Java中的设计模式

最新推荐文章于 2021-07-09 00:32:09 发布

折翼天使【*-*】

最新推荐文章于 2021-07-09 00:32:09 发布

阅读量103

点赞数

文章标签： java 设计模式

本文链接：https://blog.csdn.net/weixin_52188375/article/details/112707975

版权

本文详细介绍了设计模式中的单例模式（懒汉式和饿汉式）、工厂模式（简单工厂模式）以及代理模式。单例模式确保类只有一个实例，提高资源利用率。工厂模式用于延迟对象创建，提供灵活的类实例化。静态工厂模式通过一个静态方法创建对象。代理模式则提供了一种控制对象访问的方式，如通过代售点购买火车票。

摘要由CSDN通过智能技术生成

1.什么是设计模式？

设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众
多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结

2.设计模式的作用是什么？

使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。

3.什么是单例模式/单态模式？

单例模式---保证一个类仅有一个实例。

当类被频繁地创建与销毁的时候，我们使用单例模式，这样可以减少了内存的开销，避免对资
源的多重占用。

4.单例模式的两种表示方式以及区别

1.懒汉式

package com.wangxing.danlipattern;
/**
 * 懒汉式
 * 1.构造方法私有
 * 2.提供一个静态成员变量(私有)，用于保存当前类对象
 * 3.提供一个静态方法(公共)返回创建好的当前类对象
 * 4.为了保证在多线程情况下当前类对象只有一个(一次只能访问一个线程)我们就需要添加“synchronized”
 * @author feng
 *
 */
public class DanLiPattern1 {
	//构造方法私有，可以保障离开本类后都不能通过new创建对象
	private DanLiPattern1(){}
	//提供一个静态成员变量(私有)，用于保存当前类对象
	private static DanLiPattern1 dlp=null;
	//提供一个静态方法(公共)返回创建好的当前类对象
	//为了保证在多线程情况下当前类对象只有一个(一次只能访问一个线程)我们就需要添加“synchronized”
	public static synchronized DanLiPattern1 getDanLiPattern1(){
		if(dlp==null){
			dlp=new DanLiPattern1();
		}
		return dlp;
	}
}

package com.wangxing.danlipattern;
public class TestMain {

	public static void main(String[] args) {
		//测试懒汉式的单例模式类
		DanLiPattern1 dlp1=DanLiPattern1.getDanLiPattern1();
		DanLiPattern1 dlp2=DanLiPattern1.getDanLiPattern1();
		if(dlp1==dlp2){
			System.out.println("相等，是同一个对象");
		}
		if(dlp1.equals(dlp2)){
			System.out.println("相等，是同一个对象");
		}
		//对象访问hashcode()方法,获得hashcode值进行比较
		System.out.println("dlp1=="+dlp1.hashCode());
		System.out.println("dlp12=="+dlp2.hashCode());
		
	}
}

2.饿汉式

package com.wangxing.test1;
/**
 * 饿汉式
 * @author Administrator
 *
 */
public class SingleObject2 {
	/*
	 1.构造方法私有
     2.提供一个静态成员变量[私有]，创建当前类对象
     3.提供一个静态方法【公共】返回当前类对象
     */
	private SingleObject2() {};
	private static SingleObject2  sobj1=new SingleObject2();
	//当在多线程情况下使用是为了保证当前类对象只有一个我们就需要添加"synchronized"
	public static synchronized SingleObject2  getSingleObject1() {
		return sobj1;
	}
}

package com.wangxing.danlipattern;
public class TestMain {

	public static void main(String[] args) {
		//测试饿汉式单例模式
		DanLiPattern2 dlp1=DanLiPattern2.getDanLiPattern2();
		DanLiPattern2 dlp2=DanLiPattern2.getDanLiPattern2();
		if(dlp1==dlp2){
			System.out.println("相等，是同一个对象");
		}
		if(dlp1.equals(dlp2)){
			System.out.println("相等，是同一个对象");
		}
		//对象访问hashcode()方法,获得hashcode值进行比较
		System.out.println("dlp1=="+dlp1.hashCode());
		System.out.println("dlp2=="+dlp2.hashCode());
	}
}

区别

	懒汉式	饿汉式
资源利用率	好	差
运行速度	差	好

5.什么是工厂模式？

定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

什么情况下适用于工厂模式： 1.需求量大 2.牵一发，动全身

工厂模式中有3种角色： 1.工厂角色----【普通类】 2.抽象产品角色---【抽象类/接口】
3.具体产品角色----【抽象类/接口子类】

例如:有农场生产各种水果，有西瓜，有苹果，有香蕉......

农场---工厂角色----【类】

水果---抽象产品角色---【抽象类/接口】

西瓜，苹果，香蕉---具体产品角色----【抽象类/接口子类】

抽象工厂模式---提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

6.如何编写简单工厂【静态】模式？

具体代码自己实现

package com.wangxing.factorypattern;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.util.HashMap;
/**
 * 工厂角色类【生产角色对象】
 * @author feng
 *
 */
public class FactoryClass {
	/*
	 * 生产角色对象
	 */
	public static JueSe createJueSe(String name){
		JueSe js=null;
		try{
			//读取角色列表
			//调用读取角色的方法最后可以得到一个储存有所有数据的HashMap集合
			HashMap<String ,String> jueselist=readJueSeListMap();
			String classname=jueselist.get(name);
			Class classobj=Class.forName(classname);
			js=(JueSe)classobj.newInstance();
		}catch(Exception e){
			e.printStackTrace();
		}
		return js;
	}
	/*
	 * 读取角色列表的方法
	 */
	private static HashMap<String,String> readJueSeListMap(){
		//列表中的数据是键值对形式放置的，所以用HashMap集合保存数据
		//定义一个HashMao集合
		HashMap<String,String> jueselist=null;
		try{
		//将定义的HashMap集合实例化
		jueselist=new HashMap<String,String>();
		//列表中的数据是一行一行放置的，所以读的时候，一行一行读。故用BufferedReader
		File file=new File("JueSeList.txt");
		FileReader in=new FileReader(file);
		BufferedReader buffer=new BufferedReader(in);
		String info=null;
		//因为列表中的数据不只一行，所以用循环去读。
		while((info=buffer.readLine())!=null){
			//读进来的数据是“战士=com.wangxing.factorypattern.ZhanShi”
			//所以用字符串的spilt()根据等号将其拆分成一个字符串数组
			String infoarr[]=info.split("=");
			//将数组中保存的元素取出放入键值对集合
			jueselist.put(infoarr[0], infoarr[1]);
		}
		//关闭键值对输入流
		buffer.close();
		//关闭底层输入流
		in.close();	
		}catch(Exception e){
			e.printStackTrace();
		}
		return jueselist;
	}
}

package com.wangxing.factorypattern;
/**
 * 工厂模式中的抽象产品角色
 * @author feng
 *
 */
public interface JueSe {
	//所有角色具有的公共功能
	public abstract void GongJi();
	//public abstract可以省略
	//void GongJi();
}

package com.wangxing.factorypattern;
/**
 * 战士类【具体产品】
 * @author feng
 *
 */
public class ZhanShi implements JueSe {

	@Override
	public void GongJi() {
		System.out.println("我是战士，我使用大刀攻击怪物");
		
	}
}

package com.wangxing.factorypattern;
import java.util.Scanner;
public class TestMain {

	public static void main(String[] args) {
		Scanner input=new Scanner(System.in);
		System.out.println("请选择角色");
		String name=input.nextLine();
		JueSe js=FactoryClass.createJueSe(name);
		js.GongJi();
	}
}

7.什么是代理模式？

为其他对象提供一种代理以控制对这个对象的访问。

买火车票不一定在火车站买，也可以去代售点。

1.静态代理模式

(1)兄弟模式的静态代理

//卖票功能的接口
package com.wangxing.agentpattern.jingtai.xiongdipattern;
/**
 * 提供售票业务的接口
 * @author feng
 *
 */
public interface SellePiaoService {
	void maipiao();
}

//火车站实现卖票接口
package com.wangxing.agentpattern.jingtai.xiongdipattern;
/**
 * 火车站
 * @author feng
 *
 */
public class HuoCheZhan implements SellePiaoService{
	@Override
	public void maipiao() {
		System.out.println("我家离火车站近，所以我去火车站买票");
	}
}

//代售点实现卖票接口
package com.wangxing.agentpattern.jingtai.xiongdipattern;
/**
 * 代售点
 * @author feng
 *
 */
public class DaiShouDian implements SellePiaoService{
	@Override
	public void maipiao() {
		System.out.println("我家离火车站远，所以我去代售点买票");
	}
}

//测试类
package com.wangxing.agentpattern.jingtai.xiongdipattern;
public class TestMain {
	public static void main(String[] args) {
		//根据家离火车站的远近，决定去什么地方买票
		//家离火车站远，就去代售点买票
		DaiShouDian daishou=new DaiShouDian();
		daishou.maipiao();
		//家离火车站近的，就去火车站买票
		HuoCheZhan huochezhan=new HuoCheZhan();
		huochezhan.maipiao();

	}
}

(2)父子模式的静态代理

//卖票功能的接口
package com.wangxing.agentpattern.jingtai.fuzipattern;
/**
 * 提供售票业务的接口
 * @author feng
 *
 */
public interface SellPiaoService {
	void maipiao();
}

//火车站实现卖票接口
package com.wangxing.agentpattern.jingtai.fuzipattern;
/**
 * 火车站
 * @author feng
 *
 */
public class HuoCheZhan implements SellPiaoService{

	@Override
	public void maipiao() {
		System.out.println("我家离火车站近，我去火车站买票");
	}
}

//代售点继承火车站
package com.wangxing.agentpattern.jingtai.fuzipattern;
/**
 * 代售点
 * @author feng
 *
 */
public class DaiShouDian extends HuoCheZhan{

	@Override
	public void maipiao() {
		System.out.println("我家离火车站远，所以我去代售点买票");
	}
}

//测试类
package com.wangxing.agentpattern.jingtai.fuzipattern;
public class TestMain {

	public static void main(String[] args) {
		//根据家离火车站的远近，决定去哪买票
		//离火车站近的，去火车站买票
		HuoCheZhan hcz=new HuoCheZhan();
		hcz.maipiao();
		//离火车站远的，就去代售点买票
		DaiShouDian dsd=new DaiShouDian();
		dsd.maipiao();

	}
}

静态代理的缺点需要手动创建子类，当需要被代理元素较多的时候，我们的工作量变大了。

由于静态代理的上述缺点，所以我们需要一个专门生产代理对象的类