java常用关键字总结

super

1. 调用父类的非静态属性和方法
2. 调用父类的构造方法（必须写在子类构造方法的第一行）

3. 在子类构造方法中一定要调用父类构造方法，可以通过super指定调用父类的哪个构造方法，如果没有指定，在实例化子类时会自动调用父类的无参构造方法。

   class Test02 {
   Test02(){
       System.out.println("父类的无参构造方法");
   }
   }
   public class Test01 extends Test02 {
   Test01(int v){//自动调用父类的无参构造方法
       System.out.println("子类的有参构造方法");
   }
   Test01(){
       System.out.println("子类的无参构造方法");
   }
   public static void main(String[] args) {
       new Test01(5);
       new Test01();
   }
   }

   运行结果：
   

4. 如果父类没有无参构造方法,子类的构造方法必须手动通过super调用父类有参构造方法，否则会报编译错误

class Test02 {
    Test02(int v){
        System.out.println("父类的有参构造方法");
    }
}
public class Test01 extends Test02 {
    Test01(int v){
        super(v);
        System.out.println("子类的有参构造方法");
    }
    Test01(){
        super(7);//注掉该行Test01()处会飘红
        System.out.println("子类的无参构造方法");
    }
    public static void main(String[] args) {
        new Test01(5);
        new Test01();
    }
}

this

1. 访问本类的成员变量，解决成员变量与局部变量名称冲突问题
2. 调用成员方法
3. 调用构造方法（只能在构造方法中调用，必须在第一行，不能互相调用）
   ps:根据形参列表判断调用的是哪个构造方法

public class Test01 {

    private int id;

    Test01(){
        System.out.println("无参构造方法");
        this.method();
    }

    Test01(int a,int b){
        this(a);
        System.out.println("有参构造方法2:"+a+","+b);
    }

    Test01(int id){
        this();
        this.id = id;
        System.out.println("有参构造方法1:"+id);
    }

    public void method(){
        System.out.println("方法1");
    }

    public static void main(String[] args) {
        new Test01(10,20);
    }
}

运行结果：

final

1. 代码级别：顶级，成员级别，方法级别
2. final 修饰的类==不能被继承==
3. 修饰的方法==不能被子类重写==
4. 修饰的变量是常量，只能赋值一次
5. 修饰的变量是成员变量时，虚拟机不会对其初始化

class Test02{
    public final void  method(){//final修饰，表明该方法为最终方法，不可以被覆盖重写
        System.out.println("final修饰的方法");
    }
}

public class Test01 extends Test02 {

    final int ID = 10;
    int num = 9;

//    public void method(){//会报错:‘method()‘不能覆盖‘review.Test02‘ 中的 ‘method()‘;重写方法是 final
//
//    }

    public static void main(String[] args) {
//         new Test01().id = 100;//报错:无法为 final 变量 ‘id‘ 赋值
        System.out.println(new Test01().num);//9
    }
}

abstract

1. 代码级别：顶级，成员级别
2. 包含抽象方法的类必须声明为抽象类
3. 抽象类不可以被直接实例化，只能通过子类的实例化
4. 抽象方法必须被子类覆写，因此==限定符不可以是private==
5. ==抽象方法不可以被static修饰==，如果用static修饰了，那么我们可以直接通过类名调用，而抽象方法压根就没有主体，没有任何业务逻辑，这样就毫无意义了
6. ==抽象类不能用final修饰==

abstract class Test02{

    public abstract void method();

    public void method2(){
        this.method();//此处的this代表的是继承该类的类，而不是该类本身
        System.out.println("抽象类内部可以有普通方法");
    }
}

public class Test01 extends Test02 {

    @Override
    public void method() {
        System.out.println("实现抽象类的抽象方法");
    }
    public static void main(String[] args) {
       Test02 test02 = new Test01();
       test02.method();
       System.out.println("===========");
       test02.method2();
    }

}

运行结果：

static

1. 修饰成员变量，成员方法，内部类，代码块
2. 代码级别:成员级别
3. 与对象解绑：非静态的属性和方法属于所在类的对象，静态的属性和方法与对象解绑，属于所在类！！
4. 访问方式：
   类名.静态属性/方法 （推荐）
   对象名.静态属性/方法
5. 静态方法只能访问用static修饰的属性和方法（没有被static修饰的属性和方法需要创建对象再访问）。非静态方法可以访问静态方法和属性
6. 静态方法中不能出现 this 关键字！！！
7. static 修饰的代码块和成员变量在类加载时执行！执行顺序为书写顺序
8. static 只能修饰内部类！！！
   原因：static实现与对象解绑，外部类都没有所属对象，何来解绑一说！

class Test02 {
    Test02(int v){
        System.out.println("父类的有参构造方法");
    }
}
public class Test01 extends Test02 {

    static class Inner{
        Inner(int v){
            System.out.println("静态内部类的构造方法");
        }
    }

    class Inner2{
        Inner2(int c){
            System.out.println("普通内部类的构造方法");
        }
    }

    static int id;

    Test01(){
        super(7);
        System.out.println("子类的无参构造方法");
    }

    static void mathod(){
        System.out.println("子类的静态方法");

    }

    public static void main(String[] args) {
        int a = Test01.id;
        Test01.mathod();
        System.out.println("===========华丽的分割线===========");
        Test01 test = new Test01();
        int b = test.id;//合法但不推荐
        test.mathod();//合法但不推荐
        System.out.println("===========华丽的分割线===========");
        Test01.Inner2 inner2 = new Test01().new Inner2(1);//普通内部类的调用
        Test01.Inner inner = new Test01.Inner(4);//静态内部类的调用

    }
}

运行结果：

补充：

class Test1004{
    public static Test1004 a = new Test1004();
    public static Test1004 b = new Test1004();
    {
        System.out.println("构造代码块");
    }
    static{
        System.out.println("静态代码块");
    }
}

public class StaticDemo {
    public static void main(String[] args) {
       Test1004 t = new Test1004();
    }
}

运行结果：

访问限定符

• private (类访问级别)：修饰类的成员，则该成员只能被该类的其他成员修饰，其他类无法直接访问
• default(包访问级别): 如果一个类或者成员没有声明访问限定符，则默认为该访问限定符。被该访问限定符修饰的成员或类只能被本包下的其他类访问
• protested (子类访问级别)：被该修饰符修饰的成员可以被同一包下的其他类访问，也能被不同包下该类的子类访问
• public（公共访问级别）：被public修饰的类或者成员，可以被所有的类访问

原文地址：https://blog.51cto.com/14233363/2442411