抽象类和抽象方法

抽象方法

• 抽象方法：将共性的行为（方法）抽取到父类之后。由于每一个子类执行的内容是不一样，所以，在父类中不能确定具体的方法体。该方法就可以定义为抽象方法。
• 抽象类：如果一个类中存在抽象方法 ，那么该类就必须声明为抽象类。

抽象方法的使用格式：

public abstract class Person {

    public abstract void work();
}

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

• 抽象类不能实例化
• 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
• 可以有构造方法
• 抽象类的子类

                要么重写抽象类中的所有抽象方法

                要么是抽象类

练习：编写带有抽象类的标准Javabean类

        青蛙frog        属性：名字，年龄        行为 ：吃虫子 ，喝水

        狗Dog            属性：名字，年龄        行为：吃骨头，喝水

        山羊Sheep     属性：名字，年龄        行为：吃草，喝水 

代码实现：

package oop_abstract.demo1.a02.demo2;
//创建Animal父类，因为eat为抽象方法，所以Animal为抽象类
public abstract class Animal {
    private String name;
    private int age;


    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Animal{name = " + name + ", age = " + age + "}";
    }

    //eat()为抽象类，不用实例化
    public abstract void eat(String food);

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

package oop_abstract.demo1.a02.demo2;

public class Dog extends Animal {

    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }
    //实例化eat()方法
    @Override
    public void eat(String food){
        System.out.println(super.getName()+"吃"+food);
    }

}

package oop_abstract.demo1.a02.demo2;

public class Frog extends Animal{

    public Frog() {
    }

    public Frog(String name, int age) {
        super(name, age);
    }
    //实例化eat()方法
    @Override
    public void eat(String food){
        System.out.println(super.getName()+"吃"+food);
    }

}

package oop_abstract.demo1.a02.demo2;

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

    public Sheep(String name, int age) {
        super(name, age);
    }
    //实例化eat()方法
    @Override
    public void eat(String food) {
        System.out.println(super.getName()+"吃"+food);
    }
}

测试类： 

package oop_abstract.demo1.a02.demo2;
//测试类
public class Test {
    public static void main(String[] args) {
        //创建Frog对象并调用eat与drink方法
        Frog frog=new Frog("青蛙",20);
        frog.eat("虫子");
        frog.drink();

        //创建Dog对象并调用eat与drink方法
        Dog dog=new Dog("小狗",12);
        dog.eat("骨头");
        dog.drink();

        //创建Sheep对象并调用eat与drink方法
        Sheep sheep=new Sheep("小羊肖恩",8);
        sheep.eat("草");
        sheep.drink();
    }
}

抽象类和抽象方法的意义。

        疑问：把子类中共性的内容抽取到父类之后，由于方法体不确定，需要定义为抽象。子类使用时需要重写。那么我不抽取导父类，直接在子类写不是更节约代码？

                答：在开发过程中，代码并不是一个人写的，其他人写的方法命名与你的不一样，其他人想要调用方法，必须每次都来查看方法体，抽象方法能强制子类必须按这种 方式重写，规范方法格式。