从零学Java - 面向对象 abstract

面向对象 abstract

文章目录

面向对象 abstract
- 1.什么是抽象?
- - 1.1 生活中的抽象
- 2.抽象类
- - 2.1 不该被创建对象的类
  - 2.2 抽象类的语法
  - 2.3 抽象类的作用
  - 2.4 抽象类的特点
- 3.抽象方法
- - 3.1 不该被实现的方法
  - 3.2 抽象方法的语法
  - 3.3 抽象方法的特点
- 4.总结
- - 4.1 抽象类
  - 4.2 抽象方法

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("猫咪吃小鱼...");
    }
}