JAVA学习笔记（八）

1.1this关键字

　　构造方法之间的调用可以通过this关键字来完成

　　调用格式：

this（参数列表）;

　　实例

class Person {
    // Person的成员属性
    private int age;
    private String name;

    // 无参数的构造方法
    Person() {
    }

    // 给姓名初始化的构造方法
    Person(String nm) {
        name = nm;
    }

    // 给姓名和年龄初始化的构造方法
    Person(String nm, int a) {
        // 由于已经存在给姓名进行初始化的构造方法 name = nm;因此只需要调用即可
        // 调用其他构造方法，需要通过this关键字来调用
        this(nm);
        // 给年龄初始化
        age = a;
    }
}

1.2可以再成员变量名前加上this.来区分成员变量和局部变量

class Person {
    private int age;
    private String name;

    // 给姓名和年龄初始化的构造方法
    Person(String name, int age) {
        // 当需要访问成员变量是，只需要在成员变量前面加上this.即可
        this.name = name;
        this.age = age;
    }

    public void speak() {
        System.out.println("name=" + this.name + ",age=" + this.age);
    }

    // 判断是否为同龄人
    public boolean equalsAge(Person p) {
        // 使用当前调用该equalsAge方法对象的age和传递进来p的age进行比较
        // 由于无法确定具体是哪一个对象调用equalsAge方法，这里就可以使用this来代替
        /*
         * if(this.age == p.age) { return true; } return false;
         */
        return this.age = p.age;
    }
}

2.1super关键字

　　在创建子类对象时，父类的构造方法会先执行，因为子类中所有构造方法的第一行有默认的隐式super();语句。

　　格式

调用本类中的构造方法
this(实参列表);
调用父类中的空参数构造方法
super();
调用父类中的有参数构造方法
    super(实参列表);

　　当父类中没有空参数构造方法时，子类的构造方法必须有显示的super语句，指定要访问的父类有参数构造方法。

　　类中的构造方法默认第一行都有隐式的super()语句，在访问父类中的空参数构造方法。所以父类的构造方法既可以给自己的对象初始化，也可以给自己的子类对象初始化。

　　如果默认的隐式super()语句在父类中没有对应的构造方法，那么必须在构造方法中通过this或者super的形式明确要调用的构造方法。

3.1final关键字

　　3.1.1final的特点

　　1.final修饰类不可以被继承，但是可以继承其他类。

class Yy {}
final class Fu extends Yy{} //可以继承Yy类
class Zi extends Fu{} //不能继承Fu类

　　2.final修饰的方法不可以被覆盖,但父类中没有被final修饰方法，子类覆盖后可以加final。

class Fu {
    // final修饰的方法，不可以被覆盖，但可以继承使用
    public final void method1(){}
    public void method2(){}
}
class Zi extends Fu {
    //重写method2方法
    public final void method2(){}
}

　　3.final修饰的变量称为常量，这些变量只能赋值一次。

final int i = 20;
i = 30; //赋值报错，final修饰的变量只能赋值一次

　　4.引用类型的变量值为对象地址值，地址值不能更改，但是地址内的对象属性值可以修改。

final Person p = new Person();
Person p2 = new Person();
p = p2; //final修饰的变量p，所记录的地址值不能改变
p.name = "小明";//可以更改p对象中name属性值

　　p不能为别的对象，而p对象中的name或age属性值可更改。

　　5. 修饰成员变量，需要在创建对象前赋值，否则报错。(当没有显式赋值时，多个构造方法的均需要为其赋值。)

class Demo {
    //直接赋值
    final int m = 100;
    
    //final修饰的成员变量，需要在创建对象前赋值，否则报错。
    final int n; 
    public Demo(){
        //可以在创建对象时所调用的构造方法中，为变量n赋值
        n = 2016;
    }
}

4.1static关键字

　　static特点：

　　1.被static修饰的成员变量属于类，不属于这个类的某个对象。（也就是说，多个对象在访问或修改static修饰的成员变量时，其中一个对象将static成员变量值进行了修改，其他对象中的static成员变量值跟着改变，即多个对象共享同一个static成员变量）

class Demo {
    public static int num = 100;
}

class Test {
    public static void main(String[] args) {
        Demo d1 = new Demo();
        Demo d2 = new Demo();
        d1.num = 200;
        System.out.println(d1.num); //结果为200
        System.out.println(d2.num); //结果为200
    }
}

　　2.被static修饰的成员可以并且建议通过类名直接访问。

　　访问静态成员的格式

类名.静态成员变量名
类名.静态成员方法名(参数)

　　实例

class Demo {
    //静态成员变量
    public static int num = 100;
    //静态方法
    public static void method(){
        System.out.println("静态方法");
    }
}
class Test {
    public static void main(String[] args) {
        System.out.println(Demo.num);
        Demo.method();
    }
}

4.2static关键字注意事项

　　1.静态内容是优先于对象存在，只能访问静态，不能使用this/super。静态修饰的内容存于静态区。

class Demo {
    //成员变量
    public int num = 100;
    //静态方法
    public static void method(){
        //this.num; 不能使用this/super。
        System.out.println(this.num);
    }
}

　　2.同一个类中，静态成员只能访问静态成员变量或方法

class Demo {
    //成员变量
    public int num = 100;
    //静态成员变量
    public static int count = 200;
    //静态方法
    public static void method(){
        //System.out.println(num); 静态方法中，只能访问静态成员变量或静态成员方法
        System.out.println(count);
    }
}

　　3.main方法为静态方法仅仅为程序执行入口，它不属于任何一个对象，可以定义在任意类中。

4.3定义静态常量

　　定义格式：

public static final 数据类型 变量名 = 值;

　　当我们想使用类的静态成员时，不需要创建对象，直接使用类名来访问即可

System.out.println(Company.COMPANY_NAME); //打印传智播客
Company.method(); // 调用一个静态方法

　　接口中的每个成员变量都默认使用public static final修饰。

　　所有接口中的成员变量已是静态常量，由于接口没有构造方法，所以必须显示赋值。可以直接用接口名访问。