设计模式案例

最新推荐文章于 2022-06-06 07:45:00 发布
最新推荐文章于 2022-06-06 07:45:00 发布
阅读量215 收藏 1
点赞数
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lzm123456lq/article/details/108406508
版权

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

在这里插入图片描述

lzm990311
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
php设计模式案例详解
07-06
完整的设计模式详细说明，php示例，设计模式案例，代码详解
设计模式举例
是鲤鱼啊
07-09 385
1.简单工厂模式 工厂（Factory）：根据客户提供的具体产品类的参数，创建具体产品实例； 抽象产品（AbstractProduct）：具体产品类的基类，包含创建产品的公共方法； 具体产品（ConcreteProduct）：抽象产品的派生类，包含具体产品特有的实现方法，是简单工厂模式的创建目标。 简单工厂模式UML类图如下： ...
23 种设计模式详解（全23种，含代码样例）
lgxzzz的博客
05-25 8127
设计模式的分类 总体来说设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 A、创建模式（5种） 工...
设计模式23种范例
鱼儿锅头的博客
05-12 653
设计模式23种范例 PHP常用设计模式包括（单例，工厂，注册，观察者，适配器，策略，装饰器，原型） 模式介绍 设计模式：提供了一种广泛的可重用的方式来解决我们日常编程中常常遇见的问题。设计模式并不一定就是一个类库或者第三方框架，它们更多的表现为一种思想并且广泛地应用在系统中。它们也表现为一种模式或者模板，可以在多个不同的场景下用于解决问题。设计模式可以用于加速开发，并且将很多大的想法或者设计以一种简单地方式实现。当然，虽然设计模式在开发中很有作用，但是千万要避免在不适当的场景误用它们。 主要区分为三种类
23种设计模式实例详解
04-25 979
文章目录 一、简介 二、六大原则 1、开闭原则 2、里氏代换原则 3、依赖倒转原则 4、接口隔离原则 5、最少知道原则 6、合成复用原则 三、实例详解 1、工厂模式 2、抽象工厂模式 3、单例模式 4、构建者模式 5、原型模式 一、简介    软件设计模式（Design pattern），又称设计模式，是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码...
23种设计模式总结及应用案例
weixin_46009162的博客
12-30 4544
设计模式，七大原则 开闭原则 对扩展开放(提供方)，对修改关闭(使用方)。 抽象提供方的方法，调用方传入抽象类的子类实现，提供方调用子类方法完成具体实现 里氏替换原则 所有引用基类的地方都必须能透明的使用其子类，且行为不会发生变化。 依赖倒转原则 底层模块尽量不独立存在，应有其抽象类或接口，声明子类对象时由接口接收，作为实例与变量间的缓冲层，有利于程序扩展个优化。 中心思想是面向接口编程，相对于细节的多变性，抽象的东西稳定的多，以抽象为基础搭建的架构也更稳定。 单一职责原则 降低类的复杂度，一个类只负责一项
设计模式案例源代码.zip
06-17
设计模式案例源代码.zip
23种设计模式经典案例（C++版）
04-16
设计模式是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代 码可靠性。...本资源使用C++实现了23种设计模式的经典案例。
设计模式案例PPT-安全模式（八）.pdf
最新发布
03-21
设计模式
c#设计模式案例源码.zip
05-11
设计模式源码
23种设计模式实例
12-04
总体来说设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式例子
设计模式合集案例
06-01
java设计模式代码，全部设计示例，纯手打
23种设计模式详解及案例
12-24
23种设计模式详解及案例
23种设计模式总结及案例.pdf
01-29
23种设计模式总结及案例.pdf
几种常见设计模式的案例分析源码
11-19
针对几种常见设计模式的案例分析源码：观察者模式、工厂模式、责任链模式、单例模式、模板方法模式、适配器模式。。。。。。
设计模式案例分析与实现
向着光的那方
06-10 9552
1.UML类图及Java实现 案例：某基于C/S的即时聊天系统登录模块功能描述如下：用户通过登录界面(LoginForm)输入账号和密码，系统将输入的账号和密码与存储在数据库(User)表中的用户信息进行比较，验证用户输入是否正确，如果输入正确则进入主界面(MainForm)，否则提示“输入错误”。 根据以上描述绘制即时聊天系统登录模块的类图，并用Java编程实现（模拟实现即可）。 实现类图： 代码实现结构： 实现代码： public interface UserDao { publ
23个小案例带你吃透23种设计模式
仅以此博客记录日常学习工作中所思所得，水平有限，难登大雅，万望海涵。
06-06 1233
模式就是解决问题的固定套路，设计模式(Design pattern)就是一套经过前人反复使用，总结出来的程序设计经验。设计模式总共分为三大类：第一类是创建型模式 、第二类是结构型模式、第三种是行为型模式，共计23种标准设计模式。本文将通过5万字、23个经典小案例带你吃透23种设计模式。.........
常见设计模式及实例
黑马程序员广州中心的专栏
04-30 406
设计模式分为三种类型，共23种： 创建型模式：单例模式、抽象工厂模式、建造者模式、工厂模式、原型模式 结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式 行为型模式：模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式 本文主要讲解的是： 创建型模式：单例模式、建造者模式、工厂模式、 ...
23种设计模式举例
weixin_33918114的博客
02-09 85
1、 FACTORY —追 MM 少不了请吃饭了， 麦当劳的鸡翅和肯德基的鸡翅都是 MM 爱吃的东西， 虽然口味有所不同， 但不管你带 MM 去麦当劳或肯德基， 只管向服务员说“来四个鸡翅”就行 了。麦当劳和肯德基就是生产鸡翅的 Factory 工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消 工厂模式 费者无须修改就可以接纳新产品。缺点是当产品修改时，工...
java设计模式案例
12-22
以下是两个常见的Java设计模式案例： 1. 单例模式： ```java public class Singleton { private static Singleton instance; private Singleton() {} public static Singleton getInstance() { if (instance ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值