Java基础--面向对象高级（3）

抽象类和抽象方法

为什么需要抽象类呢?

1. 在以前,子类需要一个eat()方法,就需要在子类重写一个父类的eat()方法;但这个父类的eat()方法没有存在的意义,完全是为了子类重写而存在;
2. 在项目的多人合作中,你设置了父类的eat()方法,但别人在写子类的时候没有重写eat()方法,导致程序出错但编译器不报错,这时候设置抽象类----子类不重写编译器就会报错

抽象方法

将共性的行为(方法)抽取到父类之后。因为每一个子类的方法体是不一样的，所以在父类中不能确定具体的方法体。 该方法啊就可以定义为抽象方法；

抽象类

如果一个类中存在抽象方法，那么该类就必须声明为抽象类；

定义格式

public abstract 返回值类型 方法名（参数列表）；

public abstract class 类名{...}

示例：

• 识别是否为抽象方法的一个技巧：

1. 如果能在父类中写出来具体方法，子类直接继承的就是普通方法直接写；

2. 写不出来，每个子类都不一样就需要在子类重写，而这个父类的方法就要写成抽象方法；

• Animal

public abstract class Animal {
    private String name;
    private String color;

    public Animal() {
    }

    public Animal(String name, String color) {
        this.name = name;
        this.color = color;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public String getColor() {
        return color;
    }
    
    public void setColor(String color) {
        this.color = color;
    }

    public abstract void eat();//抽象方法，供子类所重写

    public void drink() {
        System.out.println(name + "正在喝水");
    }
}

• Cat

public class Cat extends Animal {


    public Cat() {
    }

    public Cat(String name, String color) {
        super(name, color);
    }

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

    public void catchMouse() {
        System.out.println(getName() + "抓老鼠");
    }

    public String toString() {
        return "Cat{}";
    }
}

• Dog

package com.linxin.ooppoly.Test2;

public class Dog extends Animal {
    public Dog() {
    }

    public Dog(String name, String color) {
        super(name, color);
    }

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

    public void lookHome() {
        System.out.println(getName() + "正在看家");
    }
}

• Test

public class Test {
    public static void main(String[] args) {
        Cat c = new Cat("小白", "黄色");
        c.eat();
        c.catchMouse();
        c.drink();
    }
}

• 运行结果：

抽象类和抽象方法的注意事项

• 抽象类中不一定有抽象方法： 如果父类有很多方法，那么子类就要全部重写这些抽象方法（语法规定）很麻烦；所以使用了Fu FuAdapter Zi这种继承结构：

• Fu：

public abstract class Fu {
    public abstract void method1();
    public abstract void method2();
    public abstract void method3();
    public abstract void method4();
    public abstract void method5();
    public abstract void method6();
    public abstract void method7();
    public abstract void method8();
    public abstract void method9();
}

• FuAdapter：

public class FuAdapter extends Fu {
    @Override
    public void method1() {}
    @Override
    public void method2() {}
    @Override
    public void method3() {}
    @Override
    public void method4() {}
    @Override
    public void method5() {}
    @Override
    public void method6() {}
    @Override
    public void method7() {}
    @Override
    public void method8() {}
    @Override
    public void method9() {}

• Zi：

public class Zi extends FuAdapter {
    @Override
    public void method6() {
        System.out.println("我只需要用到method6方法");
    }
}

-这样就可以解决全部重写带来的繁杂问题；

抽象类和抽象方法的意义

• 一个项目肯定不会是一个人独立完成的；写父类的规定好了都写哪些方法，而写子类的写的方法千奇百怪样式不一、子类不统一、就会导致接受的程序员不明所以；
• 所以最重要的意义是规定代码格式；
• 强制子类必须按照父类的格式书写；调用方法时直接看父类就可以了 ：）