Java抽象类和抽象方法

一、抽象方法

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

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

3.抽象类和抽象方法的定义格式

（1）抽象方法的定义格式：public abstract 返回值类型 方法名(参数列表);

（2）抽象类的定义格式：public abstract class 类名{}

示范：

package a01abstractdemo1;

public abstract class Person {
    public abstract void work();
}

4.抽象类和抽象方法的注意事项：

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

（2）抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

（3）可以有构造方法

（4）抽象类的子类要么重写抽象类中的所有抽象方法，要么是抽象类

示范：

父类Person:

package a01abstractdemo1;

public abstract class Person {
     private String name;
     private int age;

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

    public Person() {
    }
    //可以有构造方法作用：当创建子类对象时，给属性进行赋值的

    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("睡觉");
    }
}

子类1Student：抽象类的子类要么重写抽象类中的所有抽象方法

package a01abstractdemo1;

public class Student extends Person{
    public Student(String name, int age) {
        super(name, age);
    }

    public Student() {
    }

    @Override
    public void work() {
        System.out.println("学生的工作是学习");
    }
}

子类2Teacher：抽象类的子类要么是抽象类

package a01abstractdemo1;

public abstract class Teacher extends Person{
}

测试类Test:

package a01abstractdemo1;

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());
    }
}

运行结果：

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

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

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

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

父类：Animal：

package a02abstractdemo2;
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();
}

子类1Frog：

package a02abstractdemo2;

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

    public Frog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("青蛙在吃虫子");
    }
}

子类2Dog：

package a02abstractdemo2;

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

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {

        System.out.println("狗吃骨头");
    }
}

子类3Sheep：

package a02abstractdemo2;

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

    public Sheep(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("山羊吃草");
    }
}

运行结果：

5.抽象类和抽象方法的意义：

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