Java 三种设计模式实例实现

最新推荐文章于 2024-05-11 15:59:02 发布

却水

最新推荐文章于 2024-05-11 15:59:02 发布

阅读量3k

点赞数 1

分类专栏： java 学习

本文链接：https://blog.csdn.net/qq_41753944/article/details/89849615

版权

java 学习专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一．题目分析

熟悉建模工具。
掌握简单工厂模式、工厂方法模式、抽象工厂模式，并进行设计应用。

①．简单工厂模式

使用简单工厂模式模拟女娲（Nvwa）造人（Person），如果传入参数M，则返回一个Man对象，如果传入参数W，则返回一个Woman对象，请实现该场景。现需要增加一个新的Robot类，如果传入参数 R，则返回一个Robot对象，对代码进行修改并注意女娲的变化。
※分析：简单工厂模式属于类创建型模式，在简单工厂模式中，可以根据参数的不同返回不同类的实例。被创建的实例通常都具有共同的父类，也可用接口实现。

② . 工厂方法模式

海尔工厂(Haier)生产海尔空调(HaierAirCondition)，美的工厂(Midea)生产美的空调(MideaAirCondition) 。使用工厂方法模式描述该场景，绘制类图并编程实现。
※分析：工厂方法模式也叫多态工厂模式，属于类创建型模式。在工厂方法模式中，空调父类工厂负责定义创建产品对象的公共接口，而工厂子类（如HaierAirConditionFactory）则负责生成具体的产品对象（HaierAirCondition），这样做的目的是将产品类的实例化操作延迟到工厂子类中完成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类。
即使有新产品添加进来，也只需要新建具体的新建产品工厂，不会违反ocp原则。
※分析：

③．抽象工厂模式

电脑配件生产工厂生产内存、CPU等硬件设备，这些内存、CPU的品牌、型号并不一定相同，根据下面的“产品等级结构-产品族”示意图，使用抽象工厂模式实现电脑配件生产过程并绘制相应的类图，绘制类图并编程实现。
※分析：抽象工厂模式属于对象创建型模式。它提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。此模式适用于产品族（且产品的个数较少）的生产。如添加新建产品子项，就需要在接口中添加新产品实例，违反开闭原则

二．类图设计

1. 简单工厂模式

在这里插入图片描述

2. 工厂模式

3.抽象工厂模式

在这里插入图片描述

三．程序实现

①．man类,women类,robot类分别实现People接口，重写接口play（）方法，实现子类对象的特性。而产生三种人的任务均由PeopleFactory（）类承担，其中带参函数producePeople(S)
通过用户键盘输入传入s,根据不同传入参数生成不同人种。
②．HaierAirCondition（），MideaAirCondition（）分别实现接口AirCondition（），并重写其活动方法。HaierAirConditionFactory（），MideaAirConditionFactory（）分别实现AirConditionFactory（）接口。在各自的工厂内重写接口方法，实现产品的制造，返回实例化对象。通过改写xml文件中类名来生产不同的空调。XML配置采用Java 反射机制来完成。
③．interface<CPU ,RAM>分别是PC_CPU,Mac_CPU 的父类，子类通过重写discriber() 方法来对产品进行描述。Interface< ComputerPartsFactory>是MacFactory，和PCFactory 的父类，子类重写接口方法返回相应的子类对象，达到生产产品族的目的。

四．调试测试截图

在这里插入图片描述

五．经验总结

通过具体的代码了解掌握了三种设计模式的思想及实现方法，并在编程中学到了参数传递的新方法XML。
XML文件通过修改自身关于类名映射来实现不同对象的改变。
两种设计模式总结如下
工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。
区别：
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

附：
具体代码 1

package AirConditionMade;

public interface airCondition {
	public void display();
	
package AirConditionMade;

public interface airConditionFcatory {
	public airCondition produce();

}}
package AirConditionMade;
import AirConditionMade.XMLUtil;
import AirConditionMade.airConditionFcatory;
import AirConditionMade.airCondition;

public class Client {
	public static void main(String[] args)
	  {
		try {
			airCondition AC;
			airConditionFcatory factory;
			factory=(airConditionFcatory)XMLUtil.getBean();
			AC=factory.produce();
			AC.display();
			
		}
		catch(Exception e)
		{
			System.out.println(e.getMessage());
		}

	}

}
package AirConditionMade;

public class HaierAirCondition implements airCondition{
	public void display() {
		System.out.println("HaierAirCondition hava made!");
		System.out.println("海尔空调下线销售中");
		
	}

}
package AirConditionMade;

public class HaierAirConditionFacctory implements airConditionFcatory{
     public airCondition produce() {
    	 System.out.println("海尔集团生产海尔空调");
    	 return  new HaierAirCondition();
     }
}
package AirConditionMade;

public class MideaAirCondition implements airCondition {
    public void display() {
    	System.out.println("MideaAirCondition have made!");
    	System.out.println("美的空调下线销售中");
    }
}
package AirConditionMade;

public class MideaAirConditionFactory implements airConditionFcatory{
public airCondition produce() {
	 System.out.println("美的集团生产美的空调");
	 return  new MideaAirCondition();
}

}
package AirConditionMade;
import org.w3c.dom.*;
import org.xml.sax.SAXException;
import java.io.*;
import javax.xml.parsers.*;


public class XMLUtil {
	public static Object getBean() {
	try {
		/**
		 * 
		 * 创建文档对象
		 */
	
	
		DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
		DocumentBuilder builder = dFactory.newDocumentBuilder();
		Document doc;
		doc = builder.parse(new File("XMLUtil.xml"));
		//获取包含类名的文本节点
		NodeList nl =doc.getElementsByTagName("className");
		Node classNode = nl.item(0).getFirstChild();
		String className = classNode.getNodeValue();
		
		//通过类名生成实例化对象将其返回
		Class<?> c = Class.forName(className);
		Object  obj = c.newInstance();
		return obj;
	}
	catch(Exception e)
	{
		e.printStackTrace();
		return null;
	}

}
}

具体代码 2

package NvWamade;
import NvWamade.PeopleFactory;

import java.util.Scanner;

import NvWamade.People;
//import NvWamade.XMLUtilPeople;

public class Client {
	public static void main(String[] args) {
		try

        {
			Scanner sc = new Scanner(System.in);
			System.out.println("请输入想造的人种");
			String input = sc.nextLine();
			System.out.println("女娲娘娘造人中，请稍后···");
			Thread.sleep(3000);
			
			
			
			
			
			

         People pe;

       //  String createName=XMLUtilPeople.getCreateName();
         

         pe=PeopleFactory.producePeople(input);

         pe.play();
         sc.close();

        }

        catch(Exception e)

        {

         System.out.println(e.getMessage());

        }
	}
	

}
package NvWamade;

public class Man implements People{
public void play(){
		System.out.println("男人");
}
}
package NvWamade;

public interface People {
	public void play();

}

package NvWamade;
import NvWamade.People;
import NvWamade.Man;
import NvWamade.Women;
import NvWamade.Robot;

public class PeopleFactory {
	public static People producePeople(String creat) throws Exception{
		if(creat.equalsIgnoreCase("M")) {
			System.out.println("Have made MAN");
			return  new Man();
		}
		else if(creat.equalsIgnoreCase("W")) {
			System.out.println("Have made WOMEN");
			return new Women();
		}
		else if(creat.equalsIgnoreCase("R")) {
			System.out.println("Have made ROBOT");
			return new Robot();			
		}
		else
		{
			throw new Exception("对不起，女娲的技术还不能满足您的造人需求");
		}
		
	} 

}
package NvWamade;

public class Robot implements People {
	public void play(){
		System.out.println("机器人");
		}
}
package NvWamade;

public class Women implements People {
	public void play(){
		System.out.println("女人");
		}
}
package NvWamade;
import java.io.File;

import javax.xml.parsers.*;


import org.w3c.dom.NodeList;
import org.w3c.dom.Document;
import org.w3c.dom.Node;


public class XMLUtilPeople {
	public static String getCreateName() {
		try {
			/**
			 * 创建文档对象
			 */
			DocumentBuilderFactory dFactory =DocumentBuilderFactory.newInstance();
			DocumentBuilder builder =dFactory.newDocumentBuilder();
			Document doc;
			doc = (Document) builder.parse(new File("congflgPeople.xml"));
			/**
			 * 获取包含名称的文本节点
			 */
			NodeList nl = doc.getElementsByTagName("createName");
			Node classNode=nl.item(0).getFirstChild();
			String creatName = classNode.getNodeValue().trim();
			return creatName;
		}
		catch(Exception e)
		{
			e.printStackTrace();
			return null;
		}
	}

}

具体代码 3

package PCpartMade;

public class ComputerPartsClient {
public static void main(String[] args) {
	CPU cpu;
	RAM ram;
	ComputerPartsFactory pcFactory;
	ComputerPartsFactory macFactory;
	
	System.out.println("THIS IS THE PC_PARTS  @_@  ");
	pcFactory = new PCFactory();
	cpu = pcFactory.produceCPU();
	ram = pcFactory.produceRAM();
	cpu.discribe();
	ram.discribe();
	System.out.println("***************************");
	System.out.println("THIS IS THE MAC_PARTS   @_@ ");
	macFactory = new MacFactory();
	cpu = macFactory.produceCPU();
	ram = macFactory.produceRAM();
	cpu.discribe();
	ram.discribe();


}
}
package PCpartMade;

public interface ComputerPartsFactory {
	CPU produceCPU();
	RAM produceRAM();

}
package PCpartMade;

public interface CPU {
void discribe();
}
package PCpartMade;

public class MacCPU implements CPU {
	public void discribe() {
		System.out.println("This production is the Mac_CPU");
	}

}																				
package PCpartMade;

public class MacFactory implements ComputerPartsFactory{
	public MacCPU produceCPU() {
		System.out.println("MAC_CPU produced!");
		return new MacCPU();
		
	}
	public MacRam produceRAM() {
		System.out.println("Mac_RAM produced!");
		return new MacRam();
	}

}
package PCpartMade;

	public class MacRam implements RAM {
		public void discribe() {
			System.out.println("This production is the Mac_RAM");
		}

	}
package PCpartMade;

public class PcCPU implements CPU {
	public void discribe() {
		System.out.println("This production is the PC_CPU");
	}

}
package PCpartMade;

public class PCFactory implements ComputerPartsFactory{
	public PcCPU produceCPU() {
		System.out.println("PC_CPU produced!");
		return new PcCPU();
		
	}
	public PcRam produceRAM() {
		System.out.println("PC_RAM produced!");
		return new PcRam();
	}

}
package PCpartMade;

public class PcRam implements RAM {
	public void discribe() {
		System.out.println("This production is the PC_RAM");
	}

}
package PCpartMade;

public interface RAM {
	void discribe();

}

却水

关注

1
点赞
踩
18

收藏

觉得还不错? 一键收藏
1
评论
Java 三种设计模式实例实现

一．题目分析熟悉建模工具。掌握简单工厂模式、工厂方法模式、抽象工厂模式，并进行设计应用。①．简单工厂模式使用简单工厂模式模拟女娲（Nvwa）造人（Person），如果传入参数M，则返回一个Man对象，如果传入参数W，则返回一个Woman对象，请实现该场景。现需要增加一个新的Robot类，如果传入参数 R，则返回一个Robot对象，对代码进行修改并注意女娲的变化。※分析：简单工厂模...
复制链接

扫一扫