菜鸟Java面向对象 1. Java继承

1. Java继承

1. 继承的概念_简单介绍继承的用处

继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

---

继承是面向对象编程中的一个重要概念，它允许在现有类的基础上创建新的类，并且新的类可以继承现有类的属性和方法，同时可以添加新的属性和方法，或者修改继承的方法的行为。

在Java中，继承通过使用关键字 extends 来实现。子类可以继承父类的非私有成员（属性和方法），这样就可以重用已有的代码，同时也可以实现代码的扩展和重构。继承还可以形成类之间的层次关系，使得代码更加清晰、易于维护和扩展。

继承的核心概念包括：

1. 父类（基类、超类）：已存在的类，被继承的类。
2. 子类（派生类）：基于父类创建的新类，继承了父类的属性和方法。
3. 继承关系：子类可以访问父类的公有成员，但不能直接访问私有成员。子类可以添加新的成员或者重写父类的方法。

通过继承，可以实现代码的重用和扩展，提高代码的可维护性和可扩展性。同时，继承也是面向对象编程的核心特征之一，它使得程序设计更加灵活和高效。

---

生活中的继承：

兔子和羊属于食草动物类，狮子和豹属于食肉动物类。

食草动物和食肉动物又是属于动物类。

所以继承需要符合的关系是：is-a，父类更通用，子类更具体。

虽然食草动物和食肉动物都是属于动物，但是两者的属性和行为上有差别，所以子类会具有父类的一般特性也会具有自身的特性。

2. 类的继承格式

在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的，一般形式如下：

类的继承格式

class 父类 {
} 
class 子类 extends 父类 {
}

---

简单示例：

class Animal {
    String species;
    
    public void eat() {
        System.out.println("The animal is eating.");
    }
}

class Dog extends Animal {
    public void bark() {
        System.out.println("The dog is barking.");
    }
}

在这个例子中，Animal 类是父类，Dog 类是子类，Dog 类继承了 Animal 类的属性和方法。

---

3. 为什么需要继承

接下来我们通过实例来说明这个需求。

开发动物类，其中动物分别为企鹅以及老鼠，要求如下：

- 企鹅：属性（姓名，id），方法（吃，睡，自我介绍）
- 老鼠：属性（姓名，id），方法（吃，睡，自我介绍）

企鹅类：

/**
 * Penguin（企鹅）类表示一个拥有姓名和ID的企鹅。
 */
public class Penguin {
    // 企鹅的姓名
    private String name;
    
    // 企鹅的ID
    private int id;
    
    /**
     * 构造一个具有指定姓名和ID的企鹅对象。
     * 
     * @param myName 企鹅的姓名。
     * @param myid 企鹅的ID。
     */
    public Penguin(String myName, int myid) {
        name = myName;
        id = myid;
    }
    
    /**
     * 模拟企鹅进食。
     */
    public void eat() {
        System.out.println(name + "正在吃");
    }
    
    /**
     * 模拟企鹅睡眠。
     */
    public void sleep() {
        System.out.println(name + "正在睡");
    }
    
    /**
     * 介绍这只企鹅。
     */
    public void introduction() {
        System.out.println("大家好！我是" + id + "号" + name + ".");
    }
}

老鼠类：

/**
 * Mouse（老鼠）类表示一个拥有姓名和ID的老鼠。
 */
public class Mouse {
    // 老鼠的姓名
    private String name;
    
    // 老鼠的ID
    private int id;
    
    /**
     * 构造一个具有指定姓名和ID的老鼠对象。
     * 
     * @param myName 老鼠的姓名。
     * @param myid 老鼠的ID。
     */
    public Mouse(String myName, int myid) {
        name = myName;
        id = myid;
    }
    
    /**
     * 模拟老鼠进食。
     */
    public void eat() {
        System.out.println(name + "正在吃");
    }
    
    /**
     * 模拟老鼠睡眠。
     */
    public void sleep() {
        System.out.println(name + "正在睡");
    }
    
    /**
     * 介绍这只老鼠。
     */
    public void introduction() {
        System.out.println("大家好！我是" + id + "号" + name + ".");
    }
}

从这两段代码可以看出，代码存在重复，导致代码量大且臃肿，而且维护性不高(主要表现是后期需要修改的时候，需要修改很多的代码，容易出错)。要从根本上解决这两段代码的问题，就需要继承，将两段代码中相同的部分提取出来组成 一个父类：

公共父类：

/**
 * Animal（动物）类表示一个拥有姓名和ID的动物。
 */
public class Animal {
    // 动物的姓名
    private String name;
    
    // 动物的ID
    private int id;
    
    /**
     * 构造一个具有指定姓名和ID的动物对象。
     * 
     * @param myName 动物的姓名。
     * @param myid 动物的ID。
     */
    public Animal(String myName, int myid) {
        name = myName;
        id = myid;
    }
    
    /**
     * 模拟动物进食。
     */
    public void eat() {
        System.out.println(name + "正在吃");
    }
    
    /**
     * 模拟动物睡眠。
     */
    public void sleep() {
        System.out.println(name + "正在睡");
    }
    
    /**
     * 介绍这只动物。
     */
    public void introduction() {
        System.out.println("大家好！我是" + id + "号" + name + ".");
    }
}

这个Animal类就可以作为一个父类，然后企鹅类和老鼠类继承这个类之后，就具有父类当中的属性和方法，子类就不会存在重复的代码，维护性也提高，代码也更加简洁，提高代码的复用性（复用性主要是可以多次使用，不用再多次写同样的代码） 继承之后的代码：

企鹅类：

/**
 * Penguin（企鹅）类是 Animal 类的子类，表示一个拥有姓名和ID的企鹅。
 */
public class Penguin extends Animal {
    /**
     * 构造一个具有指定姓名和ID的企鹅对象。
     * 
     * @param myName 企鹅的姓名。
     * @param myid 企鹅的ID。
     */
    public Penguin(String myName, int myid) {
        // 调用父类 Animal 的构造方法
        super(myName, myid);
    }
}

老鼠类：

/**
 * Mouse（老鼠）类是 Animal 类的子类，表示一个拥有姓名和ID的老鼠。
 */
public class Mouse extends Animal {
    /**
     * 构造一个具有指定姓名和ID的老鼠对象。
     * 
     * @param myName 老鼠的姓名。
     * @param myid 老鼠的ID。
     */
    public Mouse(String myName, int myid) {
        // 调用父类 Animal 的构造方法
        super(myName, myid);
    }
}

4. 继承类型_多重继承

需要注意的是 Java 不支持多继承，但支持多重继承。

---

5. 继承的特性

• 子类拥有父类非 private 的属性、方法。

• 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

• 子类可以用自己的方式实现父类的方法。

• Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。

• 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

---

继承的几个重要特性：

1. 子类拥有父类非 private 的属性、方法：

这是继承的基本特性，子类可以访问父类中非私有的属性和方法。

2. 子类可以拥有自己的属性和方法：

继承不仅仅意味着子类可以继承父类的属性和方法，还可以在子类中添加新的属性和方法，从而实现对父类的扩展。

3. 子类可以用自己的方式实现父类的方法：

子类可以重写（override）父类的方法，以实现自己特定的行为，这样可以在不改变原有接口的情况下定制化功能。

4. Java 的继承是单继承，但可以多重继承： Java 中一个类只能直接继承一个父类，但是可以通过多级继承实现多重继承的效果。这与C++不同，C++允许直接多重继承。

5. 提高了类之间的耦合性： 继承可以提高类之间的关联性，但也会增加耦合性，使得代码更加紧密地联系在一起，降低了独立性。这是继承的一个缺点，需要谨慎使用。

继承是面向对象编程中非常重要的概念，合理地使用继承可以使代码更加模块化、可扩展和易于维护。

---

6. 继承关键字

继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承 Object（这个类在 java.lang 包中，所以不需要 import）祖先类。

extends关键字

在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。

//extend 关键字
/**
 * Animal（动物）类表示一个拥有姓名和ID的动物。
 */
public class Animal {
    // 动物的姓名
    private String name;
    
    // 动物的ID
    private int id;
    
    /**
     * 构造一个具有指定姓名和ID的动物对象。
     * 
     * @param myName 动物的姓名。
     * @param myid 动物的ID。
     */
    public Animal(String myName, int myid) {
        // 初始化属性值
    }
    
    /**
     * 模拟动物进食。
     */
    public void eat() {
        // 吃东西方法的具体实现
    }
    
    /**
     * 模拟动物睡眠。
     */
    public void sleep() {
        // 睡觉方法的具体实现
    }
}

/**
 * Penguin（企鹅）类继承自 Animal 类。
 */
public class Penguin extends Animal {
}

implements关键字

使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。

/**
 * A 接口定义了 eat() 和 sleep() 方法。
 */
public interface A {
    /**
     * 吃的行为。
     */
    public void eat();
    
    /**
     * 睡觉的行为。
     */
    public void sleep();
}

/**
 * B 接口定义了 show() 方法。
 */
public interface B {
    /**
     * 展示的行为。
     */
    public void show();
}

/**
 * C 类实现了 A 接口和 B 接口。
 */
public class C implements A, B {
}

super 与 this 关键字

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

this关键字：指向自己的引用。

class Animal { void eat() { System.out.println("animal : eat"); } } class Dog extends Animal { void eat() { System.out.println("dog : eat"); } void eatTest() { this.eat(); // this 调用自己的方法 super.eat(); // super 调用父类方法 } } public class Test { public static void main(String[] args) { Animal a = new Animal(); a.eat(); Dog d = new Dog(); d.eatTest(); } }

输出结果为：

animal : eat
dog : eat
animal : eat

final 关键字

final 可以用来修饰变量（包括类属性、对象属性、局部变量和形参）、方法（包括类方法和对象方法）和类。

final 含义为 “最终的”。

使用 final 关键字声明类，就是把类定义定义为最终类，不能被继承，或者用于修饰方法，该方法不能被子类重写：

• 声明类：

final class 类名 {//类体}

• 声明方法：

修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}

注： final 定义的类，其中的属性、方法不是 final 的。

---

7. 构造器

子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。

如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。

实例

/**
 * SuperClass 类表示一个超类，具有一个私有整型属性 n。
 */
class SuperClass {
    private int n;
    
    /**
     * 构造一个无参数的 SuperClass 对象。
     */
    SuperClass(){
        System.out.println("SuperClass()");
    }
    
    /**
     * 构造一个带有参数的 SuperClass 对象。
     * 
     * @param n 初始化的整数值。
     */
    SuperClass(int n) {
        System.out.println("SuperClass(int n)");
        this.n = n;
    }
}

/**
 * SubClass 类继承自 SuperClass 类，表示一个子类。
 */
class SubClass extends SuperClass{
    private int n;
    
    /**
     * 构造一个无参数的 SubClass 对象。
     */
    SubClass(){
        // 自动调用父类的无参数构造器
        System.out.println("SubClass");
    }  
    
    /**
     * 构造一个带有参数的 SubClass 对象。
     * 
     * @param n 初始化的整数值。
     */
    public SubClass(int n){ 
        // 调用父类中带有参数的构造器
        super(300);  
        System.out.println("SubClass(int n):"+n);
        this.n = n;
    }
}

/**
 * SubClass2 类继承自 SuperClass 类，表示另一个子类。
 */
class SubClass2 extends SuperClass{
    private int n;
    
    /**
     * 构造一个无参数的 SubClass2 对象。
     */
    SubClass2(){
        // 调用父类中带有参数的构造器
        super(300);  
        System.out.println("SubClass2");
    }  
    
    /**
     * 构造一个带有参数的 SubClass2 对象。
     * 
     * @param n 初始化的整数值。
     */
    public SubClass2(int n){ 
        // 自动调用父类的无参数构造器
        System.out.println("SubClass2(int n):"+n);
        this.n = n;
    }
}

/**
 * TestSuperSub 类用于测试 SuperClass、SubClass 和 SubClass2 类。
 */
public class TestSuperSub{
    public static void main (String args[]){
        System.out.println("------SubClass 类继承------");
        SubClass sc1 = new SubClass();
        SubClass sc2 = new SubClass(100); 
        
        System.out.println("------SubClass2 类继承------");
        SubClass2 sc3 = new SubClass2();
        SubClass2 sc4 = new SubClass2(200); 
    }
}

输出结果为：

------SubClass 类继承------
SuperClass()
SubClass
SuperClass(int n)
SubClass(int n):100
------SubClass2 类继承------
SuperClass(int n)
SubClass2
SuperClass()
SubClass2(int n):200

8. 总结

这一章学习了

1. 继承的概念和用处

• 继承是面向对象编程的基石，允许创建分层次的类，实现代码的重用和扩展。
• 通过继承，子类可以继承父类的属性和方法，同时可以添加新的属性和方法，或者重写父类的方法。
• 继承形成类之间的层次关系，使得代码更加清晰、易于维护和扩展。

2. 类的继承格式

• 在Java中，使用extends关键字来实现继承。
• 子类可以继承父类的非私有成员，形成类的层次关系。

3. 为什么需要继承

• 继承可以减少代码的重复，提高代码的复用性和可维护性。
• 通过继承，可以构建类之间的层次关系，使代码更加清晰和易于理解。

4. 继承类型

• Java支持单继承和多重继承，通过extends关键字实现单继承，通过implements关键字实现多重继承。

5. 继承的特性

• 子类拥有父类的非私有属性和方法。
• 子类可以拥有自己的属性和方法，同时可以重写父类的方法。
• Java的继承是单继承，但支持多重继承。
• 继承提高了类之间的耦合性，需要注意降低耦合度。

6. 继承关键字

• 使用extends关键字实现类的继承。
• 使用implements关键字实现接口的继承。
• 使用super关键字调用父类的构造方法。

7. 构造器

• 子类不继承父类的构造器，但可以通过super关键字调用父类的构造器。
• 如果父类构造器带有参数，子类必须显式地调用父类构造器并传递参数。