【Java SE】抽象类/方法、模板设计模式

目录

1.抽象类/方法

1.1 基本介绍

1.2 语法格式

1.3 使用细节

2. 模板设计模式（抽象类使用场景）

2.1 基本介绍

2.2 具体例子

---

1.抽象类/方法

1.1 基本介绍

① 当父类的某些方法，需要声明，但是又不确定如何实现时，可以将其声明为抽象方法

② 类中只要存在一个抽象方法，则该类必须为抽象类

③ 抽象类的价值更多作用在于设计，具体来说：设计者设计好后，让子类继承并实现父类的抽象方法

public class Test {public static void main(String[] args) {Dog dog = new Dog();dog.eat();}
}//抽象类
abstract class Animal{//抽象方法,只知道吃的动作，但不知道具体的动物吃什么东西public abstract void eat();
}class Dog extends Animal{public void eat(){System.out.println("狗吃骨头");}
}

1.2 语法格式

• 抽象类：被 abstract 修饰的类，一般会被继承，由其子类来实现抽象的方法

[修饰符] abstract class 类名{}

• 抽象方法：被 abstract 修饰而且没有方法体的方法，也叫做没有实现的方法

[修饰符] abstract 返回值类型 方法名([形参列表]);//不需要方法体{}

1.3 使用细节

① abstract 只能修饰类和方法，不能用来修饰属性和其他的

② 使用 abstract 修饰类，只是表示该类为抽象类，类内部的属性和方法不会自动具有 abstract 修饰符

③ 抽象类不能创建对象实例

④ 抽象类的本质还是类，可以有类的各种成员。比如：非抽象方法、构造器、非静态方法/属性、静态方法/属性等等，都可以继承给子类

public class Test {public static void main(String[] args) {Dog dog = new Dog();System.out.println(Dog.num);System.out.println(dog.name);dog.eat();}
}//抽象类
abstract class Animal{public static int num = 1;public String name = "小马";public abstract void eat();//抽象方法
}class Dog extends Animal{//实现父类的抽象方法public void eat(){System.out.println("狗吃骨头");}
}
/*输出结果
1
小马
狗吃骨头*/

⑤ 如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为 abstract类，否则编译不通过

 ⑥ 抽象方法不能使用 private、final、static 来修饰，因为这些关键字都是和重写相违背的

        private：如果父类的抽象方法用 private 修饰，那其子类没有访问权限，无法实现抽象方法

        final：如果父类的抽象方法用 final 修饰，则该方法不能重写，其子类无法实现抽象方法

        static：static 修饰的方法可以 "直接类.方法名" 调用，而 abstract 修饰的方法没有方法体，因此两者是相悖的【这样理解不知道对不对】

2. 模板设计模式（抽象类使用场景）

2.1 基本介绍

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式

解决的问题：

① 当功能内部一部分实现是确定的，另一部分实现是不确定的，这时可以把不确定的部分暴露出去，让子类去实现

② 换句话说，在软件开发中实现一个算法时，整体步骤很固定、通用，这些步骤已经在父类中写好了。但是某些部分易变，则易变部分可以抽象出来，供不同子类实现。这就是一种模板模式

看上面的文字可能会觉得很抽象，可以结合具体的例子理解一下

2.2 具体例子

需求：计算不同类各自任务的执行时间

未使用模板设计模式之前

public class demo {public static void main(String[] args) {new JobA().job();new JobB().job();}
}class JobA{public void job(){int result = 0;long startTime = System.currentTimeMillis();//开始时间for(int i=0;i<100000;i++){result += i;}long endTime = System.currentTimeMillis();//结束时间long duration = endTime - startTime;System.out.println("任务执行时间: " + duration + "毫秒");}
}class JobB{public void job(){int result = 1;long startTime = System.currentTimeMillis();//开始时间for(int i=0;i<8000;i++){result *= i;}long endTime = System.currentTimeMillis();//结束时间long duration = endTime - startTime;System.out.println("任务执行时间: " + duration + "毫秒");}
}

缺点：代码冗余，复用性差，可以看到代码整体的步骤是很固定的，如下：

①  记录任务开始时间

②  执行任务

③  记录任务结束时间

④  打印任务执行时间

其中，① ③ ④ 是固定不变的，变的只有 ② ，这就有了改进的空间

引入模板设计模式

优点：利用抽象类+动态绑定机制使得模板类中的 job() 可以动态调用执行方法，代码复用性高  

public class demo {public static void main(String[] args) {new JobA().calculateJobTime();new JobB().calculateJobTime();}
}//模板类
abstract class Template{public abstract void job();//抽象方法//计算任务执行时间public void calculateJobTime(){long startTime = System.currentTimeMillis();//开始时间job();//动态绑定机制long endTime = System.currentTimeMillis();//结束时间long duration = endTime - startTime;System.out.println("任务执行时间: " + duration + "毫秒");}
}class JobA extends Template{//重写抽象方法public void job(){int result = 0;for(int i=0;i<100000;i++){result += i;}}
}class JobB extends Template{//重写抽象方法public void job(){int result = 1;for(int i=0;i<8000;i++){result *= i;}}
}