Java的编程之旅28——Abstract抽象类

1.抽象类的定义

说在前面（很重要）

抽象类的一个重要特点：它可以被继承，并且子类必须实现抽象方法。而普通方法则可以在抽象类中直接定义和使用。 

Java的抽象类是一种特殊的类，它不能被实例化，只能被继承。抽象类可以包含抽象方法和非抽象方法。

抽象方法是没有实现的方法，只有方法声明，没有方法体。子类继承抽象类后，必须实现父类中的所有抽象方法。

非抽象方法是有方法体的方法，可以被子类直接继承和使用。

抽象类主要用于定义一些共性的方法和属性，而具体的实现由子类去完成。抽象类可以提供一种规范和约束，使得子类在实现时有一定的统一性和一致性。

2.代码中的体现

抽象类的定义格式：

public abstract class <类名>{

        /**内容**/

}

1.首先定义一个名为“Animal” 的动物抽象类

pubilc abstract class Animal{
    
    private String type; //定义一个动物种类的变量
    
    //构造方法
    public Aniamal(String type){
        this.type = type;
    }
    
    //getter setter 方法
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }
    
    //定义抽象方法
    public abstract void eat();
    public abstract void sport();
    
    public void sleep(){
        System.out.println(this.type + "会睡");
    }
}

这段代码定义了一个抽象类Animal。它有一个私有变量type用于表示动物的种类，并提供了相应的getter和setter方法进行访问和设置。

构造方法Animal(String type)用于初始化动物种类。

除了属性和方法的定义外，这个抽象类还定义了两个抽象方法eat()和sport()。这意味着任何继承自Animal的子类都必须实现这两个方法。

最后，这个抽象类还提供了一个具体方法sleep()，它是一个非抽象方法，可以被子类直接继承和使用。在这个方法中，它打印出动物的种类并输出“会睡”。

通过定义抽象类Animal，我们可以定义其他具体的动物类来继承Animal，并实现eat()和sport()方法。同时，可以直接使用sleep()方法，无需在每个具体的动物类中再次实现。这样可以提高代码的复用性和可维护性。

抽象类不能被实例化，需要创建一个子类将其继承

 2.创建一个名字为"Cat"的子类用来继承Aniaml类

public class Cat extends Animal{
    public Cat(String type) {
        super(type);
    }

    @Override
    public void eat() {
        System.out.println(this.getType()+"吃鱼");
    }

    @Override
    public void sport() {
        System.out.println(this.getType()+"上树");
    }
}

注意：当继承Animal类时，public class Cat extends Animal语句会显示异常，下面会有红线，鼠标点击红线处，一路alt+enter，子类中代码会自动补全，语句也正确了

@Override是一个注解（annotation），它用于告诉编译器该方法是覆盖（重写）父类或者实现接口中的方法。通过使用@Override注解，可以帮助开发人员避免在重写方法时出现错误。

在上述代码中，Cat类中的eat()和sport()方法前面都使用了@Override注解。这意味着Cat类正试图覆盖（重写）Animal类中定义的相应的抽象方法。

如果我们通过错误地拼写方法名或者参数错误地改变方法的签名，编译器就会给出一个错误，提示我们该方法并没有被正确地重写。使用@Override注解可以帮助我们在编译时捕捉到这些错误，以便及早修复它们。

这段代码是一个继承自抽象类Animal的具体动物类Cat。它通过关键字extends继承Animal类，并在构造方法中使用super关键字调用父类Animal的构造方法。

Cat类实现了Animal类中的抽象方法eat()和sport()，分别输出了Cat的种类和对应的动作。

在eat()方法中，使用了this.getType()方法获取Cat的种类，并输出“吃鱼”。

在sport()方法中，同样使用了this.getType()方法获取Cat的种类，并输出“上树”。

通过继承Animal抽象类，并实现其中的抽象方法，Cat类可以具体化Animal类的行为，而无需再关心Animal类的实现细节。

这样，我们可以通过创建Cat对象来调用其eat()和sport()方法，从而实现具体的行为。

3.同理我们再继续创建两个子类出来，证明其正确性

public class Dog extends Animal{
    public Dog(String type) {
        super(type);
    }

    @Override
    public void eat() {
        System.out.println(this.getType()+"吃骨头");
    }

    @Override
    public void sport() {
        System.out.println(this.getType()+"会跑");
    }
}

public class Person extends Animal{
    public Person(String type) {
        super(type);
    }

    @Override
    public void eat() {
        System.out.println(this.getType()+"会吃饭");
    }

    @Override
    public void sport() {
        System.out.println(this.getType()+"会跳绳");
    }
}

 3.定义测试类

public class Ts {
    public static void main(String[] args) {
        Cat cat = new Cat("波斯猫");
        cat.eat();
        cat.sport();
        cat.sleep();
        Dog dog = new Dog("小黑");
        dog.eat();
        dog.sport();
        dog.sleep();
        Person person = new Person("超人");
        person.eat();
        person.sport();
        person.sleep();
    }
}

上述代码是一个测试类Ts，其中通过创建Cat、Dog和Person对象来测试Animal类的抽象方法和普通方法。

首先，创建了一个名为cat的Cat对象，将其类型设置为"波斯猫"，然后调用了cat对象的eat()、sport()和sleep()方法。由于Cat类继承自Animal类，并实现了eat()和sport()抽象方法，因此在调用cat对象的eat()和sport()方法时，会输出相应的信息。cat对象还可以调用继承自Animal类的普通方法sleep()。

接下来，创建了一个名为dog的Dog对象，将其类型设置为"小黑"，然后同样调用了dog对象的eat()、sport()和sleep()方法。由于Dog类也继承自Animal类并实现了eat()和sport()方法，所以在调用dog对象的eat()和sport()方法时，会输出相应的信息。dog对象同样可以调用继承自Animal类的普通方法sleep()。

最后，创建了一个名为person的Person对象，将其类型设置为"超人"，然后同样调用了person对象的eat()、sport()和sleep()方法。Person类虽然没有直接继承Animal类，但它实现了eat()和sport()方法。在调用person对象的eat()和sport()方法时，也会输出相应的信息。person对象同样可以调用继承自Animal类的普通方法sleep()。

通过这个测试类，我们可以看到抽象类的一个重要特点：它可以被继承，并且子类必须实现抽象方法。而普通方法则可以在抽象类中直接定义和使用。