this关键字、super关键字、final关键字、static关键字

1、this关键字

（1）功能：

------------------------（一）调用本类中的属性，也就是成员变量。哪个对象调用了this所在函数，this就代表哪个对象。

------------------------（二）调用本类中的其他方法

------------------------（三）调用本类中的其他构造方法，调用时要放在构造方法的首行

public class TestThis {
    public static void main(String[] args) {
        Person2 p = new Person2(10,"daming");
        p.show();
        Person2 p1 = new Person2(20);
        p1.show();
    }
}
public class Person2{
    private int age;
    private String name;
    
   public Person2(){
        System.out.println("调用了无参构造函数");
    }
    
    public Person2(int a){
        this();
        age = a;
        System.out.println("调用了有参构造函数包含年龄"+"age="+age);
    }
   public Person2(int a,String n){
        this(a);
        age = a;
        name = n;
        System.out.println("调用了有参构造函数包含年龄和名称"+"age="+age+"--"+"name="+name);
    }
    
   public  void show(){
        System.out.println("调用了有参构造函数void---"+"age="+age+"--"+"name="+name);
    }
}
/*
    p.show();
    调用了无参构造函数
    调用了有参构造函数包含年龄age=10
    调用了有参构造函数包含年龄和名称age=10--name=daming
    调用了有参构造函数void---age=10--name=daming
    p1.show();
    调用了无参构造函数
    调用了有参构造函数包含年龄age=20
    调用了有参构造函数void---age=20--name=null
 */

 （2）调用构造方法

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

构造方法调用格式：

this(参数列表);

package demo03;

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

package demo03;

public class Test {

    public static void main(String[] args) {
        Person a = new Person("a",2);
        a.setAge(1);
        
        System.out.println(a.getAge()+a.getName());
        

    }

}

this原理图解：

Public class Person {
    private int age;
    private String name;

    Person() {
    }
    Person(String nm) {
        name = nm;
    }
    Person(String nm, int a) {
        this(nm);
        age = a;
    }
}

class PersonDemo {
    public static void main(String[] args) {
        Person p = new Person("张三", 23);
    }
}

 

图例解释：

（自己的理解）先执行main方法，main方法压栈，然后执行new person（）

看到new一个对象，就在堆中划出一块区域，分配内存地址，接着成员变量默认值初始化；

构造方法Person（String nm , int a））压栈，将“张三”传递给nm，23传给age，当赋值结束后，Person（String nm , int a）弹栈。

Person对象在内存中创建完成，并将0x33赋值给main方法中的p引用变量。

官方解释：

1、先执行main方法，main方法压栈，执行其中的new Person(“张三”,23);

2、堆内存中开辟空间，并为其分配内存地址0x33，，紧接着成员变量默认初始化（name=null  age = 0）；

3、拥有两个参数的构造方法（Person（String nm , int a））压栈，在这个构造方法中有一个隐式的this，因为构造方法是给对象初始化的，那个对象调用到这个构造方法，this就指向堆中的那个对象。

4、由于Person（String nm , int a）构造方法中使用了this(nm);构造方法Person(String nm)就会压栈，并将“张三”传递给nm。在Person（String nm , int a）构造方法中同样也有隐式的this，this的值同样也为0x33，这时会执行其中name = nm，即把“张三”赋值给成员的name。当赋值结束后Person（String nm , int a）构造方法弹栈。

5、程序继续执行构造方法（Person（String nm , int a）中的age = a；这时会将23赋值给成员属性age。赋值结束构造方法（Person（String nm , int a）弹栈。

6、当构造方法（Person（String nm , int a）弹栈结束后，Person对象在内存中创建完成，并将0x33赋值给main方法中的p引用变量。

 this代表什么：

this代表的是对象，具体代表哪个对象呢？哪个对象调用了this所在的方法，this就代表哪个对象。

调用其他构造方法的语句必须定义在构造方法的第一行，原因是初始化动作要最先执行。

（3）成员变量与局部变量同名问题：可以在成员变量名前面加上this.来区别成员变量和局部变量

public class Person {
    private int age;
    private String name;

    // 给姓名和年龄初始化的构造方法
    public 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 class PersonDemo {
    public static void main(String[] args) {
        Person p = new Person("张三", 23);
        p.speak();
    }
}

 this应用：

package demo05;

public class Person {
    private int age;
    private String name;

    // 给姓名和年龄初始化的构造方法
    public 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;
    }
}

public class Teat {

    public static void main(String[] args) {
        Person a=new Person("张三",18);
        a.speak();
        Person b=new Person("李四",20);
        b.speak();
        boolean bs=a.equalsAge(b);//-----------------------------------------比较
        System.out.println(bs);
    }

}

2、super关键字

（1） 子父类中构造方法的调用

格式：

调用本类中的构造方法

this(实参列表);

调用父类中的空参数构造方法

super();

调用父类中的有参数构造方法

super(实参列表);

例如：

为什么子类对象创建都要访问父类中的构造方法？因为子类继承了父类的内容，所以创建对象时，必须要先看父类是如何对其内容进行初始化的，看如下程序：

public class Fu{
    int num ;
   public Fu(){
        System.out.println("Fu构造方法"+num);//-----------------------------------------------------------------空参构造
        num = 4;
    }
}

public  class Zi extends Fu{
  public  Zi(){
         //super(); 调用父类空参数构造方法
        System.out.println("Zi构造方法"+num);//-------------------------------------------------------------------
    }
}

public class Test {
    public static void main(String[] args) {
        new Zi();//-----------------------------------------------------------------------------------------------
    }
    
}

子类构造方法执行时中，调用了父类构造方法，这说明，子类构造方法中有一句super()。

子类会继承父类中的内容，所以子类在初始化时，必须先到父类中去执行父类的初始化动作。这样，才可以使用父类中的内容。

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

 子类对象创建中的注意点：

一、如果子类的构造方法第一行写了this调用了本类其他构造方法，那么super调用父类的语句是没有的。

因为this()或者super(),只能定义在构造方法的第一行，因为初始化动作要先执行。

二、父类构造方法中有隐式的super，只要是构造方法默认第一行都是super();

三、super调用的是所有对象的父类Object构造方法（Java体系在设计，定义了一个所有对象的父类Object）

 注意：

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

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

 练习：

练习：描述学生和工人这两个类，将他们的共性name和age抽取出来存放在父类中，并提供相应的get和set方法，同时需要在创建学生和工人对象就必须明确姓名和年龄

package lianxi2;

public class Person {
    private String name;
    private int age;
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
}

package lianxi2;

public class Student extends Person{
    //Student类的构造方法
    public Student(String name,int age){
        // 使用super关键字调用父类构造方法，进行相应的初始化动作
        super(name,age);
    }
    public void study(){
        System.out.println(this.getName()+"同学正在学习");
    }
}

package lianxi2;

public class Worker extends Person{
    public Worker(String name, int age){
        // 使用super关键字调用父类构造方法，进行相应的初始化动作
        super(name, age);
    }
    public void work(){
        System.out.println(this.getName() + "工人在工作");
    }
}

package lianxi2;

public class Test {

    public static void main(String[] args) {
        Student stu = new Student("小明",23);
        stu.study();        
        Worker w = new Worker("小李",45);
        w.work();
    }

}

 3、final关键字

（1）final 关键字的概述：

类中的部分方法功能是固定的，不想让子类重写。可是当子类继承了这些特殊类之后，就可以对其中的方法进行重写，要解决这个问题（让子类无法对父类中的某一方法进行重写）

需要使用到一个关键字final，final的意思为最终，不可变。final是个修饰符，它可以用来修饰类，类的成员，以及局部变量。不能修饰构造方法。

 （2）final的特点：

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

 例如：

public class person {}//定义一个person类
public final class Fu extends person{} //定义一个父类，继承了person类
public class Zi extends Fu{} //定义子类，因为父类中使用了final所以不能继承Fu类

 ------------------- final修饰的方法不可以被子类重写,但父类中没有被final修饰方法，子类重写后可以加final。

 例如：

Public class Fu {    //=================================定义父类
    // final修饰的方法，不可以被覆盖，但可以继承使用
    public final void method1(){}//====================应用了final修饰的method1
    public void method2(){}//==========================定义一个方法method2
}

Public class Zi extends Fu {//====================定义一个子类，继承了父类的方法（method1没有被继承，无法重写，因为method1方法应用了final修饰）
    //重写method2方法
    public final void method2(){}//==================重写method2
}

 --------------------------------final修饰的变量称为常量，这些变量只能赋值一次。而且终身不变。

 例如：

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

 ------------------------------ 引用类型的变量值为对象地址值，地址值不能更改，但是地址内的对象属性值可以修改。（也是一次赋值终生不变）

 例如：

final Person p = new Person();

Person p2 = new Person();

p = p2; //final修饰的变量p，所记录的地址值不能改变

p.name = "小明";//可以更改p对象中name属性值

Person p2 = new Person();

p = p2; //final修饰的变量p，所记录的地址值不能改

p.name = "小明";//可以更改p对象中name属性值

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

 例如：

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

final应用举例：

//final修饰类（太监类）
//不能被继承，但可以继承其他类
public final class Fu {

}

public class Fu2 {
public final void xiuche(){
    System.out.println("失传的修车手艺");
}
public void maiche(){
    System.out.println("这是祖传的买车手艺");
}
}

public class Zi extends Fu2{
    public final void maiche(){
        System.out.println("失传的mai车手艺");
    }
}

public class Zi2 {
    public void eat(){
        final int i;
        i=3;
        //final Fu2 f=new Fu2();
        Fu2 f=new Fu2();
        f=null;
    }
}

//被final修饰的成员变量没有默认赋值
public class Zi3 {
    final String name="小明";//必须赋值
}

 4、static关键字

（1）static关键字概述：

-----------------------------不创建对象，就可以调用方法，可以通过static关键字来实现。static它是静态修饰符，一般用来修饰类中的成员。

 （2）static的特点：

-------------被static修饰的成员变量属于类，不属于这个类的某个对象。

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

 举例说明：

public class Demo {
    public static int num = 100;//==========================被static修饰过
}

public 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
    }//============================================其中一个更改了结果，所有的就都改过来了所以结果为200
}

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

 例如：

public class Student {
    String name;
    int age;
    static String schoolname;
}

public class Test {
    public static void main(String[] args) {
        Student s=new Student();
        s.name="小红";
        s.age=18;
        Student.schoolname="背景大学";//本来按照平时习惯应该是s.schoolname="背景大学"，但被static修饰过所以建议改成直接用类名访问
        Student s2=new Student();
        s2.name="小明";
        s2.age=18;
        Student.schoolname="清华大学";
                
        System.out.println(Student.schoolname+"..."+Student.schoolname);
    }

}

 注意：

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

- -------------------------------同一个类中，静态成员只能访问静态成员

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

---------------------------------多态调用方法中，编译看=左边，父类有，编译成功，父类没有，编译失败

　　　　　　　　　　　　运行，静态方法，运行父类中的静态方法，

　　　　　　　　　　　　运行，非静态方法，运行子类的重写方法

　　　　　　　　　　　　成员变量，编译运行全是父类

 定义静态常量时：

在类中定义一个静态常量，通常使用public static final修饰的变量来完成定义。此时变量名用全部大写，多个单词使用下划线连接。

定义格式：

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

 例如：

class School {
    public static final String SCHOOL_NAME = "北京大学";
    public static void method(){
        System.out.println("一个静态方法");
    }
} 

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

System.out.println(School.SCHOOL_NAME); 
School.method(); // 调用一个静态方法

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

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

interface Inter {
    public static final int COUNT = 100;
}

访问接口中的静态变量

Inter.COUNT