Java SE 11 Sliver学习笔记(第七章)

Java SE 11 sliver资格考试相关

第七章 クラスの継承、インタフェース、抽象クラス

間違えた:3, 4, 8, 10, 11, 12, 17, 19, 20, 21

間違えし易い:13,20

分からない:全部

回顾
  1. 继承的概念,子类中没有定义的要去父类中寻找。

  2. 继承的原则,不会被继承的为:

    1. 父类的构造方法
    2. 父类的private的变量和方法

    因此在子类的非继承方法中,是不能访问父类的private的变量的。

  3. 接口(interface)的说明。

    1. 接口中的方法即使不写访问修饰符,也会自动编译为public,这是因为便于其他的类访问。并且接口的抽象方法是不能被protected或者private修饰。
    2. 接口是不能instance化的,只能被其他的类实现。并且一个类可以实现多个接口,用逗号区分开即可。
    3. 接口中的方法不能有方法体,也就是不能写{}
    4. 接口中可以定义filed,但是要满足两个条件(全部?):
      1. final修饰的,也就是定值。
      2. static修饰的,不需要instance化就可以访问的。
    5. 接口可以扩张。也就是接口可以继承其他的接口,使用extends关键字即可。
  4. Java8后,接口可以有静态方法和方法体了,写法如下

    1
    2
    3
    default 返回值 方法名(参数类型 参数名){
    some code...
    }
  5. java.lang.Object类中定义的方法不能被接口所重写。否则会出现编译错误。

  6. 使用接口的default方法时的写法为:接口名.super.methodName()。但是只能在直接实现接口的类中使用,不能在两次实现或者两次继承中使用!!

  7. 在接口的多重实现类中,使用接口的default方法时,如果方法同名,首先要override后在方法体中指定具体实现哪个接口的default方法。例如

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    public class Main implements A, B{
    public static void main(String[] args) {
    new Main().test();
    }
    }

    @override
    public void test() {
    A.super.test();
    }
  1. 抽象类也可以继承抽象类,因此抽象类的方法不一定是所有子类都需要实现。(如果是被抽象类继承就不需要实现)

  2. 抽象类中的抽象方法没有方法体,因此执行的是子类中被重写的方法。

  3. 重写:方法名,参数类型,数量,顺序都不能改变。从java SE 5开始,返回值可以更改了?

  4. 重写的三个规则:

    1. シグニチャ(签名)必须相同。
    2. 返回值为相同类型,或者为父类返回值类型的子类。
    3. 访问权限词相同,或者是比父类更松。(例如父类为public,子类就不能用protected)
  5. 继承时父类和子类可以使用相同的变量名。当父类和子类有同名变量存在时,使用哪个取决于:

    1. 参照变量时,变数的宣言来决定。

    2. 被方法呼出时,根据方法的指定。看具体的例子, 输出结果应为AAAA,因为14和15行instance的类型为A,所以打印时使用A类中的val变量,18行和19行因为B类中压根没有print方法,所以使用A类中的print方法,自然也就参照的A类中的val变量:

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      class A{
      String val = "A";
      void print (){
      System.out.println(val);
      }
      }

      class B extends A{
      String val = "B";
      }

      public class Main{
      public static void main (String[] args){
      A a = new A();
      A b = new B();
      System.out.println(a.val);
      System.out.println(b.val);
      a.print();
      b.print();
      }
      }
  6. polymorphism相关的问题。遇到多态的问题要确定一下两点:

    1. 有没有继承关系或者实现关系,具不具备多态性实现的条件。
    2. 对instance的限制的类型中,有没有方法的定义。
  7. 向上转型和向下转型相关。向上转型可以自动完成,但是向下转型需要声明。(cast)例如:

    1
    2
    A a = new B(); //B的向上转型
    B b = (B) a ; //向下转型
  8. 对于java的向下转型,强制向下转型,编译不会报错。但是在运行时,如果对象本身并非是该类型,强制转型,
    在运行时会报java.lang.ClassCastException。因此只有把子类型赋给父类的引用,然后把该引用向下转型的情况,才不会报错。
    父类不能强制向下转型!向上转型则是安全的。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    // 父类
    public class People {
    }
    //子类
    public class Man extends People {
    }
    //测试类
    public class Test{
    public static void main(String [] args) throws Exception {
    correctDown();
    errorDown();
    }
    static void correctDown(){
    People people=new Man();
    System.out.println((Man) people);
    }
    //类型转换错误,java.lang.ClassCastException: People cannot be cast to Man
    static void errorDown(){
    People people=new People();
    System.out.println((Man) people);
    }
    }

  1. scope(作用范围)相关问题。this是指向instance自身的用法。在方法中如果有和全局变量相同名的变量,可以在方法中使用局部变量。但是也可以通过this.fieldName来直接使用全局变量。

  2. this的作用域!!!如果父子类变量名重复的情况下想访问父类的成员变量时要使用super关键字!

  3. 拥有继承关系时候的构造方法的构建顺序相关问题。需要注意的是:

    1. 首先,子类需要准备父类的instance和子类差分的instance。

    2. 首先构建的是“基盘”部分的父类的instance,因此父类的构造方法会先被执行。例:

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      class A {
      public A(){
      System.out.println("A");
      }
      }

      class B extends A{
      public B(){
      super();//编译器会自动加入这一行,确保在构建子类instance前就生成了父类的instance。
      System.out.println("B");
      }
      }

      public class Main{
      public static void main(String ){
      A a = new B();//输出结果为:A,B
      }
      }

  1. 在构造方法中想要使用被重载的其他的构造方法时用this关键字,想使用父类的构造方法时要用super关键字。
  • 版权声明: 本博客所有文章除特别声明外,著作权归作者所有。转载请注明出处!
  • Copyrights © 2020-2021 Joe
  • 访问人数: | 浏览次数:

请我喝杯咖啡吧~

支付宝
微信