java设计模式；直接上代码；

最新推荐文章于 2024-10-05 12:07:50 发布
最新推荐文章于 2024-10-05 12:07:50 发布
阅读量246 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cgj19960119/article/details/110037963
版权

一、单例模式

package mode;
//懒汉 饿汉 匿名内部类
public class Singleton {

	// 第一种（懒汉，线程不安全）
	/*
	 * private static Singleton singleton;
	 * 
	 * private Singleton(){}
	 * 
	 * public static Singleton getInstance(){ if(singleton == null){ singleton =
	 * new Singleton(); } return singleton; }
	 */

	// 第二种（懒汉，线程安全） 99%情况下不需要同步、效率很低
	/*
	 * private static Singleton instance;
	 * 
	 * private Singleton (){}
	 * 
	 * public static synchronized Singleton getInstance() { if (instance ==
	 * null) { instance = new Singleton(); } return instance; }
	 */

	// 第三种  饿汉 没有达到单例的效果 可以会有其他原因导致类装载
	/*
	 * private static Singleton instance = new Singleton();
	 * 
	 * private Singleton(){}
	 * 
	 * public static Singleton getInstance(){ return instance; }
	 */
	
	//第四种 和第三种差不多
	/*private static Singleton instance = null;  
	  static {
		instance = new Singleton();
	  }

	  private Singleton() {
	  }

	  public static Singleton getInstance() {  
	    return instance;  
	  }*/
	
	//第五种 匿名内部类
	/*private static class SingletonHolder{
		private static final Singleton INSTANCE = new Singleton();
	}
	
	  private Singleton(){}
	
	  public static Singleton getInstance(){
		return SingletonHolder.INSTANCE;
	  }*/

}

package mode;
//枚举
public enum Singleton1 {

	INSTANCE;  
    public void whateverMethod() {  

    }  
}

package mode;
//双重校验锁
public class Singleton2 {
	
	private volatile static Singleton2 singleton2;
	
	private Singleton2(){}
	
	public static Singleton2 getInstance(){
		if(singleton2 == null){
			synchronized (Singleton2.class) {
				if(singleton2 == null){
					singleton2 = new Singleton2();
				}
			}
		}
		return singleton2;
	}

}

二、工厂方法模式

package product;

public interface Logger {
	
	public void writeLogger();

}

package product;

public class FileLogger implements Logger{

	@Override
	public void writeLogger() {
		System.out.println("文件日志系统");
	}

	
}

package product;

public class DatabaseLogger implements Logger{

	@Override
	public void writeLogger() {
		System.out.println("数据库日志系统"); 
	}

}

package factory;

import product.Logger;

public interface LoggerFactory {
	
	public Logger createLogger(); 

}


package factory;

import product.FileLogger;
import product.Logger;

public class FileLoggerFactory implements LoggerFactory{

	@Override
	public Logger createLogger() {
		Logger logger = new FileLogger();
		return logger;
	}

}

package factory;

import product.DatabaseLogger;
import product.Logger;

public class DatabaseLoggerFactory implements LoggerFactory{

	@Override
	public Logger createLogger() {
		Logger logger = new DatabaseLogger();
		return logger;
	}

}

package factory;

import product.Logger;

public class Client {
	
	public static void main(String[] args) {
		LoggerFactory loggerFactory = new DatabaseLoggerFactory();
		Logger logger = loggerFactory.createLogger(); 
		logger.writeLogger();
		
		LoggerFactory loggerFactory2 = new FileLoggerFactory();
		Logger logger2 = loggerFactory2.createLogger();
		logger2.writeLogger();
	}

}

三、抽象工厂模式

package abstract1;

public interface Fruit {
	
	public void get();

}


package abstract1;

public abstract class Apple implements Fruit{
	
	public abstract void get();
	
}

package abstract1;

public abstract class Banana implements Fruit{
	
	public abstract void get();
	
}

package abstract1;

public class ChinaApple extends Apple{

	@Override
	public void get() {
		System.out.println("中国苹果");
	}

}

package abstract1;

public class ChinaBanana extends Banana{

	@Override
	public void get() {
		System.out.println("中国香蕉");
	}

}

package abstract1;

public interface FruitFactory {
	
	//实例化苹果
	public Fruit getApple();
	
	//实例化香蕉
	public Fruit getBanana();

}

package abstract1;

public class ChinaFactory implements FruitFactory{

	@Override
	public Fruit getApple() {
		return new ChinaApple();
	}

	@Override
	public Fruit getBanana() {
		return new ChinaBanana();
	}

}

package abstract1;

public class EnglandApple extends Apple{

	@Override
	public void get() {
		System.out.println("英国苹果");
	}

}

package abstract1;

public class EnglandBanana extends Banana{

	@Override
	public void get() {
		System.out.println("英国香蕉");
	}

}

package abstract1;

public class EnglandFactory implements FruitFactory{

	@Override
	public Fruit getApple() {
		return new EnglandApple();
	}

	@Override
	public Fruit getBanana() {
		return new EnglandBanana();
	}

}

package abstract1;

public class MainClass {
	
	public static void main(String[] args) {
		FruitFactory fruitFactory = new ChinaFactory();
		Fruit apple = fruitFactory.getApple();
		apple.get();
		Fruit banana = fruitFactory.getBanana();
		banana.get();
		
		
		FruitFactory fruitFactory2 = new EnglandFactory();
		Fruit apple2 = fruitFactory2.getApple();
		apple2.get();
		Fruit banana2 = fruitFactory2.getBanana();
		banana2.get();
		
		
	}

}

四、建造者模式

package builder;

/**
 * Builder.java
 *  建造者
 */
abstract class Builder {
    //地基
    abstract void bulidA();
    //钢筋工程
    abstract void bulidB();
    //铺电线
    abstract void bulidC();
    //粉刷
    abstract void bulidD();
    //完工-获取产品
    abstract Product getProduct();
}

package builder;

/**
 * Product.java
 *  产品（房子）
 */
public class Product {
    private String buildA;
    private String buildB;
    private String buildC;
    private String buildD;
    public String getBuildA() {
        return buildA;
    }
    public void setBuildA(String buildA) {
        this.buildA = buildA;
    }
    public String getBuildB() {
        return buildB;
    }
    public void setBuildB(String buildB) {
        this.buildB = buildB;
    }
    public String getBuildC() {
        return buildC;
    }
    public void setBuildC(String buildC) {
        this.buildC = buildC;
    }
    public String getBuildD() {
        return buildD;
    }
    public void setBuildD(String buildD) {
        this.buildD = buildD;
    }
    @Override
        public String toString() {
            return buildA+"\n"+buildB+"\n"+buildC+"\n"+buildD+"\n"+"房子验收完成";
        }
}


package builder;

/**
 * ConcreteBuilder.java
 *  具体建造者(工人)
 */
public class ConcreteBuilder extends Builder{
    private Product product;
    public ConcreteBuilder() {
        product = new Product();
    }
    @Override
    void bulidA() {
        product.setBuildA("地基");
    }
    @Override
    void bulidB() {
        product.setBuildB("钢筋工程");
    }
    @Override
    void bulidC() {
        product.setBuildC("铺电线");
    }
    @Override
    void bulidD() {
        product.setBuildD("粉刷");
    }
    @Override
    Product getProduct() {
        return product;
    }
}

package builder;

/**
 * Director.java
 *  指挥者
 */
public class Director {
    //指挥工人按顺序造房
    public Product create(Builder builder) {
        builder.bulidA();
        builder.bulidB();
        builder.bulidC();
        builder.bulidD();
        return builder.getProduct();
    }
}

package builder;

/**
 * Test.java
 *  测试类
 */
public class Test {
    public static void main(String[] args) {
        Director director = new Director();
        Product create = director.create(new ConcreteBuilder());
        System.out.println(create.toString());
    }
}

五、原型模式

  1. 浅克隆
package prototypePattern;
/**
* <p>Title: Attachment</p>  
* <p>Description:附件类 </p>  
*/
 
public class Attachment {
 private String name;	//附件名
 
public String getName() {
	return name;
}
 
public void setName(String name) {
	this.name = name;
}
 public void download() {
	 System.out.println("下载附件"+name);
 }
}

package prototypePattern;
/**
* <p>Title: WeeklyLog</p>  
* <p>Description:周报类充当具体的原型类 </p>  
*/
public class WeeklyLog implements Cloneable{
	
	private Attachment attachment;
	private String date;
	private String name;
	private String content;
	public Attachment getAttachment() {
		return attachment;
	}
	public void setAttachment(Attachment attachment) {
		this.attachment = attachment;
	}
	public String getDate() {
		return date;
	}
	public void setDate(String date) {
		this.date = date;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getContent() {
		return content;
	}
	public void setContent(String content) {
		this.content = content;
	}
	//实现clone()方法实现浅克隆
	public WeeklyLog clone() {
		//需要实现cloneable的接口，直接继承object就好，它里面自带一个clone方法！
		Object obj = null;
		try {
			obj = super.clone();
			return (WeeklyLog)obj;
		} catch (CloneNotSupportedException e) {
			// TODO Auto-generated catch block
			System.out.println("不支持克隆方法！");
			return null;
		}
		
		
	}
}

package prototypePattern;                                                                                  
                                                                                                           
public class Client {                                                                                      
    //测试类，客户端                                                                                              
	public static void main(String[] args) {                                                               
		WeeklyLog log_1,log_2;                                                                             
		log_1 = new WeeklyLog();	//创建原型对象                                                               
		Attachment attachment = new Attachment(); //创建附件对象                                                 
		log_1.setAttachment(attachment);	//将附件添加到周报种去                                                   
		log_2=log_1.clone();	//克隆周报                                                                     
		System.out.println("周报是否相同"+(log_1==log_2));                                                       
		System.out.println("附件是否相同"+(log_1.getAttachment()==log_2.getAttachment()));                       
	}                                                                                                      
}

2.深克隆

package prototypePattern;
 
import java.io.Serializable;
 
/**
* <p>Title: Attachment</p>  
* <p>Description:附件类 </p>  
*/
 
public class Attachment_2 implements Serializable {
 private String name;	//附件名
 
public String getName() {
	return name;
}
 
public void setName(String name) {
	this.name = name;
}
 public void download() {
	 System.out.println("下载附件"+name);
 }
}

package prototypePattern;
 
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.Serializable;
 
/**
* <p>Title: WeeklyLog</p>  
* <p>Description:周报类充当具体的原型类 </p>  
*/
public class WeeklyLog_2 implements Serializable{
	
	private Attachment_2 attachment;
	private String date;
	private String name;
	private String content;
	public Attachment_2 getAttachment() {
		return attachment;
	}
	public void setAttachment(Attachment_2 attachment) {
		this.attachment = attachment;
	}
	public String getDate() {
		return date;
	}
	public void setDate(String date) {
		this.date = date;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getContent() {
		return content;
	}
	public void setContent(String content) {
		this.content = content;
	}
	//通过序列化进行深克隆
	public WeeklyLog_2 deepclone() throws Exception {
		//将对象写入流中,
		ByteArrayOutputStream bao = new ByteArrayOutputStream();
		ObjectOutputStream oos = new ObjectOutputStream(bao);
		oos.writeObject(this);
		//将对象取出来
		ByteArrayInputStream bi = new ByteArrayInputStream(bao.toByteArray());
		ObjectInputStream ois = new ObjectInputStream(bi);
		return (WeeklyLog_2)ois.readObject();
		
		
	}
}

package prototypePattern;                                                                                  
                                                                                                           
public class Client_2 {                                                                                      
    //测试类，客户端                                                                                              
	public static void main(String[] args) {                                                               
		WeeklyLog_2 log_1,log_2=null;                                                                             
		log_1 = new WeeklyLog_2();	//创建原型对象                                                               
		Attachment_2 attachment = new Attachment_2(); //创建附件对象                                                 
		log_1.setAttachment(attachment);	//将附件添加到周报种去                                                   
		try {
			log_2=log_1.deepclone();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}	//克隆周报                                                                     
		System.out.println("周报对象是否相同"+(log_1==log_2));                                                     
		System.out.println("附件对象是否相同"+(log_1.getAttachment()==log_2.getAttachment()));                     
	}                                                                                                      
}
不为人知的小小鸟
关注
专栏目录
（1）GoF设计模式之工厂方法模式及其实例
雪华杉的博客
03-05 469
工厂方法模式又称为工厂模式 具体代码: Client.java package factory; public class Client { public static void main(String[] args) { // TODO Auto-generated method stub try { TV tv; TVFactory factory; factory=(TVFactory)XMLUtilTVFactory.getBean(); tv=fa
Java中23种设计模式
呜呜老司机的博客家园
10-10 8万+
Java中23种设计模式，包括简单介绍，适用场景以及优缺点等
Java常见设计模式总结
张维鹏的博客
09-18 19万+
设计模式是一套经过反复使用的代码设计经验，目的是为了重用代码、让代码更容易被他人理解、保证代码可靠性。设计模式于己于人于系统都是多赢的，它使得代码编写真正工程化，它是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现实中都有相应的原理来与之对应，每种模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。总体来说，设计模式分为三大类：5种创建型模式、7种结构型模式、11种行为型模式
JAVA设计模式之单例模式
热门推荐
一个本科小生的奋斗史
04-16 99万+
本文继续介绍23种设计模式系列之单例模式。 概念： 　　java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、登记式单例。 　　单例模式有以下特点： 　　1、单例类只能有一个实例。 　　2、单例类必须自己创建自己的唯一实例。 　　3、单例类必须给所有其他对象提供这一实例。　　单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例...
JAVA设计模式之策略模式详解
励志成为一名优秀的全能型软件开发工程师。
02-10 9709
策略模式(strategy pattern)的原始定义是：定义一系列算法，将每一个算法封装起来，并使它们可以相互替换。策略模式让算法可以独立于使用它的客户端而变化。其实我们在现实生活中常常遇到实现某种目标存在多种策略可供选择的情况，例如，出行旅游可以乘坐飞机、乘坐火车、骑自行车或自己开私家车等。
Java设计模式——策略模式
涛涛的个人博客
10-29 9万+
策略模式 1.策略模式简介 策略模式：策略模式是一种行为型模式，它将对象和行为分开，将行为定义为 一个行为接口 和 具体行为的实现。策略模式最大的特点是行为的变化，行为之间可以相互替换。每个if判断都可以理解为就是一个策略。本模式使得算法可独立于使用它的用户而变化 2.模式结构 策略模式包含如下角色： Strategy: 抽象策略类：策略是一个接口，该接口定义若干个算法标识，即定义了若干个抽象方法（如下图的algorithm()） Context: 环境类 /上下文类： 上下文是依赖于接口的类（
Java的23种设计模式
初心不忘、始终方得
09-01 5655
大话java23种设计模式，通俗易懂
23种设计模式详解与示例代码（详解附DEMO）
沉淀、分享、成长，让自己和他人都能有所收获！
08-01 2万+
本文将探讨设计模式在Java中的应用与实现。设计模式是一套被广泛接受的解决常见软件设计问题的经典方法。在Java编程中，设计模式是提高代码可读性、可维护性和可扩展性的关键。本文将详细介绍Java中常用的几种设计模式，包括工厂模式、单例模式、观察者模式和装饰器模式，并提供具体的代码示例和解释，帮助读者深入理解和学习这些模式的实现方式。
JAVA设计模式之原型模式详解
励志成为一名优秀的全能型软件开发工程师。
02-05 3840
定义: 原型模式(Prototype Design Pattern)用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型对象相同的新对象。西游记中的孙悟空 拔毛变小猴,孙悟空这种根据自己的形状复制出多个身外化身的技巧,在面向对象软件设计领域被称为原型模式.孙悟空就是原型对象.原型模式主要解决的问题。
23种Java设计模式
qq_41847894的博客
03-06 3385
Java 设计模式可以分为三大类：创建型模式 (Creational Patterns)、结构型模式 (Structural Patterns) 、行为型模式 (Behavioral Patterns)。另一类设计模式：J2EE 设计模式。
Java设计模式刘伟书本中模拟考试答案
11-28
在《Java设计模式》这本书的模拟试题及其参考答案中，涉及了多条设计模式的知识点，以及它们的应用场景和实现方法。现在将这些知识点详细地解释如下： 1. 开闭原则（Open-Closed Principle, OCP）： 开闭原则是面向...
Java23种设计模式可直接运行Demo
06-06
设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 ...
软件设计模式（java版）习题答案.pdf
06-24
软件设计模式（Java版）习题答案 本资源为软件设计模式（Java版）习题答案，由程细柱编著，人民邮电出版社出版。该资源涵盖了软件设计模式的基础知识，包括软件设计模式的概述、UML中的类图、面向对象的设计原则、...
23种设计模式（java代码实现案例）
m0_55651862的博客
10-12 2387
23种设计模式（java代码实现案例）
C语言 | 第十章 | 函数 作用域
最新发布
ZJC744575的博客
10-05 837
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 433
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
spring-boot 整合 mybatis
m0_72168501的博客
09-29 534
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 795
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 1260
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
精通JAVA设计模式：解锁代码艺术
"JAVA设计模式 - 一本面向初级到高级程序员，乃至系统分析师的指南，涵盖了25种经典设计模式，旨在提升代码设计质量并解决项目中的公共问题。" 设计模式是软件工程中的一种最佳实践，它是在特定上下文中解决常见...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值