面向对象—抽象

目录

1.抽象类

1.1抽象类概述

1.2抽象类的特点

1.3抽象类的成员特点

---

1.抽象类

回想一下前面学习过的猫狗案例，我们提取出了一个动物类，这个时候我们可以通过Anima a = new Animal();来创建一个动物类对象。其实这个是不对的，因为我说一个动物，你不知道我说的哪个动物，只有看到了具体的动物才知道这是什么动物，所以动物本身并不是具体的一个事物，而是一个抽象的事物。只有真正的例如：猫、狗；它们才是具体的事物，所以说我们前面的设计是有问题的。同理我们也可以想一想不同的动物它吃的是不同的食物，所以呢我们也不应该在动物类中给出具体的吃的方法实现，只应该给出一个吃的方法声明，不给方法体。接下来就要说一下：

1.1抽象类概述

在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。

直接代码演示：

public abstract class Animal {
    //1.动物类里面有一个eat方法
    //4.注释调eat方法
//    public void eat(){
//        System.out.println("吃东西");
//    }

    /*5.然后我们来说一下一个方法我们不给出方法体，是什么样子
    就是public void eat();但是这样会报错：没有方法体
    这样行不通，所以我们要把它定义成一个抽象的方法需要使用
    关键字abstract，这样还是会报错，因为抽象方法必须在
    抽象类中，这样我们把类改为抽象类就可以了
     */
    public abstract void eat();//抽象法不能有主体所以要分号结尾
}
class AnimalDemo {
    public static void main(String[] args) {


        //2.在测试类里面创建了动物对象，并调用了eat方法
        //6.定义好抽象方法后这里会报错，因为：动物类是抽象的;不能创建对象
//7.        Animal a = new Animal();（先了解一下，怎么改后面来说）
//7.        a.eat();//吃东西

        /*3.假如说将来有一个猫类继承了动物类，它并没有重写eat方法，
        它将来调用eat方法的时候，在控制台输出的也是吃东西。
        那我建立一个狗类，他也没有重写eat方法，那么它将来调用
        eat方法的时候在控制台输出的也是吃东西，而猫和狗吃的东西
        是不一样的，所以说我们在动物类里面不应该给出这样具体的实现。
         */

    }
}

1.2抽象类的特点

先到程序中演示再小结：

/*
    1.进来首先先写eat抽象方法，不给方法体
 */
public abstract class Animal {
    //2.类和方法都要加上abstract，才不会报错
    public abstract void eat();

    //3.再写一个方法
    public void sleep(){
        System.out.println("睡觉");
    }
    /*4.这样写不报错，就说明抽象类里面是可以有
    非抽象方法的，就算把抽象方法注释掉也没有问题，
    但是这样是没有意义的，因为抽象类里面一定会有
    抽象方法的
     */

    /*5.也就是说一个类里面有抽象方法，它一定是抽象类
    但是抽象类里面可以没有抽象方法，这是抽象类的第二个特点
     */
}
class Cat extends Animal{
    //8.继承之后会报错，只要重写方法后就好了
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    /*13.现在来说抽象类的第四个特点：也就是
    抽象类的子类，子类Cat继承了抽象类重写了，
    抽象类里面的抽象方法，如果抽象类里面再有其他的
    抽象方法，这个子类也要重写这个抽象类里的抽象方法。
    也就是说它继承了抽象类，就要重写抽象类里的所有方法！
    那么还有一个情况，就要再创建一个类→14.
     */

}
//14.让他继承自Animal
abstract class Dog extends Animal{
    /*15.继承之后就报错了，虽然重写一下
    抽象方法就好了，但是我就是不想重写怎么办呢？
    继承了抽象类就代表这个类里面把父类的抽象方法
    也给继承过来了，不想重写的话就把这个Dog类改成
    抽象类就不会报错了
     */

    /*16.也就是说抽象类的子类要么，重写这个抽象类中的所有
    抽象方法，要么它本身也是一个抽象类
         */
}


/*
    测试类
 */
class AnimalDemo {
    public static void main(String[] args) {
        //6.类有了，创建对象
//        Animal a = new Animal();
        /*7.这样就报错了，因为Animal是抽象类不是具体的所以说，
        它不能创建对象，但是Animal类里面有内容啊，内容可以被访问啊
        所以他应该可以创建对象啊，所以这里我们要解决的就是抽象类
        如何创建对象，我们先把上面创建对象注释掉。抽象类他会参照多态
        的形式来创建对象，既然是多态那他就一定得有继承，所以要先创建
        子类。
         */

        //9.现在创建对象就要采用多态的形式：
        Animal a = new Cat();
        //10.调用重写方法和动物类的非抽象方法
        a.eat();//猫吃鱼
        a.sleep();//睡觉

        /*11.这个eat方法，它在Animal里面虽然是抽象的，但是它在子类
        里面被改写了，我们说编译看左边，左边有。然后执行看右边，右边
        重写了；所以说会在控制台输出猫吃鱼，然后这个sleep方法编译看左边
        左边有，执行看右边，虽然右边没有重写，但是左边这是带有方法体的，
        所以会被继承过去，在控制台输出睡觉。*/

        /*12.所以他虽然不能直接实例化，但是它可以参照多态的方式，通过
        子类对象来实例化。*/
    }
}

小结抽象类的特点：

• 抽象类和抽象方法必须使用abstract关键字修饰。

public abstract class类名 { }

public abstract void 方法名（）；

• 抽象类中不一定有抽象方法，由抽象方法的类一定是抽象类
• 抽象类不能实例化

抽象类如何实现实例化呢？

参照多态的方式，通过子类对象实例化，这叫抽象类多态。

• 抽象类的子类

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

要么是抽象类。

1.3抽象类的成员特点

先到程序中演示再小结：

/*
    抽象类
 */
public abstract class Animal {
    //1.研究抽象类里面可以有那些成员，看看抽象类和其他类是否一样
    private  int age = 20;//没问题
    private final String city = "北京";//也没问题
    /*2.由此可见抽象类是包含成员变量的
    这个变量它可以是变量也可以是常量
     */

    /*3.定义方法测试变量/常量,这个方法一些出来也代表
    抽象类是可以有非抽象方法的
     */
    public void show(){
        //4.在方法内来更改变量/常量的值
        age = 40;//没有问题，因为这里没用final修饰
//        city = "四川";//报错，因为city是常量
        System.out.println(age);
        System.out.println(city);
    }

    //5.来一个抽象方法
    public abstract void eat();//也是可以的，说明抽象类中也是包含抽象方法的
    //6.由此可见，抽象类中的方法可以是抽象的也可以是非抽象的。

    //7.验证抽象类里面是否可以有构造方法
    public Animal(){
        //8.没报错，说明它可以有构造方法
    }
    /*9.不是说抽象类不可以实例化嘛，怎么可以有构造方法呢？
    强调：学习的抽象类不可以实例化指的是它不能直接实例化，但是
    它可以通过多态的方式来实例化，它的构造方法的作用就是用于子类
    访问父类数据的初始化。也就是在子类的构造方法中，会来访问父类的
    构造方法用于对父类的数据初始化，所以它也要提供构造方法。
     */

    //10.写一个带参的构造方法
    public Animal(int age) {
        this.age = age;
    }

    /*11.show方法是非抽象方法它可以提高代码的复用性
    它是由继承保证的
     */

    //12.eat抽象方法有什么用呢？新建一个类→13.
}
/*13.我让Cat继承自Animal
现在我让这个类什么都不做就会报错，
因为这个类必须去重写父类的eat方法，因为
eat方法是用抽象修饰的。
由此可见父类中的抽象方法就是限制子类必须要去做某些事情
 */
class Cat extends Animal{
    //14.改写后就没有问题了
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
class AnimalDemo {
    public static void main(String[] args) {
        //15.创建一个对象，调用方法
        Animal a = new Cat();
        a.show();//这里输出的是Animal里非抽象方法show的内容
        a.eat();//这里输出的是Animal子类Cat中重写的eat方法
    }
}

小结抽象类的成员特点：

• 抽象类可以有成员变量

可以是变量；

也可以是常量。

• 抽象类可以有构造方法

有构造方法，但是不能实例化；

那么构造方法的作用是什么呢？

用于子类访问父类数据的初始化。

• 抽象类可以有成员方法

可以有抽象方法：限定子类必须完成某些动作。

也可以有非抽象方法：提高代码复用性。