java常用关键字总结

super

调用父类的非静态属性和方法
调用父类的构造方法（必须写在子类构造方法的第一行）
在子类构造方法中一定要调用父类构造方法，可以通过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();
}
}
```
运行结果：
如果父类没有无参构造方法,子类的构造方法必须手动通过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();
    }
}

java常用关键字总结

this

访问本类的成员变量，解决成员变量与局部变量名称冲突问题
调用成员方法
调用构造方法（只能在构造方法中调用，必须在第一行，不能互相调用）
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);
    }
}

运行结果：
java常用关键字总结

final

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

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

代码级别：顶级，成员级别
包含抽象方法的类必须声明为抽象类
抽象类不可以被直接实例化，只能通过子类的实例化
抽象方法必须被子类覆写，因此==限定符不可以是private==
==抽象方法不可以被static修饰==，如果用static修饰了，那么我们可以直接通过类名调用，而抽象方法压根就没有主体，没有任何业务逻辑，这样就毫无意义了
==抽象类不能用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();
    }

}

运行结果：
java常用关键字总结

static

修饰成员变量，成员方法，内部类，代码块
代码级别:成员级别
与对象解绑：非静态的属性和方法属于所在类的对象，静态的属性和方法与对象解绑，属于所在类！！
访问方式：
类名.静态属性/方法（推荐）
对象名.静态属性/方法
静态方法只能访问用static修饰的属性和方法（没有被static修饰的属性和方法需要创建对象再访问）。非静态方法可以访问静态方法和属性
静态方法中不能出现 this 关键字！！！
static 修饰的代码块和成员变量在类加载时执行！执行顺序为书写顺序
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);//静态内部类的调用

    }
}

运行结果：
java常用关键字总结
补充：

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();
    }
}

运行结果：
java常用关键字总结

访问限定符

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

访问限定符	类内部	同一包的其他类	其他包的子类	其他包的其他类
private	Y	N	N	N
default	Y	Y	N	N
protested	Y	Y	Y	N
public	Y	Y	Y	Y

标题名称：java常用关键字总结
URL链接：http://cdiso.cn/article/jchcep.html

java常用关键字总结

super

this

final

abstract

static

访问限定符

其他资讯