从零学Java - 面向对象 abstract

面向对象 abstract

1.什么是抽象?

似是而非的，像却又不是；具备某种对象的特征，但不完整。

1.1 生活中的抽象

搜索结果都是“动物”的子类对象，而没有“动物”对象。都是动物其中的一种,不存在“动物”的实例;

2.抽象类

2.1 不该被创建对象的类

Animal仅是一种会吃会睡的对象，再无其他行为，不够具体、不够完整。

public class Animal {
    private String breed;
    private int age;
    private String gender;

    public void eat() {
        System.out.println("动物开始吃东西...");
    }

    public void sleep() {
        System.out.println("动物开始休息...");
    }

    public void show() {
        System.out.println("动物信息, 品种: "+this.breed+" 年龄: "+this.age+" 性别: "+this.gender);
    }
}

程序是用来模拟现实世界、解决现实问题的；现实世界中存在的都是“动物”具体的子类对象，并不存在“动物”对象，所以，Animal不应该被独立创建成对象。

如何限制这种对象的创建？

2.2 抽象类的语法

概念: 被abstract修饰的类，称为抽象类。抽象类意为不够完整的类、不够具体的类，抽象类对象无法独立存在，即不能new对象。

语法: public abstract class Animal {…}

eg:

//Test
public class Test {
    public static void main(String[] args) {
        Animal dog = new Dog();

        dog.eat();
        dog.sleep();
        dog.show();
    }
}

//Animal
public abstract class Animal {
    private String breed;
    private int age;
    private String gender;

    public Animal() {
    }

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

    public void eat() {
        System.out.println("动物吃东西...");
    }

    public void sleep() {
        System.out.println("动物休息...");
    }

    public void show() {
        System.out.println("动物信息...");
    }
}

//Dog
public class Dog extends Animal{
    private String color;
    
	public Dog() {
    }

    public Dog(String breed, int age, String gender, String color) {
        super(breed, age, gender);
        this.color = color;
    }
    
    @Override
    public void eat() {
        System.out.println("狗狗啃骨头...");
    }

    @Override
    public void sleep() {
        System.out.println("狗狗休息...");
    }

    @Override
    public void show() {
        System.out.println("狗狗信息...");
    }
}

2.3 抽象类的作用

作用：

• 可被子类继承，提供共性属性和方法。
• 可声明为引用，更自然的使用多态。

经验: 抽象父类，可作为子类的组成部分，依附于子类对象存在，由父类共性+子类独有组成完整的子类对象。

2.4 抽象类的特点

• 抽象类不能new对象，但可以声明变量，可以被子类继承。
• 抽象类中可以包含属性和非抽象方法，也可以包含抽象方法。
• 抽象类中有构造方法，只能被子类调用。

3.抽象方法

3.1 不该被实现的方法

方法声明必要，方法实现多余。

eg:

需求：Dog中的eat()应输出“狗在吃骨头”  Cat中的eat()应输出“猫在吃鱼”

abstract class Animal {
	public void eat() {
        System.out.println("动物吃东西...");
    }	
}

class Dog extends Animal{}
class Cat extends Animal{}

父类提供的方法很难满足子类不同需求，如不定义，则表示所有动物都不会吃、睡。如定义，略显多余，多数会被子类重写。

3.2 抽象方法的语法

概念：被abstract修改的方法，称为抽象方法，只有方法声明，没有方法实现（{}的部分）。意为不完整的方法，必须包含在抽象类中。

产生继承关系后，子类必须重写父类中所有的抽象方法，否则子类还是抽象类。

eg:

abstract class Animal {
	public abstract void eat();
}

class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗狗啃骨头...");
    }
}
class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫咪吃小鱼...");
    }
}

3.3 抽象方法的特点

• 抽象方法只有方法声明，没有方法实现。
• 包含抽象方法的类一定是抽象类。
• 抽象方法必须被子类重写，除非子类也是抽象类。

4.总结

4.1 抽象类

被abstract修饰的类

• 抽象类不能new对象，但可以声明引用，可以被子类继承。
• 抽象类中可以包含属性和非抽象方法，也可以包含抽象方法。
• 抽象类中可以包含构造方法，只能被子类调用。

4.2 抽象方法

被abstract修饰的方法

• 抽象方法只有方法声明，没有方法实现。
• 包含抽象方法的类一定是抽象类。
• 抽象方法必须被子类重写，除非子类也是抽象类。