Java笔记：类和对象

Java类和对象

类是在编程中经过编写的，拥有成员变量和一些方法的一种数据类型，可以由自己通过联系现实中的事物进行编写，关键字是class，一个Java源文件只能含有一个public类，且该类名称与文件名相同。类是对现实中具体事物的一种表示，并且需借由类创建对象，称为类的实例化，一个对象就是一个类的实例化，由一个类可以创建多个对象，这些同属一个类的对象便拥有定义类时类中定义含有的成员变量和方法。可粗略地把Java中类看做含有可以操作其成员变量的结构体。

类的储存

每个类可以包含成员变量和方法，成员变量储存由类定义的对象的一些参数，方法表示对象所能完成的一些行为。类属于引用数据类型，同其他引用数据类型一样，在栈中存放其引用地址，指向存储在堆中的实际值，包括非静态成员变量。以后文中的testClass为例，想要创建一个该类的对象，需要执行：testClass theObject = new testClass(); 语句，前半段是将theObject变为引用变量，后半段开辟空间，并根据参数调用相应的构造方法。单独的testClass只能声明引用而不能开辟空间并定义对象。
由类定义对象时，在堆中为其开辟空间，包括对象头、Class对象指针、实例成员变量和内存填充。对象头占8个字节、指针占4个字节、实例成员变量中，基本数据类型按照其本身所占字节数进行计算，引用数据类型占4个字节，最后一个对象所占的所有字节数需为8的倍数，用内存填充补齐。对象头指向Class对象，再借由Class对象找到方法区中的方法表，方法表中存放着每个类的方法和静态成员变量，方法表和静态成员变量在方法区中只有一个存储的位置，也就对于每个类只有一份。

对象的初始化

对象的初始化，即将由类定义的对象的实例成员变量值初始化、赋初值。方式有以下几种：
1、 调用类中定义的构造方法：构造方法的名称需与类的名称相同，构造方法允许方法重载，对构造方法来说，即为方法的参数列表不同，因而无参的构造方法只能有一个，无参的构造方法可以通过this关键字调用有参的构造方法，this()，括号中根据填入参数不同，调用相应的有参构造方法。除在构造方法之外，不能在其他方法中通过this调用构造方法。在构造方法中，this只能使用一次且必须在构造方法的最前端，或许可以如下理解：若由this引用的构造方法放在了后面，则该构造方法中位于this之前的初始化语句就没有用了。
2、 通过普通方法对成员变量赋值：即便是将成员变量设置为访问权限需求最高的private，该成员变量仍有类内访问权限，类中方法可以对成员变量进行引用和修改。
3、 调用静态块对静态成员变量赋值：静态块和静态方法只能修改静态成员变量，在其他方法中也可修改静态成员变量。
4、 通过实例块对成员变量赋值：可以修改静态成员变量和非静态成员变量。

一个类的初始化顺序

一个类可能会含有静态成员变量、静态块、实例成员变量、实例块、构造方法和普通方法。
在类的实例化定义对象时他们的初始化也有顺序，普通方法不经引用无法实现，用下面的代码观察初始化顺序。

public class testClass {

    int i;
    static test2 t = new test2();
    test0 t0 = new test0();

    static{
        System.out.println("静态块");
    }

    {
        System.out.println("实例块");
    }

    testClass(){
        System.out.println("构造方法");
    }

}

class test2{
    test2(){
        System.out.println("静态成员变量");
    }
}

class test0{
    test0(){
        System.out.println("普通成员变量");
    }
}

在其他位置中通过调用testClass的无参构造方法，通过打印的顺序可以得出各个部分的初始化顺序：静态成员变量、静态块、普通成员变量、实例块、构造方法。这也解释了为什么不能在静态块中对普通成员变量进行操作，在初始化静态块时，普通成员变量还没有被初始化，因而不能调用。

几个关键字

this关键字

this代表由类定义的一个对象自身，因此能用this.来调用自身的所有成员变量和方法。

static关键字

Static，静态，用static可以修饰变量和方法使其成为静态变量和静态方法，静态方法归类所有而不归对象所有，每个类只有一份。

final关键字

final关键字的作用有：1、修饰变量；2、修饰方法；3、修饰类

1、修饰变量：Final修饰的变量将变为不能更改值的常量；

class Cat{
    final int age;
    public Cat(int age){
        this.age = age;
    }
}

此处将Cat类中的age成员变量定义为final，在构造时赋初值。在其他地方写入下面的语句：

Cat cat1 = new Cat(5);
System.out.println(cat1.age++);//!

第二句发生错误，由final修饰的变量一经赋值后，便不能为其分配新的值。

2、用final修饰方法

用final修饰的方法也被锁定而不能更改，子类继承父类时，父类中的final方法可被子类继承，不能被子类重写，而在父类中final方法可以被重载，可被重载为final方法或非final方法。此处提到方法的重载：即在同一类中两个方法使用同一方法名，根据返回值和参数列表区分该调用哪个方法。沿用上面的Cat类，getAge方法两次重写，在类中不论是否由final修饰都可被重写。

final void getAge(){
    System.out.println(this.age);
}

void getAge(String name){
    System.out.println(this.age);
}

final void getAge(int years){
    System.out.println("this cat will be " + (this.age+years) + " after " + years + " years" );
}

3、用final修饰类

当用final修饰类时，该类无法被继承，即没有子类。

单例模式

即每个类只有一个对象，实现单例。

1、 重点在于将构造方法设为类的私有，不允许在类外定义新对象，而将在类中的对象、返回静态对象的方法设为归类所有的static类型，每个类只有一份，从而使归对象所有的该类成员变量只被引用了一次。后续再执行new操作也只是为第一次生成的对象加一个引用变量。

class singleExample{

    private static singleExample theExample = new singleExample();
    private int i;
    private singleExample(){
        i = 0;
    }

    public static singleExample returnTheExample(){
        return theExample;
    }

    public void setI(int num){
        this.i = num;
    }

    public int getI(){
        return this.i;
    }
}

放在其他地方的引用该类：

singleExample theExample = singleExample.returnTheExample();
theExample.setI(5);
singleExample theExample2 = singleExample.returnTheExample();
System.out.println(theExample2.getI());

在设置theExample的成员变量i为5后，重新new一个theExample2对象，并打印theExample的i，输出为5，此时的theExample2只是该类中静态对象的新引用。

2、 构建单例模式，可以在定义成员变量的时候进行对象的定义，也可在调用该方法时进行对象的定义，在调用方法时需加以判断，若引用为空，则new对象，若非空，仍返回原对象theExample，由于theExample为静态，因此不被改变：

3、  class singleExample2{

    private static singleExample2 theExample;
    private int i;

    private singleExample2(){
        i = 0;
    }

    public static singleExample2 returnTheExample(){
        if(theExample == null){
            theExample = new singleExample2();
        }
        return theExample;
    }

    public void setI(int num){
        this.i = num;
    }

    public int getI(){
        return this.i;
    }


}

访问修饰符

访问修饰符可用来修饰类、成员变量、方法，使其能在不同大小的区域被调用

default：写default或什么也不写，拥有包访问权限，同一包内可访问调用。
Private：仅在同一类中可被调用，但不能修饰外部类。
Public：在任何地方都可调用，但需在java文件开头加入包名才可引用public类。
Protected：同包中可调用，但多用于继承时修饰父类成员变量或方法，使其可以在子类中使用。不能修饰外部类。

为体现封装性，一般将类的成员变量设置为private，并通过自定义几个public方法向内或向外传值达到调用成员变量或更改成员变量值的操作。

方法重载

在同一类中，多个方法可以同名且参数列表不同，称为方法重载。可以为想进行的操作传递不同的参数类型。但多个方法方法名相同、返回值类型不同、参数列表相同是不允许的。例如：

class cat{
    public cat(){}

    public void eat(){
        System.out.println("cat eat");
    }

    public int eat(int i){
        return i;
    }
}