设计模式案例

1.策略模式案例 2.LSP案例：正方形不是长方形 3.迭代器模式案例 4.工厂模式案例

未采用策略模式 package Strategty; //以超市打折为例，未采用策略模式 public class NoStrategy { double price; public double getPrice(String type,double price) { this.price=price; //type=0 为普通用户 if(type.equals("0")) { return price; }else if(type.equals("1")) { //银卡 return price*0.9; }else if(type.equals("2")) { //金卡 return price*0.8; } return price; } } package Strategty; public class NoStrategyMain { //如果此时增加一个黑卡会员，此时需要修改NoStrategy内部方法 //违反了开放关闭原则 public static void main(String[] args) { NoStrategy noStrategy=new NoStrategy(); double person1=noStrategy.getPrice("0", 1000); double person2=noStrategy.getPrice("1", 1000); double person3=noStrategy.getPrice("2", 1000); System.out.println(person1); System.out.println(person2); System.out.println(person3); } }

采用策略模式

package Strategty; public interface Strategy { public double getPrice(double price); } package Strategty; //银卡 public class strategy1 implements Strategy { @Override public double getPrice(double price) { // TODO Auto-generated method stub return price*0.9; } } package Strategty; //金卡 public class strategy2 implements Strategy { @Override public double getPrice(double price) { // TODO Auto-generated method stub return price*0.8; } } package Strategty; //接收策略的上下文类 public class Context { Strategy strategy; public Context(Strategy strategy) { super(); this.strategy = strategy; } public double getPrice(double price) { return strategy.getPrice(price); } } package Strategty; public class StrategyMain { // 采用策略模式 public static void main(String[] args) { //银卡策略 Strategy strategy1=new strategy1(); //金卡策略 Strategy strategy2=new strategy2(); //策略1上下文,调用上下文中得到价格的方法 Context context1=new Context(strategy1); double price1=context1.getPrice(1000); //策略2上下文 Context context2=new Context(strategy2); double price2=context2.getPrice(1000); System.out.println(price1); System.out.println(price2); //此时如果我新增了一个黑卡会员 Strategy3 //不需要去修改Strategy内部的方法，Strategy3实现策略接口，内部实现 //getprice(double price) 方法就行，符合开放关闭原则 } }

LSP：正方形不是长方形 package LSP; /*任何基类可以出现的地方，子类一定可以出现。里氏替换原则是继承复用的基石 ，只有当衍生类可以替换基类，软件单位的功能不受到影响时，基类才能真正被复用， 而衍生类也能够在基类的基础上增加新的行为。 里氏代换原则是对“开-闭”原则的补充。实现“开闭”原则的关键步骤就是抽象化。 而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。 里氏替换原则中，子类对父类的方法尽量不要重写和重载。 因为父类代表了定义好的结构，通过这个规范的接口与外界交互，子类不应该随便破坏它。*/ //长方形 public class Rectangle { double length; double height; public double getLength() { return length; } public void setLength(double length) { this.length = length; } public double getHeight() { return height; } public void setHeight(double height) { this.height = height; } public double getArea() { return length*height; } } package LSP; /** * 1：子类可以实现父类的抽象方法，但是不能覆盖父类的非抽象方法。 2：子类中可以增加自己特有的方法。 3：当子类覆盖或实现父类的方法时，方法的前置条件（即方法的形参）要比父类方法的输入参数更宽松。 4：当子类的方法实现父类的抽象方法时，方法的后置条件（即方法的返回值）要比父类更严格。 * @author:廖泽铭 * @Description: TODO * @date 2020-9-4 */ //正方形 public class Square extends Rectangle{ public void setHeight(double height) { this.height = height; this.length=height; } public void setLength(double length) { this.length = length; this.height = length; } } package LSP; public class Area { public static void main(String[] args) { Rectangle Squre=new Square(); Squre.setHeight(4); Squre.setLength(2); double area = Squre.getArea(); System.out.println(area); } }

正确的设计

package LSPCorrect; /*任何基类可以出现的地方，子类一定可以出现。里氏替换原则是继承复用的基石 ，只有当衍生类可以替换基类，软件单位的功能不受到影响时，基类才能真正被复用， 而衍生类也能够在基类的基础上增加新的行为。 里氏代换原则是对“开-闭”原则的补充。实现“开闭”原则的关键步骤就是抽象化。 而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。 里氏替换原则中，子类对父类的方法尽量不要重写和重载。 因为父类代表了定义好的结构，通过这个规范的接口与外界交互，子类不应该随便破坏它。*/ //长方形 public class Rectangle { double length; double height; public Rectangle(double length, double height) { this.length = length; this.height = height; } public double getArea() { return length*height; } } package LSPCorrect; //正方形 public class Square extends Rectangle{ public Square(double side) { super(side, side); // TODO Auto-generated constructor stub. } } package LSPCorrect; /** * 1：子类可以实现父类的抽象方法，但是不能覆盖父类的非抽象方法。 2：子类中可以增加自己特有的方法。 3：当子类覆盖或实现父类的方法时，方法的前置条件（即方法的形参）要比父类方法的输入参数更宽松。 4：当子类的方法实现父类的抽象方法时，方法的后置条件（即方法的返回值）要比父类更严格。 * @author:廖泽铭 * @Description: TODO * @date 2020-9-4 */ public class Area { public static void main(String[] args) { Rectangle Squre=new Square(2); double area = Squre.getArea(); System.out.println(area); } }

迭代器模式

package Iterator; //建造书这个实体类 public class Book { String name; public String getName() { return name; } public void setName(String name) { this.name = name; } public Book() { super(); } } package Iterator; //抽象聚合类 public interface aggerate { //抽象聚合类中引入抽象的迭代器 public abstract Iterator iterator(); } package Iterator; //抽象迭代器 public interface Iterator { /** * 判断是否存在下一个元素 * @return */ public abstract boolean hasNext(); /** *获取下一个元素 * @return */ public abstract Object next(); } package Iterator; //具体的集合类 public class Books implements aggerate { private Book[] books; private int last = 0; public Books(int maxSize){ this.books = new Book[maxSize]; } public Book getBookAt(int index){ return books[index]; } public void appendBook(Book book) { this.books[last] = book; last++; } public int getLength(){ return last; } @Override public Iterator iterator() { // 返回具体的迭代器，将具体的集合传递给BookIterator来迭代 return new BookIterator(this); } } package Iterator; //具体的迭代器 public class BookIterator implements Iterator { private Books books; private int index; public BookIterator(Books books) { this.books = books; this.index = 0; } @Override public boolean hasNext() { return index < books.getLength() ? true : false; } @Override public Object next() { Book book = books.getBookAt(index); index++; return book; } } package Iterator; public class Main { //实现方法 public static void main(String[] args) { Book book1=new Book(); book1.setName("西游记"); Book book2=new Book(); book2.setName("水浒传"); Book book3=new Book(); book3.setName("红楼梦"); Books books=new Books(3); books.appendBook(book1); books.appendBook(book2); books.appendBook(book3); Iterator booIterator = books.iterator(); while(booIterator.hasNext()) { Book book = (Book) booIterator.next(); System.out.println(book.getName()); } } }

1.未采用设计模式的 package Factorys.Ordinary; //宝马车 public class car1 { //生成宝马车 public car1 makeCar() { return new car1(); } } package Factorys.Ordinary; //奔驰车 public class Car2 { //生成奔驰车 public Car2 makeCar() { return new Car2(); } } package Factorys.Ordinary; public class Customer { //缺点 耦合度太高 了，用户直接与车辆结合 public static void main(String[] args) { car1 car1=new car1(); //生成宝马 car1.makeCar(); Car2 car2=new Car2(); //生成奔驰 car2.makeCar(); } }

2.简单工厂模式

package Factorys.Simple; //简单工厂模式 对车(产品抽象化) public interface Car { public Car Carproduct(); } package Factorys.Simple; public class Car1 implements Car { @Override public Car Carproduct() { // TODO Auto-generated method stub System.out.println("我是宝马"); return null; } } package Factorys.Simple; public class Car2 implements Car { @Override public Car Carproduct() { // TODO Auto-generated method stub System.out.println("我是大奔"); return null; } } package Factorys.Simple; public class Factory { public Car makeCar(String type) { //type=1 生成宝马 if(type.equals("1")) { Car1 car1=new Car1(); return car1.Carproduct(); } //type=2生成奔驰 if(type.equals("2")) { Car2 car2=new Car2(); return car2.Carproduct(); } return null; } } package Factorys.Simple; public class Customer { public static void main(String[] args) { Factory factory=new Factory(); //用户托付工厂去造宝马 factory.makeCar("1"); //用户托付工厂去造奔驰 factory.makeCar("2"); //缺点 如果用户需要一辆奥迪，需要修改Factory中的方法，违反了开闭原则 } }

3.工厂方法模式

package Factorys.Factory; //简单工厂模式 对车(产品抽象化) public interface Car { public Car Carproduct(); } package Factorys.Factory; public class Car1 implements Car { @Override public Car Carproduct() { // TODO Auto-generated method stub System.out.println("我是宝马"); return null; } } package Factorys.Factory; public class Car2 implements Car { @Override public Car Carproduct() { // TODO Auto-generated method stub System.out.println("我是大奔"); return null; } } package Factorys.Factory; //工厂方法模式 对生成车辆的工厂抽象化 public interface Factory { public Car makeCar(); } package Factorys.Factory; public class Factory1 implements Factory { @Override public Car makeCar() { // TODO Auto-generated method stub Car1 car1=new Car1(); return car1.Carproduct(); } } package Factorys.Factory; public class Factory2 implements Factory { @Override public Car makeCar() { // TODO Auto-generated method stub Car2 car2=new Car2(); return car2.Carproduct(); } } package Factorys.Factory; public class Customer { public static void main(String[] args) { //用户跟生成宝马的工厂联系，帮我生产一个宝马 Factory factory1=new Factory1(); factory1.makeCar(); //用户跟生成奔驰的工厂联系，帮我生产一个奔驰 Factory factory2=new Factory2(); factory2.makeCar(); //如果此时用户需要在宝马上加个空调，就要采用抽象工厂模式了 } }

4.抽象工厂模式

package Factorys.Abstract; //简单工厂模式 对车(产品抽象化) public interface Car { public Car Carproduct(); } package Factorys.Abstract; public class Car1 implements Car { @Override public Car Carproduct() { // TODO Auto-generated method stub System.out.println("我是宝马"); return null; } } package Factorys.Factory; public class Car2 implements Car { @Override public Car Carproduct() { // TODO Auto-generated method stub System.out.println("我是大奔"); return null; } } package Factorys.Abstract; //工厂方法模式 对生成车辆的工厂抽象化 public interface Factory { public Car makeCar(); public Aircondition makeAircondition(); public Car getProduct(); } package Factorys.Abstract; //生成一个宝马带格力空调 public class Factory1 implements Factory { @Override public Car makeCar() { // TODO Auto-generated method stub Car car1=new Car1(); return car1.Carproduct(); } @Override public Aircondition makeAircondition() { // TODO Auto-generated method stub Aircondition aircondition=new aircondition1(); return aircondition.airconditionProduct(); } @Override public Car getProduct() { // TODO Auto-generated method stub this.makeAircondition(); this.makeCar(); System.out.println("宝马加格力空调组合完毕"); return null; } // } package Factorys.Abstract; public class Factory2 implements Factory { @Override public Car makeCar() { // TODO Auto-generated method stub Car car2=new Car2(); return car2.Carproduct(); } @Override public Aircondition makeAircondition() { // TODO Auto-generated method stub Aircondition aircondition2=new aircondition2(); return aircondition2.airconditionProduct(); } @Override public Car getProduct() { // TODO Auto-generated method stub this.makeAircondition(); this.makeCar(); System.out.println("奔驰加海尔空调组合完毕"); return null; } } package Factorys.Abstract; public interface Aircondition { public Aircondition airconditionProduct(); } package Factorys.Abstract; public class aircondition1 implements Aircondition { @Override public Aircondition airconditionProduct() { // TODO Auto-generated method stub System.out.println("我是格力空调"); return this; } } package Factorys.Abstract; public class aircondition2 implements Aircondition { @Override public Aircondition airconditionProduct() { // TODO Auto-generated method stub System.out.println("我是海尔空调"); return this; } } package Factorys.Abstract; public class Customer { //这里与策略模式不同的是策略模式需要清楚每个策略内部的实现方法 //而抽象工厂或者工厂不需要知道内部方法的实现 public static void main(String[] args) { //客户联系一个宝马带格力空调的工厂 Factory factory1=new Factory1(); //工厂生产产品 factory1.getProduct(); //生产一个宝马带格力空调的 Factory factory2=new Factory2(); //工厂生产产品 factory2.getProduct(); } }