Java类和对象

        类实质上就是封装对象属性(成员变量)和行为(方法)的载体，而对象则是类抽象出来的一个实例。

        面相对象程序设计的特点：封装，继承，多态。

1.类

1.1 成员变量

        Java中对象的属性也称为成员变量；

Book: 

package classInfo;
 
public class Book {
    private String name;    //定义一个String类型的成员变量name
 
    public String getName() {    //定义一个getName方法
        int id = 0;             //定义一个局部变量
        this.setName("春田");         //调用类中其他方法
        return id + this.name;       //设置方法返回值
    }
 
    private void setName(String name) {     //定义setName方法
        this.name = name;           //通过关键字this将参数值赋值给类的成员变量
    }
 
    public Book getBook() {
        return this;            //返回Book类引用
    }
}
 

Test:

1.2 成员方法

        权限修饰符 返回值类型 方法名(参数类型 参数名){

                                .....;         //方法体

                                            return 返回值;

                                                                                        } 

        一个成员方法可以有参数，也可以没有参数；参数可以是对象，也可以是基本数据类型的变量；同时，成员方法有返回值和无返回值的选择，如果方法需要返回值，可以在方法体中使用return关键字，使用这个关键字后，方法的执行将被终止；成员方法无返回值，可以使用void关键字定义。

1.3 权限修饰符

1.4 局部变量

        局部变量在类的成员方法被执行时才创建，在方法执行结束时被销毁；局部变量在使用时必须进行赋值操作或被初始化，否则会出现编译错误。

1.5 局部变量的有效范围

        可以将局部变量的有效范围称作变量的作用域，局部变量的有效范围从该变量的声明开始到该变量的结束为止。在互不嵌套的作用域中可以同时声明两个名称和类型相同的局部变量，在互相嵌套的区域中，不可以这么声明。

1.6 this关键字

        Java中规定使用this关键字来代表本类对象的引用，this关键字被隐式地用于引用对象的成员变量和方法，如【this.成员变量】，【this.成员方法】。

        Java中另外一种常见的调用成员变量和成员方法的方式是：【对象.成员变量】，或者【对象.成员方法】；

        this还可以作为方法的返回值，代表返回这个类对象本身。

        在getBook方法中，需要返回Book类，所以在方法体中使用return this这种形式将Book类的对象进行返回。 

        所以得出：this=本类的一个对象

2.类的构造方法

        Java中类的构造方法是一个与类同名的方法，对象的创建就是通过构造方法完成的；每当类实例化一个对象时，类都会自动调用构造方法。构造方法的特点：

        1. 构造方法没有返回值

        2.构造方法的名称与本类的名称相同

        3.构造方法不需要void关键字修饰

        当类中没有明确定义构造方法时，编译器会自动创建一个不带参数的默认构造方法。

        this关键字不但可以调用类的成员变量和类的成员方法，还可以调用类的构造方法。

        有2个构造方法时，可以在无参数的构造方法中使用this关键字调用有参数的构造方法，但这种方式只能在无参数的构造方法中的第一句使用this调用有参数构造方法。 

3.静态变量、常量和方法

        静态变量，静态常量，静态方法都是通过关键字【static】修饰定义。将一个变量、常量，方法设置为静态的，这样这个变量，常量，方法就可以在内存中被共享，所以，静态数据或者静态方法的作用通常是为了提供共享数据或方法。

        被声明为static的变量，常量，方法被称为静态成员，静态成员属于类所有，区别于个别对象，可以在本类和其他类中使用【类名.静态成员】的方式调用。

        静态成员同样要遵循private，protected，public修饰符的约束。

        语法：

        3.1 类名.静态成员

package classInfo;
 
public class StaticTest {
    final static double PI = 3.1415;  //类中定义静态常量
    static int id = 1;  //类中定义静态变量
 
    public static void method1() {       //类中定义静态方法
        System.out.println("这是类中的静态方法1的打印输出");
    }
 
    public void method2() {      //类中定义非静态方法
        System.out.println(StaticTest.PI);  //调用静态常量
        System.out.println(StaticTest.id);  //调用静态变量
        StaticTest.method1();   //调用静态方法
    }
}

        static修饰的静态方法规定：

        3.2 在静态方法中，不可以使用【this】关键字；

        3.3 在静态方法中，不可以直接调用非静态方法；

        3.4 方法体中的局部变量不能声明为static；

        3.5 static定义静态区执行类的初始化动作；

package classInfo;
 
public class StaticTest {
    //定义静态区完成类的初始化动作，只会执行1次
    static {
        int id = 2;
        final double PI = 3.1415;
        String name = "chuntian";
    }
}

4.类的主方法

        主方法是类的入口，亦是程序执行的入口，它定义了程序从何处开始；Java编译器通过主方法来执行程序，主方法语法：

public static void main(String[] args){
    //方法体
}

        4.1 主方法是静态的，所以在主方法中调用其他方法，该方法也必须是静态的；

        4.2 主方法没有返回值；

        4.3 主方法的形参是数组，其中args[0]~args[n]分别代表程序的第一个参数到第n个参数，可以使用args.length来获取参数的个数。

5.对象

        Java是一门面向对象的语言，对象时由类抽象出来的，所有的操作都通过对象来处理。

5.1 对象的创建

        5.1.1 【new】操作符来创建对象

                每实例化一个对象就会自动调用一次构造方法，实质上就是new操作符调用构造方法创建对象。语法：

        Test test = new Test();

        Test test = new Test("a");

        test对象被创建出来时，就是一个对象的引用，这个引用在内存中为对象分配了存储空间，每个对象都是相互独立的，在内存中占据独立的内存地址，并且每个对象都有自己的生命周期，当一个对象的声明周期结束时，对象就变成了垃圾，由Java虚拟机自带的垃圾回收机制进行处理，不能再被使用。

package classInfo;
 
public class CreateObject {
    public CreateObject() {      //构造方法
        System.out.println("构造方法中创建了对象");
    }
 
    public static void main(String[] args) {     //主方法
        new CreateObject();     //创建对象
    }
}
 
输出：
        构造方法中创建了对象

5.2 访问对象的属性和行为

        对象.类成员

package classInfo;
 
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() {
        System.out.println("构造方法触发了");  //定义构造方法
    }
 
    public static void main(String[] args) {
        TransferProperty t1 = new TransferProperty();   //创建一个对象
        TransferProperty t2 = new TransferProperty();   //创建另一个对象
        t2.i = 60;    //t2对象将成员变量修改为60
        //使用第一个对象调用类成员变量
        System.out.println("第一个实例对象调用成员变量i的结果：" + t1.i);
        t1.call();  //使用第一个对象调用类成员方法
 
//      TransferProperty.call();    //静态方法中不可以直接调用非静态方法
//      this.call();                //静态方法中不可以使用this关键字
 
        //使用第二个对象调用类成员变量
        System.out.println("第二个实例对象调用成员变量i的结果：" + t2.i);
        t2.call();  //使用第一个对象调用类成员方法
    }
}
 
输出：
        构造方法触发了
        构造方法触发了
        第一个实例对象调用成员变量i的结果：47
        调用了call（）方法
        -----------
        第二个实例对象调用成员变量i的结果：60
        调用了call（）方法
        -----------

5.3 对象的引用

        引用只是存放一个对象的内存地址，并非存放一个对象，对象的引用存放在栈中，对象存放在堆内存中。

5.4 对象的比较

        对象的比较有2中方式：

        5.4.1 【==】

                【==】运算符比较的是两个对象引用的地址是否相等。

        5.4.2 【equals()方法】

                【equals()方法】是String类中的方法，用于比较两个对象引用所指的内容是否相等。

package classInfo;
 
public class Compare {
    public static void main(String[] args) {
        String c1 = new String("abc");  //创还能2个String对象引用
        String c2 = new String("abc");  //c1，c2是2个不同对象，内存中存放的地址不一样
        String c3 = c1; //将c1对象的引用赋值给c3;
 
        //使用“==”运算符比较c2和c3
        System.out.println("c2==c3对吗？" + (c2 == c3));
        System.out.println("c1==c3对吗？" + (c1 == c3));
        //使用“equals()方法比较c2和c3”
        System.out.println("c2.equals(c3)对吗？" + (c2.equals(c3)));
    }
}
 
输出：
        c2==c3对吗？false
        c1==c2对吗？true
        c2.equals(c3)对吗？true

5.5 对象的销毁

        每个对象都有生命周期，当对象的生命周期结束后，分配给该对象的内存地址需要被回收。Java中拥有一整套完善的垃圾回收机制，垃圾回收器会自动回收无用却占据内存资源的对象。但是垃圾回收器只能回收那些由【new】操作符创建的对象。

        何种对象会被视为垃圾：

        5.5.1. 对象的引用技术为0，被视为垃圾，将消亡；

        5.5.2. 对象的引用超过其作用方位，被视为垃圾，将消亡；

        5.5.3. 将对象赋值为null，被视为垃圾，将消亡；

        5.5.4. 垃圾回收器只能回收那些由【new】操作符创建的对象。

                Java中提供了Object类的finalize()方法，被声明为protected,用户可以在自己的类中定义这个方法来回收那些非【new】创建出来的对象；如果用户在类中定义了这方法finalize()方法，在垃圾回收时会首先调用这个方法，在下一次垃圾回收动作发生时，才真正回收被对象占用的内存。

        垃圾回收或finalize()方法并不保证一定会发生，如果Java虚拟机内存耗尽，它将不会执行垃圾回收处理。

        5.5.5. System.gc()方法

        由于垃圾回收不受人为控制，具体执行时间也不确定，所以finalize()方法也就无法执行。因此Java提供了【System.gc()】方法来强制启动垃圾回收器，主动告知来进行清理。