Java基础2-final关键字和super关键字

final class不能被继承

public class Main{
    public static void main(String[] args){
        A a=new A();
        System.out.print(a.a);
    }
}
final class A{
    int a=10;
}
/*class Ason extends A{
    这里不注释掉会报错因为A是final 不可以被继承
}*/

输出结果:

10

final 方法不可以被覆盖但可以重载

public class Main{
    public static void main(String[] args){
        Ason ason=new Ason();
        System.out.print(ason.returnA(ason.a));//Ason继承了父类A的属性a=10;
    }                              //使用了重载后的returnA(int a)方法得到了a+10而不是a
}
class A{
    int a=10;
    int returnA(){
        return a;
    }
}
class Ason extends A{
   /* double returnA(){
        return 20; final方法不可以被覆盖 这里不注释掉回报错
    }*/
    int returnA(int a){
        return a+10;
    }
}

输出结果

20

final 属性不可以被修改

public class A{
 int a=10
}
public class Main{
 public static void main(String[] args){
  A a=new A();
  //a.a=20;不可以给final属性赋值！
}
} 

super.a 在子类中调用父类的属性

public class Main{
    public static void main(String[] args){
        Ason ason=new Ason();
        System.out.print(ason.returnA(ason.a));//ason
    }
}
class A{
    int a=10;
    int b=5;
    int returnA(){
        return a;
    }
}
class Ason extends A{
   /* double returnA(){
        return 20; final方法不可以被覆盖
    }*/
    int returnA(int a){
        return a+super.b;
    }
}

输出结果：15
super.b调用了父类A的属性b=5
ason.a继承了父类A的属性a=10;
两个整数相加得到15

super.returnA() 在子类中调用父类的方法

public class Main{
    public static void main(String[] args){
        Ason ason=new Ason();
        System.out.print(ason.returnA(ason.a));//ason
    }
}
class A{
    int a=10;
    int b=5;
    int returnA(){
        return a;
    }
    int return1(){
        return 1;
    }
}
class Ason extends A{
   /* double returnA(){
        return 20; final方法不可以被覆盖
    }*/
    int returnA(int a){
        return a+super.b+super.return1();
    }
}

输出结果16
同理 superreturn1();调用了父类A的return1()方法返回了整数1

子类构造过程中必须调用父类的构造方法 super(参数1,参数2,...,参数n) { } 可以调用父类的构造方法

当子类中没有调用父类构造方法时 会隐式地调用父类无参的构造方法

在程序运行过程中 要构造子类必须先构造父类 当语句中父类没有无参构造A()、而有有参构造A(int a)时 系统会认为父类A是没有无参构造方法的

如上图所示这里的A没有无参构造 所以在构造对象时产生报错

如果要加载子类 必须先构造父类 系统构造父类默认通过A()来实现 但是系统找不到A() 这时程序会报错

所以 要实现A的构造必须通过有参的构造方法 这就是使用super的原因

super()调用的是父类的构造方法 只有构造完父类后才可以构造子类

public class Main {
    public static void main(String[] args) {
        Ason ason = new Ason();
    }
}

class A {
    public A(int a) {
        System.out.println(a);
    }
}

class Ason extends A {
    public Ason() {
        super(2);  //super(2)调用父类构造方法A(int a)构造出父类
        System.out.println(3); //构造完父类才有子类  所以super(2)只能放在第一句
    }
}

当显示调用父类构造方法时 必须放在子类构造方法的第一行 现有父类后又子类 这和常规逻辑一致

所以输出结果是：
2
3