✅接口和抽象类的区别，如何选择？
- ✅ 接口和抽象类的区别
- ✅方法定义
- ✅修饰符
- ✅构造器
- ✅继承和实现
- ✅单继承 、 多实现
- ✅职责不同
- ✅什么是模板方法模式，有哪些应用呢？
- ✅典型理解
- ✅示例
- 💡思考
- ✅你在工作中是如何使用设计模式的？
✅ 接口和抽象类的区别
接口和抽象类的区别其实挺多的。比如以下这些：
✅方法定义
接口和抽象类，最明显的区别就是接口只定义了一些方法而已，再不考虑Java 8 中的default方法情况下，接口中只有抽象方法，是没有实现的代码的。（Java 8 中可以有默认方法）
✅修饰符
抽象类中的抽象方法可以有public 、 protected 、 和default 这些修饰符，而接口中默认修饰符是public。不可以使用其他修饰符。
✅构造器
抽象类可以有构造器，接口不能有构造器。
✅继承和实现
接口可以被实现，抽象类可以被继承。
✅单继承 、 多实现
一个类可以实现多个接口，但只能继承一个抽象类。接口支持多重继承，即一个接口可以继承多个其它接口。
public interface HollisTestService extends InitializingBean,DisposableBean {}
✅职责不同
接口和抽象类的职责不一样。接口主要用于制定规范，因为我们提倡也经常使用的都是面向接口棉城。而抽象类主要目的是为了复用，比较典型的就是模板方法模式。
了解完这些，我们使用Java代码来规整一下：
// 定义一个接口，名为Animal
interface Animal { // 定义一个抽象方法，用于发出动物的叫声 void makeSound();
} // 定义一个接口，名为Mammal
interface Mammal extends Animal { // 定义一个抽象方法，用于哺乳动物生育 public abstract void giveBirth();
} // 定义一个抽象类，名为Reptile
abstract class Reptile implements Animal { // 定义一个抽象方法，用于爬行动物移动 public abstract void move();
} // 定义一个实现了Mammal接口的类，名为Dog
class Dog implements Mammal { // 重写makeSound方法，实现狗的叫声 @Override public void makeSound() { System.out.println("汪汪！"); } // 重写giveBirth方法，实现狗的生育行为（这里只是模拟，实际狗的生育行为更复杂） @Override public void giveBirth() { System.out.println("汪汪！"); }
} // 定义一个继承了Reptile抽象类的类，名为Snake
class Snake extends Reptile { // 重写move方法，实现蛇的移动方式（这里只是模拟，实际蛇的移动方式更复杂） @Override public void move() { System.out.println("蜿蜒爬行..."); }
} // 定义一个实现了Animal接口的类，名为Cat
class Cat implements Animal { // 重写makeSound方法，实现猫的叫声 @Override public void makeSound() { System.out.println("喵喵！"); }
} // 主函数，测试代码
public class Main { public static void main(String[] args) { // 创建Dog对象并调用makeSound和giveBirth方法 Dog dog = new Dog(); dog.makeSound(); // 输出 "汪汪！" dog.giveBirth(); // 输出 "汪汪！" // 创建Snake对象并调用move方法 Snake snake = new Snake(); snake.move(); // 输出 "蜿蜒爬行..." // 创建Cat对象并调用makeSound方法（注意Cat没有实现giveBirth方法） Cat cat = new Cat(); cat.makeSound(); // 输出 "喵喵！" }
}
以上演示了接口和抽象类的复杂使用。Animal接口定义了一个makeSound方法，而Mammal接口继承了Animal接口并定义了一个giveBirth方法。Reptile抽象类实现了Animal接口并定义了一个move方法。Dog类实现了Mammal接口，而Snake类继承了Reptile抽象类。在主函数中，我们创建了Dog、Snake和Cat对象，并调用了它们的方法。这个例子展示了多个接口和抽象类的组合使用。
所以，当我们想要定义标准、规范的时间，就是用接口。当我们想要复用代码的时候，就使用抽象类。
一般实际开发中，我们会先把接口暴露给外部，然后业务代码中实现接口。如果多个实现类中有相同可复用的代码，则在接口和实现类中加一层抽象类，将公用部分代码抽出到抽象类中。可以参考一下模板方法模式，这是一个很好理解接口、抽象类和实现类之间关系的设计模式。
✅什么是模板方法模式，有哪些应用呢？
✅典型理解
模板方法模式是一种行为设计模式，他的主要作用就是复用代码。在很多时候，我们的代码中可能会有一些公共的部分并且还有一些定制的部分，那么公共这部分就可以定义在一个父类中，然后将定制的部分实现在子类中。这样了类可以根据需要扩展或重写父类的方法，而不需要改变算法的结构。
我们通常会把模板方法模式和策略模式一起使用，因为当我们使用策略模式的时候，会把具体的策略实现在策略服务里面，但是还剩下一些通用的逻辑，就可以通过模板方法模式进行复用。
✅示例
我们拿一个常见的优惠券作为示例，假设我们需要定义一个优惠券的申请服务。
abstract class Coupon {// 模板方法，定义优惠券的应用流程public final oid applyCoupon() {if (isCouponValid()) {if (isEligibleForDiscount()) {applyDiscount();}displayConfirmation();} else {displayInvalidCouponMessage();}}// 具体方法，用于判断优惠券是否有效protected boolean isCouponValid() {// 具体的判断逻辑，子类可以重写该方法来实现特定的有效性判断return true;}//具体方法，用于判断用户是否符合优惠券的折扣条件protected boolean isEligibleForDiscount() {//具体的判断逻辑，子类可以重写该方法来实现特定的条件判断return true;}//具体方法，用于判断用户是否符合优惠券的折扣条件protected boolean isEligibleForDiscount() {//具体的判断逻辑，子类可以重写该方法来实现特定的条件判断return true;}//抽象方法，由子类实现具体的优惠券折扣逻辑protected abstract void applyDiscount();// 抽象方法，由子类实现具体的优惠券确认展示逻辑protected abstract void displayConfirmation();// 具体方法，用于展示无效优惠券的信息protected void displayInvalidCouponMessage() {System.out.printIn("无效优惠券!“);}
}
以上是一个抽象类。这个类中有一个具体的方法applyCoupon，其中定义了一个优惠券申请的具体实现，并且编排了多个其他的方法。
这就是一个典型的模板方法。我们可以基于这个抽象类来定义具体的实现：
class PercentageCoupon extends Coupon {@Overrideprotected void applyDiscount() {// 具体的百分比折扣逻辑System.out.printIn("应用百分比折扣优惠!);}@Overrideprotected void displayConfirmation() {// 具体的百分比优惠券确认展示逻辑System.out.printIn("百分比折扣优惠确认!");}
}class FixedAmountCoupon extends Coupon {@Overrideprotected void applyDiscount() {// 具体的固定金额折扣逻辑System.out.println("应用固定金额优惠!“);}@Overrideprotected void displayConfirmation() {// 具体的固定金额优惠券确认展示逻辑System.out.printIn("固定金额优惠确认!");}
}
以上就是两个具体的实现，分别继承Coupon抽象类，并且实现其中的部分方法就可以了。
这样我们在实际使用时，可以直接使用FixedAmountCoupon 和 PercentageCoupon 类，并且直接调用它的applyCoupon方法就行了，如：
public class Main {public static void main(String[] args) {Coupon percentageCoupon = new PercentageCoupon();percentageCoupon.applyCoupon();System.out.println("-------------------------");Coupon fixedAmountCoupon = new FixedAmountCoupon();fixedAmountCoupon.applyCoupon();}
}
💡思考
看到这里，模板方法已经告一段落了，我们思考一下，如果在面试过程中，我们奇葩面试官问：你在**工作中是如何使用设计模式的？**那我们思考一下，脑子有思路吗？
没有思路也没关系！我们见招拆招，我给大家聊一下！
✅你在工作中是如何使用设计模式的？
工作中常用的设计模式有很多，如单例、工厂、策略、模板等。一般在工作中，是可以把策略、工厂和模板一起结合着来使用的。
当我们需要有多个具体的策略服务的时候，那不同的内容放到策略服务中，那些公共的东西就可以抽象出来放到模板方法中了。那这些策略服务该如何管理呢?什么时候用什么策略服务呢?这时候就可以借助工广来管理这些服务。
如以下例子，我们需要定义一个支付服务，里面有一个支付方法:
public interface Payservice {public void pay(PayRequest payRequest);}class PayRequest {}
这是一个单独的接口，只定义了一个方法，那么我们再把所有支付渠道中公共的代码抽取出来，定义一个抽象类：
public abstract class AbstractPayService implements PayService {@Overridepublic void pay(PayRequest payRequest) {//前置检查validateRequest(payRequest);//支付核心逻辑doPay(payRequest);//后置处理postPay(payRequest);} public abstract void doPay(PayRequest payRequest);private void postPay(PayRequest payRequest) {//支付成功的后置处理}public void validateRequest(PayRequest payRequest) {//参数检查}
}
这个抽象类中首先把pav方法给实现了，然后编排了几个其他的方法，这些公共的方法在抽象类中直接实现了，具体的支付核心实现，留给实现类去实现就行了。
然后我们就可以定义多个策略服务了：
@Service
public class AlipayPayService extends AbstractPayService {@Overridepublic void doPay(PayRequest payRequest) {//支付宝支付逻辑}
}@Service
public class WechatPayService extends AbstractPayService {@Overridepublic void doPay(PayRequest payRequest) {//微信支付逻辑}
}
这些服务协议定好了以后，需要一个地方统一管理，那就定义一个工厂吧：
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
@Service
public class PayServiceFactory {@Autowiredpublic Map<String,ayService> payServiceMap = new ConcurrentHashMap<>();public PaySerice getPayService(String payChannel) {// alipay -> alipayPayService// wechat -> wechatPayServicereturn payServiceMap.get(payChannel +"PayService");}
}
在工厂中，把PayService的所有实现全部都注入到payServiceMap中，然后再需要用的是，直接调他的getPayService方法就行了
这样，在使用的时候，只需要通过工厂就能获取对应的策略服务进行服务调用了:
public class PayDomainService {@AutowiredPayServiceFactory payServiceFactory;public void pay(PayRequest payRequest) {String payChannel = payRequest.getPayChannel();payServiceFactory.getPayService(payChannel).pay(payRequest);}
}
以上，我们借助了Spring，结合了策略、模板以及工厂，实现了我们想要的功能，通过多种设计模式，减少重复代码，提升可维护性，也让代码更容易阅读和理解。
接博主上一篇博文: 如何理解面向对象和面向过程
