Java——抽象类+模板设计模式

1.抽象类介绍

父类方法不确定性的问题

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

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();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

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() + " 工作中...");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

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() + " 工作中...");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

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));
    }
1
2
3
4
5
6
7
8
9
10
11

加法

    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));
    }
1
2
3
4
5
6
7
8
9
10
11

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

1
2
3
4
5
6
7
8
9
10
11
12
13

测试结果
在这里插入图片描述

模板设计模式

抽象类模板设计模式，就是在父类中提取出相同的模板，不同的部分抽象化，在子类中重写抽象函数，需要用到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();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

父类

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

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

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

测试结果
在这里插入图片描述

相关阅读:
学习编程的第二十三天
 perf性能分析工具使用分享
 【单片机毕业设计】【mcuclub-cl-008】基于单片机的出租车计价器的设计
 2023年8月京东冰箱行业品牌销售排行榜（京东数据挖掘）
http请求过程 Android,Cronet android设计与实现分析 HTTP请求启动
 DevExpress开发WPF应用实现对话框总结
 Django之三板斧的使用，全局配置文件介绍，request对象方法，pycharm链接数据库，Django链接数据库，ORM的增删改查
 3DMAX森林树木植物插件ForestPackLite教程
 Nginx几种负载均衡方式介绍
 sys文件系统
原文地址：https://blog.csdn.net/qq_59708493/article/details/124893232

Java——抽象类+模板设计模式

目录

1.抽象类介绍

2.抽象类细节

3.抽象类细节02

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

test01.java

Employee.java

Manager.java

CommonEmployee.java

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

1.普通设计

乘法

加法

main函数

模板设计模式

main函数

父类

AA类

BB类