Java的设计模式三大类
1.模板方法模式（Templates Pattern）
模板方法模式就是指：一个抽象类中，有一个主方法，再定义1...n个方法，可以是抽象的，也可以是实际的方法，定义一个类，继承该抽象类，重写抽象方法，通过调用抽象类，实现对子类的调用。
车辆模板：
public abstract class CarModel {
//启动
protected abstract void start();
//跑
//为什么用final,让子类不能修改run()里面的方法调用顺序
final public void run(){
//开始要启动
this.start();
//到了目的地就停车
this.stop();
};
//停住
protected abstract void stop();
}
宝马实现类：
public class BMW extends CarModel {
@Override
public void start() {
System.out.println("宝马启动");
}
@Override
public void stop() {
System.out.println("宝马停车");
}
}
悍马实现类：
public class Hummer extends CarModel {
@Override
public void start() {
System.out.println("悍马启动");
}
@Override
public void stop() {
System.out.println("悍马停车");
}
}
测试：
public class Test {
public static void main(String[] args){
BMW bmw=new BMW();
bmw.run();
Hummer hm=new Hummer();
hm.run();
}
}
结果：
类图如下：
2.建造者模式(Build Pattern)
工厂类模式提供的是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性，其实建造者模式就是前面抽象工厂模式和最后的Test结合起来得到的。
sender:
public interface Sender {
public void send();
}
smsSender:
public class smsSender implements Sender {
@Override
public void send() {
System.out.println("发短信");
}
}
mailSender:
public class mailSender implements Sender {
@Override
public void send() {
System.out.println("发邮件");
}
}
build:
public class build {
private List<Sender> phoneList=new ArrayList<>();
public void mailSend(int count){
for(int i=0;i<count;i++){
phoneList.add(new mailSender());
}
}
public void smsSend(int count){
for(int i=0;i<count;i++){
phoneList.add(new smsSender());
}
}
}
测试：
public class Test {
public static void main(String[] args){
build b=new build();
b.mailSend(10);
}
}类图如下
3.桥接模式（Bridge Pattern）
举例，我有一家公司，现在我要成立两家子公司，一个是房地产公司，一个是服装公司，但是我总公司要监督这两家子公司。
产品：
public abstract class Product {
//生产
protected abstract void produce();
//销售
protected abstract void sell();
}
服装：
public class Clothes extends Product {
@Override
public void sell() {
System.out.println("夏天到了，生产了一批高端T恤");
}
@Override
public void produce() {
System.out.println("T恤全部买完");
}
}
房地产：
public class House extends Product {
@Override
public void produce() {
System.out.println("投资盖了一座大楼");
}
@Override
public void sell() {
System.out.println("房子全部高价售罄");
}
}
总公司：
public abstract class Company {
private Product product;
public Company(Product product) {
this.product = product;
}
//赚钱
public void makeMoney(){
this.product.produce();
this.product.sell();
}
}
房地产公司：
public class houseCorp extends Company {
@Override
public void makeMoney() {
super.makeMoney();
System.out.println("赚钱了");
}
public houseCorp(House house) {
super(house);
}
}
服装公司：
public class clothesCorp extends Company {
public clothesCorp(Clothes clothes) {
super(clothes);
}
@Override
public void makeMoney() {
super.makeMoney();
System.out.println("赚钱了");
}
}
测试：
public class Test {
public static void main(String[] args){
House h=new House();
houseCorp hc=new houseCorp(h);
hc.makeMoney();
}
}
结果：
以后我的房地产公司或者服装公司要不要转型做其他产品？我要不要在成立一家子公司？如果这样我要去修改代码？不用，成立子公司就去继承Company,转型发展其他产品线就去继承Product,不用修改源代码，这就是桥梁模式的好处。
类图如下：
4.命令模式（Command Pattern）
命令模式很好理解，举个例子，司令员下令让士兵去干件事情，从整个事情的角度来考虑，司令员的作用是，发出口令，口令经过传递，传到了士兵耳朵里，士兵去执行。这个过程好在，三者相互解耦，任何一方都不用去依赖其他人，只需要做好自己的事儿就行，司令员要的是结果，不会去关注到底士兵是怎么实现的。
命令接口：
public interface Command {
public void exe();
}
命令接口的实现：
public class myCommand implements Command{
private Soldier soldier;
public myCommand(Soldier soldier) {
this.soldier = soldier;
}
@Override
public void exe() {
soldier.action();
}
}
司令：
public class Commander {
private Command command;
public Commander(Command command) {
this.command = command;
}
public void action(){
command.exe();
}
}
士兵：
public class Soldier {
public void action() {
System.out.println("收到命令");
}
}
测试：
public class Test {
public static void main(String[] args){
Soldier sd=new Soldier();
Command cm=new myCommand(sd);
Commander cmd=new Commander(cm);
cmd.action();
}
}
结果：
命令模式的目的就是达到命令的发出者和执行者之间解耦，实现请求和执行分开，熟悉Struts的同学应该知道，Struts其实就是一种将请求和呈现分离的技术，其中必然涉及命令模式的思想！
类图如下：
全部评论