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

运行结果:

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

相关文章

本文从从Bitcask存储模型讲起,谈轻量级KV系统设计与实现。从...
内部的放到gitlab pages的博客,需要统计PV,不蒜子不能准确...
PCM 自然界中的声音非常复杂,波形极其复杂,通常我们采用的...
本文介绍如何离线生成sst并在线加载,提供一种用rocksdb建立...
验证用户输入是否正确是我们应用程序中的常见功能。Spring提...
引入pdf2dom <dependency> <groupId&a...