7.Java中的继承、覆盖、重载

目录结构

⭕1. 继承
⭕2. 继承的两个条件
⭕3. abstract（抽象）
⭕4. 子类的继承性的访问控制
⭕5. 子类对象的构造过程
⭕6. 方法重载与方法的覆盖
⭕7. Super（） 和 this（）关键字
⭕8. instanceof验证类是否相同类型

======================================

继承(快速查询类的父子关系图:Ctrl+T)

1.父类可以是也可以是java。Java多重继承，即子类。

2. 如果要声明类B继承类A,则必须满足两个条件：

①类A非final；

②类A是public或类B与类A同包。

如果这两个条件满足则可按照以下的语法声明类B：

这两声明表明B是A的子类，A是B的父类。
Class  B  extends  A
{... ...
}

3.(1)abstract（抽象）：

• 必须是父类，不能和extends同时出现
• 不能实例化对象

（2）Final（最终）

• 必须是子类

4.子类的继承性的访问控制

4.1子类和父类在的继承性

当子类和父类处在同一个包中时，子类可继承其父类中不是private的成员变量和方法。继承的成员变量以及方法的访问权限保持不变。

4.2子类和父类中的继承性

①当子类和父类不在同一包中时，子类只能继承父类的protected，public成员变量和方法，不能继承父类的友好变量和友好方法。继承的成员或方法的访问权限不变。
② 所谓** 友好** 即 ** 不被protected、public、private关键修饰的变量和方法** ，区别在于比public低一级，用于只能在同一包下访问的变量。

5.子类对象的构造过程

Java语言中，使用构造方法来构造并初始化对象。当用子类的构造方法创建一个子类对象时，子类构造函数总是先调用

子类对象的构造方法过程为：

• （1）将子类中声明的成员变量或方法作为子类对象的成员变量或方法。
• （2）将从父类继承的父类的成员变量或方法作为子类对象的成员变量或方法。

Dog继承Animal

class Animal{
    protected String name;
    protected String description;
    protected String say() {
        return "一只动物";
    }
}
 
class Dog extends Animal{
    private String name;
    protected String say() {
       return "我是忠犬八公,我父类是" + super.say();
    }
 
    private String getName() {
        return "我的名字是" + name + ",我父类的名称是" + super.name;
    }
 
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "忠犬八公";
        System.out.println(dog.say());
        System.out.println(dog.getName());
        System.out.println("==================================");
        Animal animal = new Dog();    ///
        animal.name = "哈皮";
        System.out.println(animal.say());
    }
}

输出

我是忠犬八公,我父类是一只动物
我的名字是忠犬八公,我父类的名称是null
==================================
我是忠犬八公,我父类是一只动物

参考文件

• JAVA子类继承父类的成员变量以及方法

--------------------------------------------------------------------

6. 方法重载与方法的覆盖

6.1 方法重载(override)

方法重载是在一个类中定义二个或多个同名的方法，但方法的参数个数或类型不完全相同，只有返回值类型不同的不构成重载。

6.2 方法覆盖

方法的覆盖发生在父类和子类之间，若子类中定义的某个方法的特征，与父类中定义的某个方法的特征完全一样，那么就说子类中的这个方法覆盖了父类对应的那个方法。

6.3 方法重载与方法覆盖的区别

• 重载可以出现在一个类中，也可以出现在父类与子类的继承关系中，并且重载方法的特征不完全相同。
• 覆盖则要求子类的方法特征与父类定义的对应方法的特征完全一样，即这个方法的名字，返回类型，参数个数和类型与从父类继承的方法相同。
• 子类全相同，子类覆盖父类

重载代码如下：

public class Main {
    public static void main(String[] args) {
        new Test().print();
        new Test().print(3);
        new Test().print(3,"双参");
    }
}
 
class Test{
     public void print(){
         System.out.println("无参");
     }
     public void print(int i){
         System.out.println(i+" "+"单参");
     }
     public void print(int i,String j){
         System.out.println(i+" "+j);
     }
}

输出：

无参
3 单参
3 双参

覆盖代码如下：

public class Main {
    public static void main(String[] args) {
        new Father().print();
        new Son().print();
    }
}
 
class Father{
     public void print(){
         System.out.println("father");
     }
}
class Son extends Father{
    @Override
    public void print() {
        System.out.println("SON");
    }       
}

输出：

father
SON

参考文件：

• java中覆盖和重载的区别

7.Super（） 和 this（）关键字

7.1 使用super调用父类的构造方法

子类的构造方法不能继承父类的构造方法，因此，子类如果想使用父类的构造方法，必须在子类的构造方法中使用并且必须使用关键字super来表示，而且super必须是子类构造方法中的第一条语句，写于不写都是第一句，先找爹。

7.2 使用super操作被隐藏的成员变量和方法

如果在子类中想使用被子类隐藏的成员变量或方法就可以使用关键字super

class Person { 
    public static void prt(String s) { 
       System.out.println(s); 
    } 
   
    Person() { 
       prt("父类·无参数构造方法： "+"A Person."); 
    }//构造方法(1) 
    
    Person(String name) { 
       prt("父类·含一个参数的构造方法： "+"A person's name is " + name); 
    }//构造方法(2) 
} 
    
public class Chinese extends Person { 
    Chinese() { 
       super(); // 调用父类构造方法（1） 
       prt("子类·调用父类”无参数构造方法“： "+"A chinese coder."); 
    } 
    
    Chinese(String name) { 
       super(name);// 调用父类具有相同形参的构造方法（2） 
       prt("子类·调用父类”含一个参数的构造方法“： "+"his name is " + name); 
    } 
    
    Chinese(String name, int age) { 
       this(name);// 调用具有相同形参的构造方法（3） 
       prt("子类：调用子类具有相同形参的构造方法：his age is " + age); 
    } 
    
    public static void main(String[] args) { 
       Chinese cn = new Chinese(); 
       cn = new Chinese("codersai"); 
       cn = new Chinese("codersai", 18); 
    } 
}

--------------------------------------------------------
输出：

父类·无参数构造方法： A Person.
子类·调用父类”无参数构造方法“： A chinese coder.
--------------------------------------------------------
父类·含一个参数的构造方法： A person's name is codersai
子类·调用父类”含一个参数的构造方法“： his name is codersai
--------------------------------------------------------
父类·含一个参数的构造方法： A person's name is codersai
子类·调用父类”含一个参数的构造方法“： his name is codersai
子类：调用子类具有相同形参的构造方法：his age is 18

参考文件：

• 【java】this()与super()使用详解

7.3 this ( ) 的用法：

①构造方法中用来代表对象
②区分变量（形参与成员名字重名，用this来区分）
③普通的直接引用

class Person {
    private int age = 10;
    public Person(){
    System.out.println("初始化年龄："+age);
}
    public int GetAge(int age){
        this.age = age;
        return this.age;
    }
}
 
public class test1 {
    public static void main(String[] args) {
        Person Harry = new Person();
        System.out.println("Harry's age is "+Harry.GetAge(12));
    }
}     

-------------------------------------------------------------------------
输出：

初始化年龄：10
Harry's age is 12  

参考文件：

• 【java】this()与super()使用详解

8. instanceof验证类是否相同类型

• 相同类型时返回True，反之False；