14_Java中的抽象类

Java中的抽象类

一、抽象类的概述

例如我们前面使用的动物类，并不是一个具体的事物，在这个类中我们是不应该给出方法的具体实现的，应当只是声明

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

关键字：abstract

注意：抽象类无法创建对象

参考代码：

package com.itheima_01;
/*
动物类
 */
//抽象方法必须在抽象类中，即一个类中只要有了抽象方法那么这个类就是抽象类
public abstract class Animal {
 
   /* public void eat(){
        System.out.println("吃东西");
    }*/
    //删除了方法体后报错：没有方法体或者没有声明抽象类
    public abstract void eat();
}

package com.itheima_01;
 
public class AnimalDemo {
 
    public static void main(String[] args) {
        //一个抽象类不是一个具体的类 无法创建对象
       /* Animal a = new Animal();
        a.eat();*/
    }
}

二、抽象类的特点

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

​ public abstract class 类名{}

​ public abstract void eat();

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

​

3、抽象类不可以实例化对象（但是可以利用其引用类型，指向子类对象来实例化对象）

​ 如何调用抽象类中的成员（即实例化对象）？ 需要参照多态的方式，通过子类对象实例化，这叫抽象多态

4、抽象类的子类

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

​ 要么也是抽象类（继承了抽象类中的抽象方法，而有抽象方法又一定是抽象类，所以不重写就是抽象类）

5、参考代码：

package com.itheima_02;
/*
     抽象类
 */
public abstract class Animal {
    //创建抽象方法
    public abstract void eat();
 
    //创建一个非抽象方法 通过注释可以发现：有抽象方法一定是抽象类，但是抽象类中不一定有抽象方法
    public void sleep(){
        System.out.println("睡觉");
    }
}

package com.itheima_02;
/*
创建一个Cat类来继承抽象类（注意继承抽象类，必须重写抽象方法）
 */
public class Cat extends Animal{//!!而且是重写所有抽象方法，不然找不到实现（在调用时）
    @Override
    public void eat(){  //重写时，不需要在写abstract
        System.out.println("猫吃老鼠");
    }
}

package com.itheima_02;
/*
 
 */
public abstract class Dog extends Animal{
    //抽象类的子类
    // 要么重写抽象类中的方法
    // 要么其本身就是一个抽象类
}

package com.itheima_02;
/*
    测试类
 */
public class AnimalDemo {
    public static void main(String[] args){
//        Animal a = new Animal();
        //抽象类无法自己创建对象，但是可以参照多态的方法来访问里面的内容
        Animal a = new Cat();   //等号左边是 类的引用 | 右边是创建对象
        a.eat();    //编译看左边，执行看右边
        a.sleep();  //这个方法子类中，没有但是是被继承到子类中了
 
    }
}

三、抽象类的成员特点

1、可以有成员变量

​ 可以是变量

​ 也可以是常量

2、可以有构造方法

​ 有构造方法，但是本身不能够示例化对象

​ 只是用于子类初始化时，访问父类构造方法（子类构造语句中的默认语句：super(); ）

3、可以有成员方法

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

​ 可以是非抽象方法：用于提高代码复用性

4、参考代码：

package com.itheima_03;
/*
抽象类
 */
public abstract class Animal {
    //抽象类中可以成员变量（且可以是变量或者常量）
    private int age = 20;
    private final String city = "北京";
 
    /*
    抽象类是可以有构造方法的
    ????为什么  抽象类虽然不能直接实例化对象，但是通过多态进行间接实例化对象时，会使用继承
    而在继承中，子类构造函数调用时会先执行默认语句super();
    来调用父类构造方法所以父类是需要构造方法的 （抽象类可以理解为特殊的一个父类）
    抽象 可以利用多态方法进行实例化对象，而多态的前提之一（目前）就是继承
     */
    public Animal(){}
 
    public Animal(int age){
        this.age = age;
    }
 
    //抽象类中可以又成员函数（且可以是非抽象方法或者抽象方法）
    public void show(){
        age = 40;
        System.out.println(age);
        //city = "上海";    使用了final修饰不能在赋值了
        System.out.println(city);
    }
 
    public abstract void eat();
}

package com.itheima_03;
/*
创建一个Cat类来继承抽象类
 */
public class Cat extends Animal{
    //抽象类中的抽象方法 是用来限制其子类必须要重写抽象方法的（除非子类也是抽象类）
    @Override
    public void eat(){
        System.out.println("猫吃老鼠");
    }
}

package com.itheima_03;
/*
测试类：抽象类的成员特点
 */
public class AnimalDemo {
    public static void main(String[] args) {
        Animal a = new Cat();
        a.eat();
        a.show();
    }
}

四、抽象类的案例

package com.itheima_04;
/*
抽象类
 */
public abstract class Animal {
    //成员变量
    private String name;
    private int age;
 
    //构造方法
    public Animal(){}
 
    public Animal(String name, int age){
        this.name = name;
        this.age = age;
    }
 
    //set/get/show方法
    public void setName(String name){
        this.name = name;
    }
 
    public String getName(){
        return this.name;
    }
 
    public void setAge(int age){
        this.age = age;
    }
 
    public int getAge(){
        return this.age;
    }
 
    public void show(){
        System.out.println(getName() + "," + getAge());
    }
 
    //创建一个抽象方法
    public abstract void eat();
}

package com.itheima_04;
 
public class Cat extends Animal{
    //构造方法
    public Cat(){}
 
    public Cat(String name, int age){
        //此处可以使用 super(name, age);
        //来修改默认语句从而调用抽象类中的有参构造方法    (可参照继承中的构造方法)
        super(name, age);   //这两个属性在抽象父类中的访问权限是：private没有被继承过来
    }
 
    @Override
    public void eat(){
        System.out.println("猫吃老鼠");
    }
}

package com.itheima_04;
 
public class Dog extends Animal{
    //构造方法
    public Dog(){}
 
    public Dog(String name, int age){
        super(name, age);
    }
 
    @Override
    public void eat(){
        System.out.println("狗吃骨头");
    }
}

package com.itheima_04;
/*
测试类
 */
public class AnimalDemo {
    public static void main(String[] args) {
        //创建猫类对象
        Animal a1 = new Cat();
        a1.setName("Tom");
        a1.setAge(7);
        System.out.println(a1.getName() + "," + a1.getAge());
        a1.eat();
 
        Animal a2 = new Cat("加菲猫", 4);
        System.out.println(a2.getName() + "," + a2.getAge());
        a2.eat();
 
        //创建狗类对象
        Animal a3 = new Dog();
        a3.setName("旺财");
        a3.setAge(6);
        System.out.println(a3.getName() + "," + a3.getAge());
        a3.eat();
 
        Animal a4 = new Dog("来福", 8);
        System.out.println(a4.getName() + "," + a4.getAge());
        a4.eat();
    }
}