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

1、this关键字：

（1）用于区分局部变量与成员变量重名问题，this代表成员变量。

package Circle;

public class Circle {
public double  Pi=3.1415926;
public double radius;
public Circle(double radius){
    this.radius=radius;
}
public double getRadius(){
   return radius; 
}

public void updateRadius(double radius){
   this.radius=radius;
}

public void getArea(){
    System.out.println("圆的面积:"+radius*radius*Pi);
}
}

其中，带this的是实例变量，不带this关键字的是局部变量。

（2）一个构造方法调用本类的其它构造方法：

class Person {
    private String name;
    private int 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;
    }

    public Person(String name) {
        this.name = name;
    }

    public Person(String name, int age) {
        this(name);
        this.age = age;
    }

    public String toString() {
        return "Tom [name=" + name + ", age=" + age + "]";
    }
}

public class ThisDemo {
    public static void main(String[] args) {
        Person per = new Person("Tom", 12);
        System.out.println(per.toString());

    }
}

注意：this()调用构造方法的语句必须放在构造方法的首行。

如图：调换位置后报错。

 2、super关键字

（1）子类继承父类所有的成员变量和成员方法，但不继承父类的构造方法。在子类的构造方法中可使用语句 super(参数列表) 调用父类的构造方法。

创建Person类：

public class Person {
    protected String name;
    private int 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;
    }

    public void sleep() {
        System.out.println("睡觉");
    }

    public void eat() {
        System.out.println("吃饭");
    }
    public Person(String name,int age){//父类的构造方法
        this.name=name;
        this.age=age;
    }
}

创建Student类：

public class Student extends Person {
    public Student(String name, int age) {//子类的构造方法，调用父类的构造方法
        super(name, age);//super（）语句必须在第一句
    }

    public void study() {
        System.out.println(name + "在学习，他" + super.getAge() + "岁了");
    }

}

测试类：

public class Test {
    public static void main(String[] args) {
        Student s = new Student("Tom",12);
        s.study();
    }
}

 （2）如果子类的构造方法中没有调用父类构造方法，则在产生子类的实例对象时，系统默认调用父类无参数的构造方法：

创建父类Person类：

public class Person {
    protected String name;
    protected int 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;
    }

    public void sleep() {
        System.out.println("睡觉");
    }

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

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
        System.out.println("父类无参的构造方法被调用了");
    }
}

创建Student类，继承Person类：

public class Student extends Person {
    // public Student(String name,int age){//子类没有调用父类的构造方法
    // super(name,age);
    // }

    public void study() {
        System.out.println(name + "在学习，他" + super.getAge() + "岁了");
    }

}

子类的构造方法未调用父类的构造方法，要保证父类中有无参的构造方法。

测试类：

public class Test {
    public static void main(String[] args) {
        Student s = new Student();
        s.study();
    }
}

 注意：如果将父类无参的构造方法去掉，程序将报错。

所以：如果子类构造方法，未调用父类的构造方法，需要在父类中定义一个“不做事的”构造方法。

此例中可在父类中定义空参的构造方法：

public Person（）{

}

（3）super（子类）调用父类的成员变量和成员方法（处理子类与父类的成员变量或成员方法同名问题）：

子类中的成员变量或方法名优先级高，所以子类中的同名成员变量或方法就隐藏了父类的成员变量或方法，但是我们如果想要使用父类中的成员变量或方法，就需要用到super关键字。

 创建动物类：

package super调用父类变量;

public class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    public Animal() {

    }
}

创建Cat类：

package super调用父类变量;

public class Cat extends Animal {
    protected String name;

    public Cat(String Animalname, String Catname) {
        super.name = Animalname;
        name = Catname;
    }

    public String toString() {
        return "我是" + super.name + ",我叫" + name;
    }
}

测试类：

package super调用父类变量;

public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat("猫科动物", "Tom猫");
        System.out.println(cat.toString());
    }
}

 在同名的问题上：this关键字用于处理本类的属性和方法同名，而super关键字用于解决子类和父类的同名问题。

3、final关键字

• final意思是，最终，如果一个类不想被子类继承，或者不想被子类的方法重写，可以用final修饰此类，final类中的方法默认也会是final类型的。final关键字可以修饰类、类的成员变量、类的成员方法、局部变量。
• 将变量或方法声明为final，可以保证它们在使用中不被改变。如：String类就是final的，当然它声明为final类型的类有一部分因素是不想被重写，提高安全性，但是还有其他的因素：https://www.cnblogs.com/zhai1997/p/12354769.html

（1）被final关键字修饰后的变量（成员变量、局部变量）只能赋值一次，final修饰后的变量只能在这个类的内部使用，不能在类的外部直接使用：

 运行结果为：90 

再向a赋值时出现错误：

 （2）引用类型的变量值为对象地址值，赋值之后，地址不能再更改，但是地址内的对象属性值可以修改。

 如图：再次向Cat对象赋值时，报错。

（3）final 标记的成员变量必须在声明的同时或在该类的构造方法中显式赋值，这两种赋值方式只能任选其一，赋值成功后该变量就不能再修改了，被final修饰的方法野之能使用，不能重写

赋值之后错误消失：

 4、static关键字

static关键字可以修饰成员变量、成员方法、代码块。它们都被称为静态成员，归整个类所有，不依赖于类的特定实例，为类的所有实例所共享。

（1） 静态变量和实例变量：

静态变量：在加载类的时候为静态变量分配一次内存（java虚拟机只为静态变量分配一次内存）。在类外，可以通过类名直接调用。

实例变量：每创建一个实例java虚拟机就为实例变量就分配一次空间。

（2）被static关键字修饰后的成员变量属于整个类，不属于类的某个对象。

例如：

在StaticDemo类中定义一个static类型的成员变量：

public class StaticDemo {
public static int a=1;
}

创建测试类：

public class Test {
    public static void main(String[] args) {
        StaticDemo ad1 = new StaticDemo();
        ad1.a = 100;
        System.out.println(ad1.a);
        StaticDemo ad2 = new StaticDemo();
        System.out.println(ad2.a);

    }

}

两次输出的值都为100.

改变一个对象的值，另外一个对象的值也跟着改变。

2、被static修饰的成员方法：

（1）静态方法不依赖于任何人对象，没有this关键字（不需要实例化）。

（2）静态不能访问非静态变量和方法（静态是在加载类的时候就已经分配了空间，而费静态的方法只有在对象调用的时候才会被分配空间）。

3、static关键字的好处：

（1）不用创建对象，也能使用类中的属性和方法；

（2）效率高；不用多次占用内存。