1.抽象类介绍

父类方法不确定性的问题

===> 考虑将该方法设计为抽象（abstract）方法
//===> 所谓抽象方法就是没有实现的方法
//===> 所谓没有实现就是指，没有方法体
//===> 当一个类中存在抽象方法时，需要将该类声明为abstract类
//===> 一般来说，抽象类会被继承，有其子类来实现抽象方法.

package com.demo.abstract_;

public class Abstract01 {
    
    public static void main(String[] args) {
    

    }
}

abstract class Animal {
    
    private String name;

    public Animal(String name) {
    
        this.name = name;
    }

    //思考：这里eat 这里你实现了，其实没有什么意义
    //即： 父类方法不确定性的问题
    //===> 考虑将该方法设计为抽象(abstract)方法
    //===> 所谓抽象方法就是没有实现的方法
    //===> 所谓没有实现就是指，没有方法体
    //===> 当一个类中存在抽象方法时，需要将该类声明为abstract类
    //===> 一般来说，抽象类会被继承，有其子类来实现抽象方法.
//    public void eat() {
    
//        System.out.println("这是一个动物，但是不知道吃什么..");
//    }
    public abstract void eat()  ;
}

2.抽象类细节

1.//抽象类，不能被实例化
2. //抽象类不一定要包含abstract方法。也就是说,抽象类可以没有abstract方法
//，还可以有实现的方法。
3.//一旦类包含了abstract方法,则这个类必须声明为abstract
4.//abstract 只能修饰类和方法，不能修饰属性和其它的

package com.demo.abstract_;

public class AbstractDetail01 {
    
    public static void main(String[] args) {
    
        //抽象类，不能被实例化
        //new A();
    }
}
//抽象类不一定要包含abstract方法。也就是说,抽象类可以没有abstract方法
//，还可以有实现的方法。
abstract class A {
    
    public void hi() {
    
        System.out.println("hi");
    }
}
//一旦类包含了abstract方法,则这个类必须声明为abstract
abstract class B {
    
    public abstract void hi();
}
//abstract 只能修饰类和方法，不能修饰属性和其它的
class C {
    
   // public abstract int n1 = 1;
}

3.抽象类细节02

1.//抽象方法不能使用private、final 和 static来修饰，因为这些关键字都是和重写相违背的
2.如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类
3.//抽象类的本质还是类，所以可以有类的各种成员

package com.demo.abstract_;

public class AbstractDetail02 {
    
    public static void main(String[] args) {
    
        System.out.println("hello");
    }
}
//抽象方法不能使用private、final 和 static来修饰，因为这些关键字都是和重写相违背的
abstract class H {
    
    public   abstract void hi();//抽象方法
}

//如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类
abstract class E {
    
    public abstract void hi();
}
abstract class F extends E {
    

}
class G extends E {
    
    @Override
    public void hi() {
     //这里相等于G子类实现了父类E的抽象方法，所谓实现方法，就是有方法体

    }
}

//抽象类的本质还是类，所以可以有类的各种成员
abstract class D {
    
    public int n1 = 10;
    public static  String name = "Demo龙";
    public void hi() {
    
        System.out.println("hi");
    }
    public abstract void hello();
    public static void ok() {
    
        System.out.println("ok");
    }
}

4.抽象类实例(员工问题）

test01.java

package com.demo.abstract_;

public class test01 {
    
    public static void main(String[] args) {
    
        //测试
        Manager jack = new Manager("jack", 999, 50000);
        jack.setBonus(8000);
        jack.work();

        CommonEmployee tom = new CommonEmployee("tom", 888, 20000);
        tom.work();
    }
}

Employee.java

package com.demo.abstract_;

abstract public class Employee {
    
    private String name;
    private int id;
    private double salary;

    public Employee(String name, int id, double salary) {
    
        this.name = name;
        this.id = id;
        this.salary = salary;
    }
    //将work做成一个抽象方法
    public abstract void work();
    public String getName() {
    
        return name;
    }

    public void setName(String name) {
    
        this.name = name;
    }

    public int getId() {
    
        return id;
    }

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

    public double getSalary() {
    
        return salary;
    }

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

Manager.java

package com.hspedu.abstract_;

public class Manager extends Employee {
    

    private double bonus;
    public Manager(String name, int id, double salary) {
    
        super(name, id, salary);
    }

    public double getBonus() {
    
        return bonus;
    }

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

    @Override
    public void work() {
    
        System.out.println("经理 " + getName() + " 工作中...");
    }
}

CommonEmployee.java

package com.hspedu.abstract_;

public class CommonEmployee extends Employee{
    
    public CommonEmployee(String name, int id, double salary) {
    
        super(name, id, salary);
    }

    @Override
    public void work() {
    
        System.out.println("普通员工 " + getName() + " 工作中...");
    }
}

5.抽象类-模板设计模式

计算指定算法所需要的时间

1.普通设计

乘法

    public void job1() {
    
        //得到开始的时间
        long start = System.currentTimeMillis();
        long num = 1;
        for (long i = 1; i <= 200000; i++) {
    
            num *= i;
        }
        //得的结束的时间
        long end = System.currentTimeMillis();
        System.out.println("AA 执行时间 " + (end - start));
    }

加法

    public void job2() {
    
        //得到开始的时间
        long start = System.currentTimeMillis();
        long num = 0;
        for (long i = 1; i <= 200000; i++) {
    
            num += i;
        }
        //得的结束的时间
        long end = System.currentTimeMillis();
        System.out.println("AA 执行时间 " + (end - start));
    }

main函数

package com.hspedu.abstract_;

public class TestTemplate {
    
    public static void main(String[] args) {
    

        AA aa = new AA();
        aa.calculateTime(); //这里还是需要有良好的OOP基础，对多态

        BB bb = new BB();
        bb.calculateTime();
    }
}

测试结果

模板设计模式

抽象类模板设计模式，就是在父类中提取出相同的模板，不同的部分抽象化，在子类中重写抽象函数，需要用到OOP中的动态绑定机制

main函数

package com.demo.abstract_;

public class TestTemplate {
    
    public static void main(String[] args) {
    

        AA aa = new AA();
        aa.calculateTime(); //这里还是需要有良好的OOP基础，对多态

        BB bb = new BB();
        bb.calculateTime();
    }
}

父类

package com.hspedu.abstract_;

abstract public class Template {
     //抽象类-模板设计模式

    public abstract void job();//抽象方法

    public void calculateTime() {
    //实现方法，调用job方法
        //得到开始的时间
        long start = System.currentTimeMillis();
        job(); //动态绑定机制
        //得的结束的时间
        long end = System.currentTimeMillis();
        System.out.println("任务执行时间 " + (end - start));
    }
}

AA类

package com.hspedu.abstract_;

public class AA extends Template {
    

    //计算任务
    //1+....+ 800000
    @Override
    public void job() {
     //实现Template的抽象方法job

        long num = 0;
        for (long i = 1; i <= 800000; i++) {
    
            num += i;
        }
    }

//    public void job2() {
    
//        //得到开始的时间
//        long start = System.currentTimeMillis();
//        long num = 0;
//        for (long i = 1; i <= 200000; i++) {
    
//            num += i;
//        }
//        //得的结束的时间
//        long end = System.currentTimeMillis();
//        System.out.println("AA 执行时间 " + (end - start));
//    }
}

BB类

package com.hspedu.abstract_;

public class BB extends Template{
    

    public void job() {
    //这里也去，重写了Template的job方法

        long num = 0;
        for (long i = 1; i <= 80000; i++) {
    
            num *= i;
        }

    }
}

测试结果