jdk1.8中super&this&static含义

前提
1.当类不声明构造方法的时候，系统会给出一个默认的无参构造方法
2.当声明了构造方法的时候 系统不会再给默认的
3.但是当 子类的构造器中没有声明 super 的时候也即是第一行
系统会给一个默认的 super(),它指向父类的无参构造器，如果父类声明了有参构造器，没有声明无参构造器，系统不会默认给无参构造器，就会报错，这时需要声明一个super(args…),

super&this

super&this定义

super定义指代表父类的存储空间标识(可以理解为父亲的引用)
相对应的
this定义为指代表当前对象的引用（谁调用就代表谁）

super用法

注意 1 2 3 super不能再静态方法中使用，代码示例看this中的合并了
4是1.8新增的，代码单独拎出来
1. super.xxx xxx–指父类的成员变量名 或者 成员对象名 –
不能写在子类的static 静态方法里面
2. super.xx(0个或者多个参数) ，指向父类的方法
不能写在子类的static 静态方法里面
----以上 1 和 2 这两种情况中，super 表示 父类本身
3. super(0个或多个参数) ，写在构造器里 ，这里指的是父类的构造方法
必须写在构造方法的第一行，不写的话默认给一个空的super()
4.固定写法，调用接口的默认方法 – 这是 1.8中新的特性
Interface.super.xxx(); 表示调用接口的default 默认实现方法,不能再静态方法中使用
Interface.ss(); 表示接口中的static 实现的实现方法，可以在静态方法中使用

package main.java.defaultt;

@FunctionalInterface
public interface Interface1 {
    default void sayhello(String hello){
        System.out.println(hello);
    }

    abstract void test1();

//    abstract void test2();
}

package main.java.defaultt;

public interface Interface2 {
    default void sayhello(String hello){
        System.out.println("2:"+hello);
    }
    //default关键字声明的默认实现
    default void sayhello2(String hello){
        System.out.println("2:"+hello);
    }

    //接口中static默认实现
    static void saywhat(){

    }
    //抽象接口
    abstract void test1();
}

package main.java.defaultt;

public class Test implements Interface1,Interface2{


    @Override
    public  void sayhello(String hello) {
        //指定调用接口父类的默认实现
        Interface1.super.sayhello("ssss");
        Interface2.super.sayhello2("ssss");
        //接口父类的静态实现
        Interface2.saywhat();
    }

    @Override
    public void test1() {

    }
    public static void main(String[] args) {
        Test test = new Test();
        //接口默认静态实现
        Interface2.saywhat();
        test.sayhello("ya");
    }
}

this用法

this关键字不能再静态方法中使用
1. this.xx xx–指的是当前对象的变量 变量和方法 不能是静态的 同super一样
2. this.xx() --指的是应用当前对象的成员方法
3. this(0个或者多个参数) 表示当前对象的构造方法 – 只能用在本类了的构造方法中
注意
　 1：在构造调用另一个构造函数，调用动作必须置于最起始的位置。
　　2：不能在构造函数以外的任何函数内调用构造函数。
　　3：在一个构造函数内只能调用一个构造函数
　　4：本类只有一个构造函数时不能使用
4. this还可以当参数传递 --即是this是当前对象，进行传递

5.有时候，我们会用到一些内部类和匿名类，如事件处理。当在匿名类中用this时，这个this则指的是匿名类或内部类本身。这时如果我们要使用外部类的方法和变量的话，则应该加上外部类的类名

package main.java.defaultt;

public class TestSuper {
    public TestSuper() {
        System.out.println("父类的构造器");
    }

    main.java.lambda.Test otherTest = new main.java.lambda.Test();

    public static String name="fg";
    public  String age="23";
    public void sayhi(String lll){
        System.out.println("TestSuper"+lll);
    }
}

package main.java.defaultt;

public class TestThis extends TestSuper{
    TestChild child;

    public TestThis(TestChild child) {
        this.child = child;
    }
    
    public void out(){
        child.demo();
        System.out.println(child.dfg+"ddd"+child.address);//this传递了多个参数
    }

  int i = 0;
    public void Theaderr() {
        Thread thread = new Thread() {
            public void run() {
                for (int j=0;j<20;j++) {
                    TestThis.this.run();
                    //调用外部类的方法, 有时候，我们会用到一些内部类和匿名类，如事件处理。
                    // 当在匿名类中用this时，
                    // 这个this则指的是匿名类或内部类本身。
                    // 这时如果我们要使用外部类的方法和变量的话，则应该加上外部类的类名
                    try {
                        sleep(1000);
                    } catch (InterruptedException ie) {
                    }
                }
            }
        }; // 注意这里有分号
        thread.start();
    }

    public void run() {
        System.out.println("i = " + i);
        i++;
    }

}

package main.java.defaultt;

public class TestChild extends TestSuper{
    String address = "address";
    String dfg = "";
    public static String teacher = "teacher";
    private TestChild(){
        super();//必须是第一位的，默认隐藏
        super.sayhi("");  //调用父类的方法   --static的调不了
        String s = super.age;  //调用父类的成员变量  --static的调不了

        System.out.println("子类构造器");
        new TestThis(this);  //传递当前对象  -- 不能再静态方法里使用，同时也传递了参数
    }
    private TestChild(String ss,String s){
        this("");
        System.out.println(ss);;
    }
    private TestChild(String ss){
        this();
        System.out.println(ss);;
    }

    public static void main(String[] args) {
        TestChild testChild = new TestChild();
    }
    public  void demo(){
        super.sayhi("");
        String anme = super.age;
        this.dfg = anme;//把参数值赋给成员变量，成员变量的值改变
        main.java.lambda.Test otheqq = super.otherTest;
    }
}

static

static表示静态的。 从理解的角度看: 共享的
静态的成份不属于某个对象，而属于类。但它可以被所有对象共享使用。
修饰过得方法与变量 是类的变量
通过类名. 的形式可以访问

1.8 之后可以在 interface 中声明 是static 的 实现方法
调用时 是接口名. 的形式
接口中不可以写静态块
基本可以与在类中表现一样

静态块
static{

}
通常是用来在静态变量的初始化
第一次加载类时被执行且只执行一次。

可能有不对的地方，请大家多多指教！