当前位置:首页 > Java技术 > java 设计模式 常用21种

java 设计模式 常用21种

2022年09月17日 09:32:18Java技术6

1.创造型:抽象工厂

package com.seezoon.创建型.抽象工厂;

/**
 * 抽象工厂
 * @author DF
 *工厂方法模式有一个问题就是,类的创建依赖工厂类,也就是说,如果想要拓展程序,
 *必须对工厂类进行修改,这违背了闭包原则,所以,从设计角度考虑,有一定的问题,如何解决?
 *就用到抽象工厂模式,创建多个工厂类,这样一旦需要增加新的功能,直接增加新的工厂类就可以了,
 *不需要修改之前的代码
 */
public class AbstractFactory {
	public static void main(String[] args) {
		IFactory factory = new ProductAFactory();
		IProduct product = factory.produce();
		product.productMethod();
	}
}
interface IFactory {
	public IProduct produce();
}
class ProductAFactory implements IFactory{
	@Override
	public IProduct produce() {
		return new ProductA();
	}
}
class ProductBFactory implements IFactory{
	@Override
	public IProduct produce() {
		return new ProductB();
	}
}
interface IProduct {
	public void productMethod();
}

class ProductA implements IProduct {
	@Override
	public void productMethod() {
		System.out.println("ProductA");
	}
}

class ProductB implements IProduct {

	@Override
	public void productMethod() {
		System.out.println("ProdectB");
	}
}

2.创造型:单例

package com.seezoon.创建型.单例;

import jdk.internal.dynalink.beans.StaticClass;

/**
 * 简单单例模式(严格的单例模式一般情况不适用可自行科普。) 
 * @author DF
 *  单例模式(Singleton)
          单例对象(Singleton)是一种常用的设计模式。在Java应用中,单例对象能保证在一个JVM中,
          该对象只有一个实例存在。这样的模式有几个好处:
    1、某些类创建比较频繁,对于一些大型的对象,这是一笔很大的系统开销。
    2、省去了new操作符,降低了系统内存的使用频率,减轻GC压力。
    3、有些类如交易所的核心交易引擎,控制着交易流程,如果该类可以创建多个的话,系统完全乱了。
       (比如一个军队出现了多个司令员同时指挥,肯定会乱成一团),所以只有使用单例模式,才能保证核心交易服务器独立控制整个流程。
       
   Singleton是一种创建型模式,指某个类采用Singleton模式,则在这个类被创建后,只可能产生一个实例供外部访问,并且提供一个全局的访问点。
核心知识点如下:
(1) 将采用单例设计模式的类的构造方法私有化(采用private修饰)。
(2) 在其内部产生该类的实例化对象,并将其封装成private static类型。
(3) 定义一个静态方法返回该类的实例。    
 */

/**
 * 1.单例模式的实现:饱汉式,非线程安全
 * 优点是:写起来比较简单,当类SingletonTest被加载的时候,静态变量static的instance未被创建并分配内存空间,
 * 当getInstance方法第一次被调用时,初始化instance变量,并分配内存,因此在某些特定条件下会节约了内存;
缺点是:并发环境下很可能出现多个SingletonTest实例。
 * @author HP
 *
 */
public class Singleton {

	/* 持有私有静态实例,防止被引用,此处赋值为null,目的是实现延迟加载 */  
    private static Singleton instance = null;  
    /* 私有构造方法,防止被实例化 */  
    private Singleton() {  
    }  
    /* 静态工程方法,创建实例 */  
    public static Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
    }  
}

/**
 * 2.单例模式的实现:饿汉式,线程安全 但效率比较低 
 * 优点是:写起来比较简单,而且不存在多线程同步问题,避免了synchronized所造成的性能问题;
缺点是:当类SingletonTest被加载的时候,会初始化static的instance,静态变量被创建并分配内存空间,
从这以后,这个static的instance对象便一直占着这段内存(即便你还没有用到这个实例),
当类被卸载时,静态变量被摧毁,并释放所占有的内存,因此在某些特定条件下会耗费内存。
 */

/**public*/ class SingletonTest {  

    // 定义一个私有的构造方法
    private SingletonTest() {  
    }  

    // 将自身的实例对象设置为一个属性,并加上Static和final修饰符
    private static final SingletonTest instance = new SingletonTest();  

    // 静态方法返回该类的实例
    public static SingletonTest getInstancei() {  
        return instance;  
    }  
  
}
3.创建型.:工厂方法.多个工厂方法

package com.seezoon.创建型.工厂方法.多个工厂方法;


/**
 * 多个工厂方法模式
 * 是对普通工厂方法模式的改进,在普通工厂方法模式中,
 * 如果传递的字符串出错,则不能正确创建对象,而多个工厂方法模式是提供多个工厂方法,分别创建对象
 * @author DF
 *
 */
public class MutiFactoryMethod {
	public static void main(String[] args) {
		MutiFactory factory = new MutiFactory();
		IProduct product = factory.produceA();
		product.productMethod();
	}
}
class MutiFactory{
	public IProduct produceA(){
		return new ProductA();
	}
	public IProduct produceB(){
		return new ProductB();
	}
}

interface IProduct {
	public void productMethod();
}

class ProductA implements IProduct {
	@Override
	public void productMethod() {
		System.out.println("ProductA");
	}
}

class ProductB implements IProduct {
	@Override
	public void productMethod() {
		System.out.println("ProductB");
	}
}
4.创造型:静态工厂

package com.seezoon.创建型.工厂方法.静态工厂;


/**
 * 静态工厂方法模式
 * 将多个工厂方法模式里的方法置为静态的,不需要创建实例,直接调用即可
 * @author DF
 *
 */
public class StaticiFactoryMethod {
	public static void main(String[] args) {
		IProduct product = StaticFactory.produceA();
		product.productMethod();
	}
}
class StaticFactory{
	public static IProduct produceA(){
		return new ProductA();
	}
	public static IProduct produceB(){
		return new ProductB();
	}
}
interface IProduct {
	public void productMethod();
}

class ProductA implements IProduct {
	@Override
	public void productMethod() {
		System.out.println("ProductA");
	}
}

class ProductB implements IProduct {
	@Override
	public void productMethod() {
		System.out.println("ProductB");
	}
}
5.创造型:普通工厂方法

package com.seezoon.创建型.工厂方法.普通工厂模式;

/**
 * 普通工厂方法比较常用
 * @author DF
 *
 */
public class NormalFactoryMethod {

	
	public static void main(String[] args) {
		Factory factory= new Factory();
		IProduct product = factory.produce("A");
		product.productMethod();
	}
}
class Factory{
	/**
	 * 一般可以做成配置 比如xml 
	 * @param product
	 * @return
	 */
	public IProduct produce(String product){
		if ("A".equals(product)) {
			return new ProductA();
		} else if ("B".equals(product)) {
			return new ProductB();
		} else {
			return null;
		}
	}
}
interface IProduct {
	public void productMethod();
}

class ProductA implements IProduct {
	@Override
	public void productMethod() {
		System.out.println("ProductA");
	}
}

class ProductB implements IProduct {
	@Override
	public void productMethod() {
		System.out.println("ProductB");
	}
}

6.创造型:建造者

package com.seezoon.创建型.建造者;


/**
 * 建造者模式
 * @author DF
 * 工厂模式关注的是创建单个产品,而建造者模式则关注创建符合对象
 */
public class Builder {
	 public static void main(String []args){
	        Director dir = new Director();
	        dir.getProduct1().showProduct();
	        dir.getProduct2().showProduct();
	    }
}
class Director {
    private AbsBuild build = new Build();
    public Product getProduct1(){
        build.setProd("df",15);
        return build.getProduct();
    }
    public Product getProduct2(){
        build.setProd("df",20);
        return build.getProduct();
    }
}


abstract class AbsBuild {
    public abstract void setProd(String name,int num);
    public abstract Product getProduct();
}
class Build extends AbsBuild {
    Product product = new Product();
    @Override
    public void setProd(String name, int num) {
        //To change body of implemented methods use File | Settings | File Templates.
        product.setName(name);
        product.setNum(num);
    }

    @Override
    public Product getProduct() {
        return product;
    }
}

class Product {
    private String name;
    private int num;

    public void showProduct(){
        System.out.println("name :"+name);
        System.out.println("age:"+num);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }
}

7.创造型:原型

package com.seezoon.创建型.原型;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * 
 * @author DF
 *原型模式虽然是创建型的模式,但是与工程模式没有关系,从名字即可看出,
 *该模式的思想就是将一个对象作为原型,对其进行复制、克隆,产生一个和原对象类似的新对象。
 *在Java中,复制对象是通过clone()实现的
 */
public class Prototype implements Cloneable,Serializable{
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	public void print(){
		System.out.println("hello Prototype !!!!!");
	}
	/**
	 * 该做法为浅复制
	 * 浅复制:将一个对象复制后,基本数据类型的变量都会重新创建,而引用类型,指向的还是原对象所指向的。
	 */
	public Prototype clone() throws CloneNotSupportedException {  
        Prototype proto = (Prototype) super.clone();  
        return proto;  
    }  
	/**
	 * 深复制
	 * 深复制:将一个对象复制后,不论是基本数据类型还有引用类型,都是重新创建的。
	 * 简单来说,就是深复制进行了完全彻底的复制,而浅复制不彻底
	 * @return
	 * @throws IOException
	 * @throws ClassNotFoundException
	 */
    public Prototype deepClone() throws IOException, ClassNotFoundException {  
  
        /* 写入当前对象的二进制流 */  
        ByteArrayOutputStream bos = new ByteArrayOutputStream();  
        ObjectOutputStream oos = new ObjectOutputStream(bos);  
        oos.writeObject(this);  
        /* 读出二进制流产生的新对象 */  
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());  
        ObjectInputStream ois = new ObjectInputStream(bis);  
        Prototype prototype = (Prototype) ois.readObject();  
        ois.close();
        bis.close();
        oos.close();
        bos.close();
        return prototype;
    }  
    public static void main(String[] args) throws Exception {
    	Prototype prototype = new Prototype();
    	Prototype prototypeClone = prototype.clone();
    	Prototype prototypeDeepClone = prototype.deepClone();
    	prototypeClone.print();
    	prototypeDeepClone.print();
	}
}

8.结构型:代理

package com.seezoon.结构型.代理;

/**
 * 
 * @author DF
 *其实每个模式名称就表明了该模式的作用,代理模式就是多一个代理类出来,
 *替原对象进行一些操作,比如我们在租房子的时候回去找中介,为什么呢?
 *因为你对该地区房屋的信息掌握的不够全面,希望找一个更熟悉的人去帮你做,此处的代理就是这个意思。再如我们有的时候打官司,
 *我们需要请律师,因为律师在法律方面有专长,可以替我们进行操作,表达我们的想法
 *
 *
 *代理模式的应用场景:
	如果已有的方法在使用的时候需要对原有的方法进行改进,此时有两种办法:
	1、修改原有的方法来适应。这样违反了“对扩展开放,对修改关闭”的原则。
	2、就是采用一个代理类调用原有的方法,且对产生的结果进行控制。这种方法就是代理模式。
	使用代理模式,可以将功能划分的更加清晰,有助于后期维护!
 */
public class ProxySample {
	 public static void main(String[] args) {  
	        Sourceable source = new Proxy();  
	        source.method();  
	    }  
}
interface Sourceable {  
    public void method();  
} 
class Source implements Sourceable {  
	  
    @Override  
    public void method() {  
        System.out.println("the original method!");  
    }  
}  
class Proxy implements Sourceable {  
	  
    private Source source;  
    public Proxy(){  
        super();  
        this.source = new Source();  
    }  
    @Override  
    public void method() {  
        before();  
        source.method();  
        atfer();  
    }  
    private void atfer() {  
        System.out.println("after proxy!");  
    }  
    private void before() {  
        System.out.println("before proxy!");  
    }  
}  
9.结构型:桥接

package com.seezoon.结构型.桥接;

/**
 * 
 * @author DF
 *桥接模式就是把事物和其具体实现分开,使他们可以各自独立的变化。
 *桥接的用意是:将抽象化与实现化解耦,使得二者可以独立变化,像我们常用的JDBC桥DriverManager一样,
 *JDBC进行连接数据库的时候,在各个数据库之间进行切换,基本不需要动太多的代码,
 *甚至丝毫不用动,原因就是JDBC提供统一接口,
 *每个数据库提供各自的实现,用一个叫做数据库驱动的程序来桥接就行了
 *
 *
 *
 *通过对Bridge类的调用,实现了对接口Sourceable的实现类SourceSub1和SourceSub2的调用
 */
public class BridgeSample {
	public static void main(String[] args) {  
        
        Bridge bridge = new MyBridge();  
          
        /*调用第一个对象*/  
        Sourceable source1 = new SourceSub1();  
        bridge.setSource(source1);  
        bridge.method();  
          
        /*调用第二个对象*/  
        Sourceable source2 = new SourceSub2();  
        bridge.setSource(source2);  
        bridge.method();  
    }  
}
interface Sourceable {  
    public void method();  
}  
class SourceSub1 implements Sourceable {  
	  
    @Override  
    public void method() {  
        System.out.println("this is the first sub!");  
    }  
}  
class SourceSub2 implements Sourceable {  
	  
    @Override  
    public void method() {  
        System.out.println("this is the second sub!");  
    }  
}  
abstract class Bridge {  
    private Sourceable source;  
  
    public void method(){  
        source.method();  
    }  
      
    public Sourceable getSource() {  
        return source;  
    }  
  
    public void setSource(Sourceable source) {  
        this.source = source;  
    }  
}  
class MyBridge extends Bridge {  
    public void method(){  
        getSource().method();  
    }  
}  

10.结构型:对象适配器

package com.seezoon.结构型.适配器.对象适配器;

/**
 * 对象适配器
 * @author DF
 *对象的适配器模式:当希望将一个对象转换成满足另一个新接口的对象时,可以创建一个Adapter类,持有原类的一个实例,
 *在Adapter类的方法中,调用实例的方法就行。
 */
public class ObjectAdapter {
	public static void main(String[] args) {
		Source source = new Source();
		Adapter adapter = new Adapter(source);
		adapter.method1();
		adapter.method2();
	}
}

class Source {
	public void method1() {
		System.out.println("this is original method!");
	}
}

interface Targetable {
	/* 与原类中的方法相同 */
	public void method1();

	/* 新类的方法 */
	public void method2();
}

class Adapter implements Targetable {

	private Source source;

	public Adapter(Source source) {
		super();
		this.source = source;
	}

	@Override
	public void method2() {
		System.out.println("this is the targetable method!");
	}

	@Override
	public void method1() {
		source.method1();
	}
}



    

作者:Rundy_Deng
来源链接:https://blog.csdn.net/Rundy_Deng/article/details/76552095

版权声明:
1、JavaClub(https://www.javaclub.cn)以学习交流为目的,由作者投稿、网友推荐和小编整理收藏优秀的IT技术及相关内容,包括但不限于文字、图片、音频、视频、软件、程序等,其均来自互联网,本站不享有版权,版权归原作者所有。

2、本站提供的内容仅用于个人学习、研究或欣赏,以及其他非商业性或非盈利性用途,但同时应遵守著作权法及其他相关法律的规定,不得侵犯相关权利人及本网站的合法权利。
3、本网站内容原作者如不愿意在本网站刊登内容,请及时通知本站(javaclubcn@163.com),我们将第一时间核实后及时予以删除。


本文链接:https://www.javaclub.cn/java/42461.html

分享给朋友:

“java 设计模式 常用21种” 的相关文章

一分钟搞定Java环境变量配置

一分钟搞定Java环境变量配置

对于学Java的人来说,成功配置环境变量是第一步,因为后期不论 你做什么工作,会发现都需要这些,接下来介绍如何安装与配置,我按照jdk1.6来说明,其他一致。 下载官网 首先将jdk安装好后进行配置。 右击“计算机”,右键打开“属性”,...

Java实现Email发送

一、前言最近将项目的登录密码从图形验证码改为了短信验证码,同时也将忘记密码时长度进行了修改,在修改时,想到了之前在一些国外的网站上,使用过邮箱接收验证码的情况,故想到何妨不自己尝试整合一下Java程序发送邮件信息呢,所以动手整合了Email的发送实例。二、Email发送协议想要在互联网上提供电子邮件...

常用设计模式系列(二)—工厂方法模式

常用设计模式系列(二)—工厂方法模式

一、前言 hello各位小伙伴好,天气贼冷,多冻手,但是还是不能降低我编写设计模式讲解的热情。设计模式的魅力就像那冬天里的一把火,怎么也浇不灭; 上期讲解了简单工厂模式的应用场景及优缺点分析,今天开始我们的设计模式第二弹——工厂方法模式,其实工厂方法模式类似于简单工厂模式的一个升级...

常用设计模式系列(五)—原型模式

常用设计模式系列(五)—原型模式

一、前言 各位朋友大家好,经过几天的努力,我已经讲解了常用设计模式其中的四种,分别是简单工厂、工厂方法、抽象工厂、建造者模式,正在想着下一遍写哪个模式的时候,有个朋友先说他想先看看原型模式,说想看看原型模式是如何运行的,然后我给这个朋友讲了个故事:“从前有个老铁得了个病,听说还挺严重的,后来...

冒泡排序的原理,思路,以及算法分析(Java实现)

冒泡排序的原理,思路,以及算法分析(Java实现)

冒泡排序 如果遇到相等的值不进行交换,那这种排序方式是稳定的排序方式。 1.原理:比较两个相邻的元素,将值大的元素交换到右边 2.思路:依次比较相邻的两个数,将比较小的数放在前面,比较大的数放在后面。 (1)第一次比较:首先比较第...

枚举法 之Java实现凑硬币

问题? 如何利用1元五元十元凑硬币 Scanner in=new Scanner(System.in); int amout ; amout=in.nextInt(); for(int one =0;one<=amout;one+...

java之整数的分解可以理解为倒序输出

Scanner in=new Scanner(System.in); int number ; number=in.nextInt(); int result=0; do{ int diget=number%10;...

java比较语句常犯错误和三个数比较大小

1.忘了大括号 解决: 任何if else语句后面加大括号,哪怕只有一句 2.忘了分号 if后面不能有分号 3.代码分格 Scanner in=new Scanner(System.in); int x; int y; int z;...

动车上的书摘-java对象流与序列化

动车上的书摘-java对象流与序列化

动车上的书摘-java对象流与序列化摘要: 摘要: 原创出处: http://www.cnblogs.com/Alandre/ 泥沙砖瓦浆木匠 希望转载,保留摘要,谢谢!钢笔不限贵便宜,书法是来自心对手的交流。-泥沙砖瓦浆木匠 一.对象序列化当需要存储相同类型的数据,选...

Java 基础:hashCode方法

Java 基础:hashCode方法

Writer:BYSocket(泥沙砖瓦浆木匠) 微博:BYSocket 豆瓣:BYSocket 一、前言     泥瓦匠最近被项目搞的天昏地暗。发现有些要给自己一些目标,关于技术的目标: 专注...

发表评论

访客

◎欢迎参与讨论,请在这里发表您的看法和观点。