final
static
this
super

1.final（四种用法）

1.修饰局部变量（只能一次赋值，终生不变）

修饰基本数据类型：修饰的数据变量值不可变
修饰引用数据类型：地址值不可变，内容可以变

注意事项：

1 错误：

 public static void main(String[] args) {
        final int c = 0;
        for (int i=0;i<10;i++)
        {
            c=i;                        //错误：无法为最终变量c分配值
        }
    }

2正确：

 public static void main(String[] args) {
        for (int i=0;i<10;i++)
        {
            final int c = 0;            //正确：局部变量，每次循环释放掉
        }
    }

2. 修饰成员变量（变量的数据值不可变）

成员变量有默认值，final修饰后需要手动赋值
通过构造方法对final修饰的成员变量进行赋值，需要保证所有重载的构造方法对final修饰的成员变量进行赋值，保证其修饰变量的初始化

选其一：

public class Demo {
    private final String name = "桑凤娇";//直接赋值
    public Demo(){}
    }

public class Demo2 {
    private final String name ;
public Demo2()
	{
    		name = "桑凤娇";//通过构造方法赋值
	}
 public Demo2(String name) {
        this.name = name;//通过构造方法赋值
    }
}

3.修饰类

用final修饰的这个类不能有任何子类

注意：一个类如果是final修饰的，其中所有的成员方法都无法进行覆盖（因为没有子类）

被final修饰的类，final类中的成员变量可以根据自己实际需要设计成final
final类中的成员方法都会被隐式指定为final方法

修饰方法

用final修饰的方法不能被覆盖（不能重写：override）

2.static

static修饰的内容（随类的加载而加载，且加载一次；存储于固定的内存区域(静态区)，所以直接用类名进行调用；优先于对象存在，所以可以被所有对象共享）

修饰成员变量和成员方法，其中被修饰的成员都属于类，而不是单单属于某个对象，使用时用类可以直接调用，而不需要创建对象

类变量定义格式：static int num = 10;（static 数据类型变量名;）
类方法定义格式：public static 返回值类型方法名(){ }

没有被static修饰的成员变量称为实例变量，实例变量属于某个对象
类方法使用及其注意事项：

使用：

static修饰的方法都属于静态方法（类方法），使用类名.方法名调用
定义格式：public static 返回值类型方法名（参数列表）{}

注意：

package com.day02;
/**
 * @author SFJ
 * @date 2019/11/8
 * @time 22:19
 **/
public class Test1 {
    private String name="桑凤娇";
    static String idCard ="3709211998092033**";
    public static void method1()
    {
        method2();//错误，静态方法不可以直接访问非静态成员方法
        new Test1().method2();//正确，静态方法创建匿名对象访问非静态成员方法
        System.out.println(name);//错误，不可以直接访问非静态成员变量
        System.out.println(idCard);//正确，可以直接访问静态成员变量
    }
    public void method2()
    {
        System.out.println(idCard);//正确，非静态方法可以访问静态变量
        method1();//正确，非静态方法可以访问静态方法
    }
    public static void main(String[] args) {
        Test1 test1 = new Test1();
        test1.method2();
    }
}

静态方法不能直接访问普通变量和成员方法，需要创建对象进行访问
静态方法可以直接访问静态方法和静态成员变量
在非静态方法中可以访问静态方法和静态成员变量
在静态方法中，不能直接使用super和this关键字

静态代码块：

定义在类的内部，任何方法的外部
定义格式： static{}

主要作用是给类变量进行初始化赋值

3.this(表示对当前对象的引用)

区分同名的函数参数和成员变量（this.成员变量名=参数----最常用）
在构造方法中(this()或者this(参数列表)，只能引用一个构造方法且只能在第一句)
注意：this不能用在static修饰的方法中，因为static修饰的方法属于类，而this指的是对对象的引用，冲突矛盾

package com.day02;

/**
 * @author SFJ
 * @date 2019/11/8
 * @time 22:53
 **/
public class Test3 {
        private int i=0;
        Test3(int i) {//第一个构造器：有一个int型形参
            this.i = i + 1;//此时this表示引用成员变量ｉ，而非函数参数ｉ
            System.out.println("Int constructor i——this.i:  " + i + "——" + this.i);
            System.out.println("i-1:" + (i - 1) + "this.i+1:" + (this.i + 1));
            //从两个输出结果充分证明了i和this.i是不一样的！
        }
        Test3(String s){ //  第二个构造器：有一个String型形参
            System.out.println("String constructor:  "+s);
        }
        Test3(int i,String s){//  第三个构造器：有一个int型形参和一个String型形参
            this(s);//this调用第二个构造器
            this.i=i++;//this以引用该类的成员变量
            System.out.println("Int constructor:  "+i+"/n"+"String constructor:  "+s);
        }
        public Test3 increment(){//增量
            this.i++;
            return this;//返回的是当前的对象，该对象属于（Test3）
        }
        public static void main(String[] args){
            Test3 t0=new Test3(21);
            Test3 t1=new Test3("桑凤娇");
            Test3 t2=new Test3(21,"桑凤娇");
            System.out.println(t1.increment().increment().increment().i);
            //t0.increment()返回一个在t0基础上ｉ++的Test3对象，
            //接着又返回在上面返回的对象基础上i++的Test3对象！
        }

    }

4.super(表示父类的引用)

子父类存在着同名的成员（包括变量和方法）时，在子类中默认是访问子类的成员，可以通过super关键字指定访问父类的成员；
创建子类对象时，默认会先调用父类无参的构造方法，可以通过super关键字指定调用父类的构造方法：

如果在子类的构造方法上没有指定调用父类的构造方法，jvm会在子类的构造方法内加上super()语句
super关键字调用父类构造函数时，该语句必须要是子类构造函数中的第一个语句
super与this关键字不能同时出现在同一个构造函数中调用其他的构造函数。因为两个语句都需要第一个语句

继承中，只要创建子类对象，默认一定会先调用父类无参构造方法创建父类对象

package com.day02;

/**
 * @author SFJ
 * @date 2019/11/8
 * @time 23:08
 **/
public class Test4 {
    public static void main(String[] args) {
        Son s = new Son(3);
        System.out.println();  //4
    }
}
class Father {
    int x = 1;
    Father() {
        System.out.println("父类无参的构造方法");
    }
    Father(int x) {
        this.x = x;
        System.out.println("父类有参的构造方法");
    }
    void speak() {
        System.out.println("我是父类");
    }
}
class Son extends Father {
    int y = 1;
    Son() {
        System.out.println("子类无参的构造方法");
    }
    Son(int y) {
        this.y = y+x;
        System.out.println("子类带参的构造方法");
    }
    void run() {
        super.speak(); //访问父类的函数
        System.out.println("我是子类");
    }
}

Firefly-

Java常见关键字及其用法（上）