关于人工智能:22-继承与多态

继承和多态是面向对象编程的两个重要概念，它们使得咱们能够创立更加通用、可扩大的代码。

2.2.1. 继承

继承是一种创立新类的形式，新类（子类）从现有类（父类）继承属性和办法。子类能够重写或扩大父类的性能。

要创立一个子类，能够应用 extends 关键字：

class SubClassName extends ParentClassName {// 子类的成员变量和办法}

示例 1：继承

// 父类
class Animal {
    String name;
    int age;

    void sleep() {System.out.println(name + "is sleeping.");
    }
}

// 子类
class Dog extends Animal {
    String breed;

    void bark() {System.out.println(name + "is barking.");
    }
}

class Main {public static void main(String[] args) {Dog myDog = new Dog();
        myDog.name = "Buddy";
        myDog.age = 3;
        myDog.breed = "Golden Retriever";

        myDog.bark(); // 子类的办法
        myDog.sleep(); // 继承自父类的办法}
}

2.2.2. 办法重写（笼罩）

子类能够重写父类的办法，以便在调用子类对象的该办法时应用子类的实现而不是父类的实现。重写办法的返回类型、办法名和参数列表必须与父类雷同。

class SubClassName extends ParentClassName {
    @Override // 注解，表明该办法重写了父类的办法，非必须但倡议应用
    ReturnType methodName(Parameters) {// 子类的实现}
}

示例 2：办法重写

// 父类
class Animal {
    String name;
    int age;

    void sleep() {System.out.println(name + "is sleeping.");
    }
}

// 子类
class Dog extends Animal {
    String breed;

    void bark() {System.out.println(name + "is barking.");
    }

    @Override
    void sleep() {System.out.println(name + "the" + breed + "is sleeping.");
    }
}

class Main {public static void main(String[] args) {Dog myDog = new Dog();
        myDog.name = "Buddy";
        myDog.age = 3;
        myDog.breed = "Golden Retriever";

        myDog.bark();
        myDog.sleep(); // 调用子类重写的办法}
}

2.2.3. 多态

多态是一个对象在不同状况下体现出不同的行为。多态是通过父类援用指向子类对象实现的。

ParentClassName objectName = new SubClassName();

示例 3：多态

// 父类
class Animal {
    String name;
    int age;

    void sleep() {System.out.println(name + "is sleeping.");
    }
}

// 子类
class Dog extends Animal {
    String breed;

    void bark() {System.out.println(name + "is barking.");
    }

    @Override
    void sleep() {System.out.println(name + "the" + breed + "is sleeping.");
    }
}

class Main {public static void main(String[] args) {
        // 多态
        Animal myAnimal = new Dog();
        myAnimal.name = "Buddy";
        myAnimal.age = 3;

        myAnimal.sleep(); // 调用子类重写的办法

        // 留神：无法访问子类特有的办法和属性
        // myAnimal.bark(); // 谬误
        // myAnimal.breed = "Golden Retriever"; // 谬误
    }
}

多态的次要长处是代码的可扩展性和维护性。当你须要增加新的子类时，不须要批改应用多态的代码。

2.2.4. 抽象类和接口

抽象类和接口是 Java 中实现多态和代码复用的两种形式。

• 抽象类：包含形象办法（没有实现的办法）和具体方法。子类必须实现所有形象办法。应用 abstract 关键字定义抽象类和形象办法。

  abstract class AbstractClassName {
      // 形象办法
      abstract ReturnType methodName(Parameters);
  
      // 具体方法
      ReturnType methodName(Parameters) {// 办法实现}
  }
  ```
  

• 接口：定义一组办法签名（没有实现的办法）。实现接口的类必须实现所有办法。应用 interface 关键字定义接口。

  interface InterfaceName {
      // 办法签名（没有办法体）ReturnType methodName(Parameters);
  }
  ```

示例 4：抽象类和接口

// 抽象类
abstract class Animal {
    String name;
    int age;

    abstract void makeSound();

    void sleep() {System.out.println(name + "is sleeping.");
    }
}

// 接口
interface Pet {void play();
}

// 子类实现抽象类和接口
class Dog extends Animal implements Pet {
    String breed;

    @Override
    void makeSound() {System.out.println(name + "is barking.");
    }

    @Override
    public void play() {System.out.println(name + "is playing.");
    }
}

class Main {public static void main(String[] args) {Dog myDog = new Dog();
        myDog.name = "Buddy";
        myDog.age = 3;
        myDog.breed = "Golden Retriever";

        myDog.makeSound(); // 实现抽象类的形象办法
        myDog.sleep(); // 继承自抽象类的具体方法
        myDog.play(); // 实现接口的办法}
}

这是对于继承和多态的根本介绍。通过这些概念，你能够创立更加灵便和可扩大的代码。在理论开发中，你会遇到更多简单和实用的用例，通过多做练习和深刻学习，你将更好地把握这些知识点。

举荐浏览：

https://mp.weixin.qq.com/s/dV2JzXfgjDdCmWRmE0glDA

https://mp.weixin.qq.com/s/an83QZOWXHqll3SGPYTL5g