15-面向对象进阶_04(抽象类)

四 抽象类

为了让子类必须继承父类

4.1 抽象方法、抽象类概念

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

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

4.2 抽象类和抽象方法的定义格式：

// 抽象方法的定义格式：
public abstract 返回值类型 方法名(参数列表);
​
// 抽象类的定义格式：
public abstract class 类名{}
​
//示例
public abstract class Person {
    
    public abstract void work();
}

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

• 抽象类不能实例化（不能创建对象）

• 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

• 抽象类可以有构造方法

• 抽象类的子类

  • 要么重写抽象类中的所有抽象方法（常用）

  • 要么是抽象类

// 父类为抽象类，存在抽象方法
public abstract class Person {
​
    private String name;
    private int age;
​
    //此处的构造方法作用：当子类创建对象的时候，给属性进行赋值
    public Person() {}
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
​
    public abstract void work();
    public void sleep(){ System.out.println("睡觉"); }
    
}
​
​
// Student类继承Person父类，重写了父类(Preson)中的所有抽象方法
public class Student extends Person {
    public Student() { }
    public Student(String name, int age) { super(name, age); }
​
    @Override
    public void work() {
        System.out.println("学生的工作是学习");
    }
}
​
​
// 测试，抽象类(Person)中有抽象方法(work)，子类(Student)继承父类(Person)，Student不是抽象类，可以创建对象
public class Test {
    public static void main(String[] args) {
        //抽象类不能实例化（不能创建对象）
        //Person p = new Person();
​
        Student s = new Student("zhangsan",23);
        System.out.println(s.getName() +"," + s.getAge());
​
    }
}
​
//抽象类的子类 - 也是抽象类
public abstract class Teacher extends Person{ }
​
//抽象类的子类 - 重写抽象类中所有的抽象方法
public class ATeacher extends Teacher{
    @Override
    public void work() {
​
    }
}
​

4.4 练习-编写带有抽象类的标准 javabean 类

青蛙frog      属性：名字，年龄        行为：吃虫子，喝水
狗Dog         属性：名字，年龄        行为：吃骨头，喝水
山羊Sheep     属性：名字，年龄        行为：吃草，喝水

实现代码：

// Animal.java
public abstract class Animal {
    private String name;
    private int age;
​
    public Animal() {}
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    public String getName() {return name;}
    public void setName(String name) {this.name = name;}
    public int getAge() {return age;}
    public void setAge(int age) {this.age = age;}
    
    public void drink(){System.out.println("动物在喝水");}
    public abstract void eat();
    
}
​
//Dog.java
public class Dog extends Animal{
    public Dog() {}
    public Dog(String name, int age) {super(name, age);}
​
    @Override
    public void eat() {System.out.println("狗在吃骨头");}
}
​
//Frog.java
public class Frog extends Animal{
​
    public Frog() {}
    public Frog(String name, int age) {super(name, age);}
​
    @Override
    public void eat() {System.out.println("青蛙在吃虫子");}
}
​
//Sheep.java
public class Sheep extends Animal{
    public Sheep() {}
    public Sheep(String name, int age) {super(name, age);}
​
    @Override
    public void eat() {System.out.println("山羊在吃草");}
}
​
//Test.java
public class Test {
    public static void main(String[] args) {
        //创建对象
        Frog f = new Frog("小绿", 1);
        System.out.println(f.getName() + ", " + f.getAge());
        f.drink();
        f.eat();
​
        Dog d = new Dog();
        d.setName("旺财");
        d.setAge(2);
        System.out.println(d.getName() +", " + d.getAge());
        d.drink();
        d.eat();
​
        Sheep s = new Sheep("山羊", 1);
        System.out.println(s.getName() +", " + s.getAge());
        s.drink();
        s.eat();
    }
}
​

4.5 抽象类、抽象方法的意义

强制子类必须按照某种格式进行重写