Java面向对象（四）

抽象类概述

抽象的表述:

我们之前所说的猫,狗,猪,羊驼,熊猫等等都是动物的具体的例子,而动物本身是一个抽象的 概念,而我们之前是将动物写成了一个类,而类又可以创建对象,但是呢,实际上抽象的东西本身应该不能 实例化,并且动物这个概念中吃的方法,以及动物共有的方法本身也是一个不具体的方法, 我们在今天之后,把一个不具体的功能,叫做抽象方法,而如果说一个类中包含有抽象方法的时候, 这个类叫做抽象类。

抽象类的特点:

1、抽象类和抽象方法要用abstract关键字修饰

修饰类 放在class前面 举例： abstract class Animal3{} 修饰方法 放在访问权限修饰符的后面 举例： public abstract void eat();

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

3、抽象类不能被实例化

既然不能被实例化，那写在抽象类中具体的方法怎么去调用呢？ 抽象类如果创建呢？ 利用多态的形式，通过具体的子类实例化去调用方法

4、如果继承抽象类是一个具体的类，要重写抽象类所有的抽象方法，如果是一个抽象类继承抽象类， 不需要重写抽象类中的方法

//定义了一个抽象类，叫Animal3
abstract class Animal3{
    //注意：
    //  抽象方法没有方法体{}，连大括号都没有，直接以分号结尾
    //Error:(26, 26) java: 抽象方法不能有主体
//    public abstract void eat(){};
    public abstract void eat();
​
    public void fun(){
        System.out.println("这是抽象类中的具体实现的fun方法");//抽象类例既可有抽象方法也可有非抽象方法
    }
}
​
class Dog3 extends Animal3{
    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }
    //Error:(37, 1) java: com.shujia.wyh.day16.Dog3不是抽象的, 并且未覆盖com.shujia.wyh.day16.Dog3中的抽象方法show()
//    public abstract void show();
}
​
abstract class Demo2 extends Animal3{
​
}
​
​
public class AbstractDemo1 {
    public static void main(String[] args) {
        //Error:(46, 21) java: com.shujia.wyh.day16.Animal3是抽象的; 无法实例化
        //Animal3 a = new Animal3();//抽象类不能创建对象
​
        //使用抽象多态的形式创建
        Animal3 a = new Dog3();
        a.eat();
        a.fun();
​
    }
}

抽象类特点

/*
    在抽象的动物类中定义两个抽象方法。吃饭和睡觉。
​
 */
​
abstract class Animal4{
    //定义一个抽象方法吃饭，不给出具体实现
    public abstract void eat();
​
    //定义一个抽象方法睡觉，不给出具体实现
    public abstract void sleep();
}
​
class Dog4 extends Animal4{
    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }
​
    @Override
    public void sleep() {
        System.out.println("狗侧着睡");
    }
​
    public void lookDoor(){
        System.out.println("看门");
    }
}
​
class Cat4 extends Animal4{
​
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
​
    @Override
    public void sleep() {
        System.out.println("猫趴着睡");
    }
}
​
​
public class AbstractTest1 {
    public static void main(String[] args) {
        //使用抽象多态创建第一个对象
        Animal4 a = new Dog4();
        a.eat();
        a.sleep();
//        a.lookDoor();
        Dog4 d = (Dog4)a;
        d.lookDoor();
​
​
        //使用抽象多态创建第二个对象
        Animal4 a2 = new Cat4();
        a2.eat();
        a2.sleep();
​
    }
}

抽象类的成员特点

成员变量

​ 可以是变量，也可以是常量

构造方法

​ 有构造方法，但是我们上一个程序中总结出抽象类不能实例化，那构造的意义是
​ 什么呢？要想初始化子类，就必须先初始化父类，在继承的关系中有用

成员方法

​ 可以有抽象方法 限定子类必须完成某些动作
​ 也可以有非抽象方法 提高代码复用性

abstract class Animal5{
    public int a;//常量
    public final int b = 20;//变量

    Animal5(){
        a = 20;
        System.out.println(a);
    }
}

class Dog5 extends Animal5{

}

public class AbstractDemo2 {
    public static void main(String[] args) {
        Dog5 dog5 = new Dog5();//初始化
    }
}

猫狗案例

​ 具体事物：猫，狗
​ 共性：姓名，年龄，吃饭
分析：从具体分析到抽象的过程
​ 猫：Cat
​ 成员变量：姓名，年龄
​ 构造方法：无参构造，有参构造
​ 成员方法：吃饭（猫吃鱼）

​ 狗：Dog
​ 成员变量：姓名，年龄
​ 构造方法：无参构造，有参构造
​ 成员方法：吃饭（狗吃肉）

​ 通过分析我们发现，两个类存在相同的内容，所以提取出一个抽象类：Animal6

​ 抽象动物类：
​ 成员变量：姓名，年龄
​ 构造方法：无参构造，有参构造
​ 成员方法：吃饭（该方法是抽象的，没有具体的实现）

//定义一个抽象动物类
abstract class Animal6 {
    //姓名
    private String name;
    //年龄
    private int age;

    //无参构造
    Animal6() {

    }

    //有参构造
    Animal6(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;
    }

    //show方法，输出所有的成员变量值
    public void show() {
        System.out.println("姓名：" + this.name + ",年龄：" + this.age);
    }

    //吃饭的抽象方法
    public abstract void eat();
}

class Dog6 extends Animal6 {

    Dog6() {

    }

    Dog6(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }
}

class Cat6 extends Animal6 {

    Cat6() {

    }

    Cat6(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

public class AbstractTest2 {
    public static void main(String[] args) {
        //使用多态创建第一个对象
        Animal6 a = new Dog6("小白", 3);
        a.show();
        a.eat();

        //创建第二个对象，使用公共的getXxx和setXxx进行赋值
        Animal6 a2 = new Dog6();
        a2.setName("大黄");
        a2.setAge(4);
        a2.show();
        a2.eat();

        //创建第三个对象
        Animal6 a3 = new Cat6("小黑",2);
        a3.show();
        a3.eat();
    }
}

老师案例

​ 具体事物：基础班老师，大数据班老师
​ 共性：姓名，年龄，讲课。

abstract class Teacher{
    private String name;
    private int age;

    public Teacher() {
    }

    public Teacher(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 abstract void teach();
}

class JavaTeacher extends Teacher{

    public JavaTeacher() {
    }

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

    @Override
    public void teach() {
        System.out.println("教java SE基础");
    }
}

class BigDataTeacher extends Teacher{

    public BigDataTeacher() {
    }

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

    @Override
    public void teach() {
        System.out.println("教大数据");
    }
}

public class AbstractTest3 {
    public static void main(String[] args) {
        //创建一个对象，使用构造方法给成员变量进行赋值，并使用getXxx获取值
        //抽象多态的形式创建对象
        Teacher t1 = new JavaTeacher("小虎",18);
        System.out.println(t1.getName()+"---"+t1.getAge());
        t1.teach();

        //创建一个对象，使用setXxx对成员变量进行赋值，并使用getXxx获取值
        Teacher t2 = new BigDataTeacher();
        t2.setName("火火");
        t2.setAge(19);
        System.out.println(t2.getName()+"---"+t2.getAge());
        t2.teach();
    }
}

员工案例

假如我们在开发一个系统时需要对员工类进行设计，员工包含3个属性：姓名、工号以及工资。
经理也是员工，除了含有员工的属性外，另为还有一个奖金属性。
请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。

分析：
普通员工：
成员变量：姓名，工号，工资
成员方法：工作（搬砖）
经理：
成员变量：姓名，工号，工资，奖金
成员方法：工作（做PPT）

实现：
员工类：（抽象类）
普通员工类：
经理：

//定义一个员工类
abstract class Staff {
    private String name;
    private int age;
    private String id;
    private int salary;

    public Staff() {
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }

    public Staff(String name, int age, String id, int salary) {
        this.name = name;
        this.age = age;
        this.id = id;
        this.salary = salary;

    }

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

//定义一个具体的普工类
class CommonWorker extends Staff{

    public CommonWorker() {
    }

    public CommonWorker(String name, int age, String id,int salary) {
        super(name, age, id, salary);
    }

    @Override
    public void work() {
        System.out.println("搬砖");
    }
}


class Manager extends Staff{
    //奖金属性
    private int bonus;

    public Manager() {
    }

    public Manager(String name, int age, String id, int salary, int bonus) {
        super(name, age, id, salary);
        this.bonus = bonus;
    }

    public int getBonus() {
        return bonus;
    }

    public void setBonus(int bonus) {
        this.bonus = bonus;
    }

    @Override
    public void work() {
        System.out.println("做PPT");
    }
}


public class AbstractTest4 {
    public static void main(String[] args) {
        //创建第一个对象
        Staff cw1 = new CommonWorker("李玉伟", 18, "Alibaba2000", 20000);
        cw1.work();

        //创建第二个对象
        Staff s2 = new Manager();
        s2.setName("杨旭");
        s2.setAge(23);
        s2.setId("TengXun1000");
        s2.setSalary(30000);
//        s2.setBonus(200000);
        //将s2进行向下转型

        Manager m = (Manager)s2;
        m.setBonus(200000);

        System.out.println(s2.getName()+"---"+s2.getAge()+"---"
                +s2.getId()+"---"+s2.getSalary()+"----"+((Manager) s2).getBonus());
        s2.work();
    }
}