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://tech.souyunku.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）效率高；不用多次占用内存。