面向对象程序设计的思想要以对象来思考问题，首先要将现实世界的实体抽象为对象，然后考虑这个对象具备的属性和行为。（对象）
不能将所谓的一个事物描述成一类事物，如一只鸟不能成为鸟类。类是同一类事物的统称，如果将现实世界上中的一个事物抽象成对象，类就是这类对象的统称如鸟类，畜生类、人类等类是构造对象时所依赖的规范，如一只鸟具有一对翅膀，它可以用这对翅膀飞行，而基本上所有鸟都具有有翅膀这个特征和飞行的技能，这样具备相同特征和行为的一类事物就统称为类，类的思想就这样产生的。（类是封装对象的属性和行为的载体，反过来说具有相同属性和行为的一类实体被称为类）
封装：封装是面对对象编程的核心思想，将对象的属性和行为封装起来，其载体就是类，类通常对客户隐藏其实现细节，就是封装思想。（采用封装思想保证了类内部数据结构的完整性，应用该类用户不能轻易地直接操作此数据结构，只能执行公开的数据）
继承：类与类之间同样具有关系，如一个百货公司与销售员类相联系，类之间的这种关系被称为关联。继承性主要是利用特定对象之间的共有属性。
类
对象的属性也成为成员变量。
eg:
public class Book{
private String name; //定义一个String型的成员变量
public void getName(){ //定义一个getName（）方法
int id=0; //局部变量
setName("java"); //调用类中其他办法
return id+this.name; //设置方法返回值
}
public void setName(Sting name){ //定义一个setName()方法
this.name=name; //将参数值赋予类中的成员变量
}
public Book getBook(){
return this; //返回Book类引用
}
}
成员变量：
在java语言中可以使用成员方法对应类对象的行为。以Book类为例，它包含了getName()和setName（）两个方法，这两个成员方法分别为获取图书名和设置图书名的方法。
权限修饰符 返回值类型 方法名(参数类型，参数名）{
.....//方法
return 返回值
}
一个成员方法可以有参数，这个参数可以是其他类型的变量，同时成员方法有返回值和不返回值两种情况，如果方法需要返回值可以在方法体中使用return关键字，使用该关键字后，该类方法会被终止。（无需返回值可以在方法体中使用void关键字）
成员变量方法的返回值可以是计算结果也可以是其他想要的数值和对象，返回值类型要与方法返回值的类型一致。
如果一个方法中含有与成员变量同名的局部变量，则方法中对这个变量访问以局部变量进行。
权限修饰：
| 访问位置 | private | protected | public |
| 本类 | 可见 | 可见 | 可见 |
| 同包其他类或子类 | 不可见 | 可见 | 可见 |
| 其他包的类或子类 | 不可见 | 不可见 | 可见 |
当声明类时不使用public,private,protected修饰符设置权限，则这个类预设为包存取范围，即只有一个包中的类可以调用这个类的成员变量或成员方法。
eg:
package com.lzw;
class AnyClass{
public void doString(){
//方法体
}
}
在上述代码中，由于类的权限修饰符为默认修饰符，即只有一个包内的其他类和子类可以对该类进行访问，而AnyClass类中的dostring()方法却设置为public访问权限，即使这样，dostring()方法访问权限和AnyClass()类的访问权限相同，因为java语言规定，类的权限设定会约束成员的权限设定。
上面的代码可以写成：
package com.lzw;
class AnyClass{
void dostring(){
//方法体
}
}
局部变量
局部变量是在方法执行时被创建，在方法执行结束时被销毁，局部变量在使用时必须进行赋值操作或被初始化，否则会出现编辑错误。
eg:
public String getName(){
int id=0;
setName("java");
return id+this.name;
}
（如果将id的初始化值去掉，编辑器就会出现错误）
局部变量的有效范围
可以将局部变量的有效范围称为变量的作用域，局部变量的有效范围从该变量声明开始到该变量的结束为止。
public void doString(String name){
int id=0;
for(int i=0;i<10;i++){
System.out.println(name+String.valueOf(i));
}
}
在互不嵌套的作用域中可以同时声明两个相同的局部变量。
public void doString(String name){
int id=0;
for(int i=0;i<10;i++){
System.out.println(name+string.valueOf(i));
}
for(int i=0;i<3;i++){
System.out.println(i);
}
}
但是在相互嵌套的区域中不可以这样声明，如果将局部变量id在方法体for循环中再次循环定义，就会报错。
在作用范围外使用局部变量是一个常见的错误，因为在作用范围外没有声明局部变量的代码。
this关键字
public void setName(string name){
this.name=name;
}
在上述代码中可以看到，成员变量setName()方法中的形式参数的名称相同，都为name，在java语言中规定使用this关键字来代表本类对象的引用，this关键字被隐式地用于对象的成员变量和方法，this.name指的是Book类中的name成员变量，而this.name=name语句中的第二个name则指形参name。实际上setName方法实现的功能就是将形参name的值赋予成员变量name。
public Book getBook(){
return this;
}
在getBook()方法中，方法返回值为Book类，所以方法体中使用return this这种形式将Book类的对象进行返回。
类的构造方法
在类中除了成员方法之外，还存在一种特殊类型的方法，那就是构造方法。构造方法是一个与类同名的方法，对象的创建就是通过构造方法完成的。每一类实例化一个对象时，类都会自动调用构造方法。构造方法是没有返回值，而且不需要使用void关键字进行修饰。
public book(){
//...构造方法体
}
public:构造方法修饰符
book:构造方法的名称
public class AnyThing{
public AnyThing(){ //定义无参构造方法
this("this调用有参构造方法"); //使用this调用有参构造方法
System.out.println("无参构造方法");
}
public AnyThing(String name){ //定义有参构造方法
System.out.println("有参构造方法");
}
}
静态变量、常量、方法
被static关键字修饰的变量、常量、方法被称为静态变量、常量和方法。
语法：
类名.静态类成员
public class StaticTest{
static double PI=3.1415; //静态常量
static int id; //静态变量
public static void method1(){ //静态方法
}
public void method2(){
System.out.println(StaticTest.PI); //调用静态常量
System.out.println(StaticTest.id); //调用静态变量
StaticTest.method1(); //调用静态方法
}
}
静态数据和静态方法的作用通常是为了提供共享数据或方法，如数据计算公式，以static声明并实现，
public class StaticTest{
static double PI=3.1415;
static int id;
public static void method1(){
//doSomthing
}
public void method2(){
System.out.println(StaticTest.PI);
System.out.println(StaticTest.id);
StaticTest.method1();
}
public static StaticTest method3(){
method2(); //调用非静态方法
return this； //在return语句中使用this关键字
}
}
上述代码在编辑时会报错，（1：静态方法中不可以使用this关键字；2：静态方法中不可以直接调用非静态方法）
在java中规定不能将方法体内的局部变量声明为static。例如下面的代码就是错误的
public class example{
public void method(){
static int i=0;
}
}
如果在执行类时，希望先执行类的初始化动作，可以使用static定义一个静态区域。
public class example{
static{
//some
}
}
当这段代码被执行时，首先执行static块中的程序，并且只会执行一次
类的主方法
主方法是类的入口点，他定义了程序从何处开始；主方法提供对程序流向的控制，java编辑器通过主方法来执行程序。
public static void main(String[]args){
//方法体
}
1:：主方法是静态的，所以如果要直接在主方法中调用其他方法，则该方法也得是静态的。
2：主方法是没有返回值的。
3：主方法的形参为数组。其中args[0]~args[n]分别代表程序的第一个参数到第n个参数，可以使用args.length获取参数的个数。
public class Testmain{
public static void main(String[]args){
for(int i=0;i<9;i++){
System.out.println(args[i]);
}
}
}
对象
java是一门面向对象的程序设计语言，对象是由类抽象出来的，所有的问题都通过对象来处理。
在java语言中通过new操作符来创建对象，每实例化一个对象就会调用一次构造方法，实质就是创建对象的过程。
语法：
Test test=new Test（"a"）;
eg:
public class CreateObject{
public CreateObject(){
System.out.println("创建对象");
}
public static void main(String[]args){
new CreateObject();
}
}
在上述实例的主方法中使用new操作符创建对象，创建对象的同时，将自动调用构造方法中的代码。
访问对象的属性和行为
eg：public class TransferProperty{
int i=47;
public void call(){
System.out.println("调用call()方法");
for(int i=0;i<3;i++){
if（i==2){
System.out.println(" ");
}
}
}
public TransferProperty{
}
public static void main(String[]args){
TransferProperty t1=new TransferProperty();
TransferProperty t2=new TransferProperty();
t2.i=60;
System.out.println("第一个实例对象调用变量："+t1.i++);
t1.call();
System.out.println("第二个实例对象调用变量："+t2.i);
t2.call();
}
}
如果希望成员变量不被其中任何一个对象改变，可以使用static关键字。
eg:
public class ceshi{
static int i=47;
public void call(){
System.out.println("调用call()方法");
for(int i=0;i<3;i++){
System.out.println(i+" ");
if(i==2){
System.out.println(" ");
}
public ceshi(){
}
public static void main(String[]args){
ceshi t1=new ceshi();
ceshi t2=new ceshi();
t2.i=60;
System.out.println("第一个实例对象调用变量:"+t1.i++);
t1.call();
System.out.println("第二个实例对象调用变量："+t2.i);
t2.call()
}
}
对象的引用：
在java语言中尽管一切都可以看做对象，单真正的操作标识符实质上是一个引用，那么在java中是如何体现的呢？
类名 对象引用名称
如一个Book类的引用：
Book book=new Book（）；
对象的比较：
“=="运算符比较的是两个对象引用的地址是否相等。
"equals"用于比较两个对象引用所指的内容是否相等。
eg:
public class Compare{
public static void main(String[]args){
String c1=new String("abc");
String c2=new String("abc");
String c3=c1;
System.out.println("c2==c3的运算结果:"+(c2==c3));
System.out.println("c2.equals(c3)的运算结果:"+(c2.equals(c3));
}
}
对象的销毁：
java 有一套完整的垃圾回收机制，两种类会被回收：
1：{
Example e=new Example();
}
对象e超过其作用范围，将消亡
2：{
Example e=new Example();
e=null;
}
当对象被置为null值时，将消亡
垃圾回收器只能回收由new操作符创建的对象，如果对象不是通过new操作符在内存中获取一块区域，这种对象可能不能被回收机制识别，所以java有提供了一种finalize()方法。这个方法是Object类的方法，它被声明为protected，如果用户定义了finalize()方法，在垃圾回收时会首先调用该方法，在下一次垃圾回收动作发生时，才能真正回收被对象占用的内存。