ACCP8.0 java课程第二学期-关于继承

Posted 2020-09-16

本章重点：
    继承的概念，重写与抽象类
本章难点：
    1.理解存在继承关系时创建对象时的内存调用原理
    2.理解抽象类

学习方法：
    1.自己多想例子并分析，有了思路立刻动手实现，不要空想社会主义
    2.根据需求找父类，定子类，发现属性，归纳特征


1.继承
1.1 继承是面向对象的特征之一，子类继承父类则子类能拥有父类的方法与属性，这样的好处是复用代码，使结果清晰，它是多态的必要条件
1.2 需要继承的类访问修饰符不能用protected 和 private修饰
1.3 Object是所有java的类的父类，如果一个类没有显式的继承一个类那么它默认就继承Object类
1.4 (1)完全继承：public 和 protected 修饰的属性和方法 (2)部分继承：同一个包内默认修饰符修饰的属性和方法
    (3)不能继承: private修饰的属性和方法与构造函数
1.5 创建子类对象之前，都会从最上级依次调用父类的构造函数。
1.6 如果父类没有提供默认的构造方法，则必须用super关键字显式的调用父类的构造函数写至第一行

package org.lyrk.accp8.s2.chapter.two;

/**
 * Created by niechen on 17/4/20.
 */
public class Test1 {

    public Test1() {
        System.out.println("Test1的构造函数");
    }

    public static void main(String[] args) {
        new TestChildTwo();

    }
}
class TestChildOne extends Test1 {

    public TestChildOne() {
        System.out.println("TestChildOne的构造函数");
    }
}

class TestChildTwo extends TestChildOne {
    public TestChildTwo() {
        System.out.println("这个是TestChildTwo的构造函数");
    }
}
//子类的访问修饰符不能是private 或者 protected
//protected class TestChildThree extends TestChildTwo{
//
//}
输出结果:
Test1的构造函数
TestChildOne的构造函数
这个是TestChildTwo的构造函数

 

2.super关键字是对父类的引用
2.1 是调用父类的关键字
2.2 调用父类的属性和方法
2.3 调用父类的构造方法
2.4 在构造函数中不能同时出现 super与this关键字，在实例方法则可以

3.关于重写
3.1 可以用override注解，也可以不用
3.2 规则:
  (1)方法名，返回值(或者是其子类)，方法参数必须保持一致。
  (2)访问修饰符的控制权限不能低于父类的访问控制权限
  (3)不能抛出不兼容于父类的异常
3.3 重载(overload)与重写(override)的区别
 (1) 重载是在一个类里，重写作用在子类当中
 (2) 重载仅仅是需要方法名保持相同，而重写是返回值 方法名 参数保持一致，访问修饰符最好保持一致
 (3) 构造方法支持重载，但构造方法无法被重写

package org.lyrk.accp8.s2.chapter.two;

import java.io.IOException;

/**
 * Created by niechen on 17/4/21.
 */
public class Test3 {

　　 public int age = 20;
    public void test1() {

    }

    public void test2() {

    }

    public void test3() {

    }

    public Test3 test4() {

        return null;
    }

    public void test5() throws NullPointerException {

    }


}

class Test3Child extends Test3 {
    //报错父类没有抛出异常
    public void test1()  throws Exception{

    }

   //报错 返回值与父类不同 
    public int test2() {
        return 0;
    }

    public void test3(int text) {

    }

    @Override
    public Test3Child test4() {
        super.test4();
        return null;
    }

    //报错不兼容父类的异常
    @Override
    public void test5() throws IOException {

    }
}

 

4.抽象
4.1 抽象类是一个残缺不全的类，所以它无法被实例化，用关键字abstract修饰
4.2 抽象类中能定义实体方法也能定义抽象方法，但非抽象类不能定义抽象方法
4.3 非抽象子类则必须要重写抽象方法
4.4 抽象方法不能为private
4.5 当一个类迫切的想让子类重写方法时则可以考虑定义抽象类(不知道该怎么实现，却很有必要实现)

 1 package org.lyrk.accp8.s2.chapter.two;
 2 
 3 /**  
　　　*　abstract示例 可以作用在类与方法上
 4  * Created by niechen on 17/4/21.
 5  */
 6 public abstract class Test4 {
 7 
 8     public abstract void test1();
 9 
10     protected abstract void test2();
11 
12     abstract void test3();
13 
14     // private abstract  void test4(); 抽象方法不能是私有的
15 
16     public void test5() {
17         System.out.println("这个是实例方法");
18     }
19 }
20 
21 class Test4Child extends Test4 {
22 
23     @Override
24     public void test1() {
25 
26     }
27 
28     @Override
29     protected void test2() {
30 
31     }
32 
33     @Override
34     void test3() {
35 
36     }
37 }

 

5 final关键字
5.1 final类不能被继承，没有子类，final类中的方法默认是final的。
    （1)final方法不能被子类的方法覆盖，但可以被继承。
     (2)final成员变量表示常量，只能被赋值一次，赋值后值不再改变。
     (3)final不能用于修饰构造方法。
5.2 final作用于方法上：
    如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。
    使用final方法的原因有二：
    第一、把方法锁定，防止任何继承类修改它的意义和实现。
    第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率
5.3 final作用于参数时，可以读取使用该参数，但是无法改变该参数的值。

package org.lyrk.accp8.s2.chapter.two;

/**
 * Created by niechen on 17/4/25.
 */
public final class Test5 {


    public static final String TEST_CONST = "这是一个常量测试";

    public final void test1() {
        System.out.println("这是一个final方法");


    }

    public static final String test2() {
        return null;
    }

    public void test3() {
        final int age = 10;

    }

    public void test4(final Test3 test3) {
       // test3 =new Test3(); 不可以创建对象 但能改变对象的属性
        test3.age =100;
    }
}
// 最终类不能被继承
//class Test5Child extends Test5 {
//
//}