java 设计模式常用21种

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{@Overridepublic IProduct produce() {return new ProductA();}
}
class ProductBFactory implements IFactory{@Overridepublic IProduct produce() {return new ProductB();}
}
interface IProduct {public void productMethod();
}class ProductA implements IProduct {@Overridepublic void productMethod() {System.out.println("ProductA");}
}class ProductB implements IProduct {@Overridepublic 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 {@Overridepublic void productMethod() {System.out.println("ProductA");}
}class ProductB implements IProduct {@Overridepublic 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 {@Overridepublic void productMethod() {System.out.println("ProductA");}
}class ProductB implements IProduct {@Overridepublic 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 {@Overridepublic void productMethod() {System.out.println("ProductA");}
}class ProductB implements IProduct {@Overridepublic 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();@Overridepublic void setProd(String name, int num) {//To change body of implemented methods use File | Settings | File Templates.product.setName(name);product.setNum(num);}@Overridepublic 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;}@Overridepublic void method2() {System.out.println("this is the targetable method!");}@Overridepublic void method1() {source.method1();}
}

java 设计模式常用21种相关推荐

JAVA设计模式之3种工厂模式
转自 JAVA设计模式之3种工厂模式创建型模式创建型模式(Creational Pattern)对类的实例化过程进行了抽象,能够将软件模块中对象的创建和对象的使用分离.为了使软件的结构更加清晰,外 ...
我以订披萨为例，给朋友详细讲了Java设计模式的3种工厂模式
摘要:工厂模式是将实例化对象的代码提取出来,放到一个类中统一管理和维护,达到和主项目的依赖关系的解耦.从而提高项目的扩展和维护性. 本文分享自华为云社区<[Java设计模式]用披萨订购案例详 ...
Java设计模式：23种设计模式全面解析，墙都不扶就服你
命令模式:将命令请求封装为一个对象,使得可以用不同的请求来进行参数化. 迭代器模式:一种遍历访问聚合对象中各个元素的方法,不暴露该对象的内部结构. 观察者模式:对象间的一对多的依赖关系. 仲裁者模式: ...
JAVA设计模式（21）：行为型-迭代器模式（Iterator）
20世纪80年代,那时我家有一台"古老的"电视机,牌子我忘了,只记得是台黑白电视机,没有遥控器,每次开关机或者换台都需要通过电视机上面的那些按钮来完成,我印象最深的是那个用来换台的 ...
24张图带你彻底理解Java中的21种锁
本篇主要内容如下: 本篇主要内容本篇文章已收纳到我的Java在线文档. Github 我的SpringCloud实战项目持续更新中帮你总结好的锁: 序号锁名称应用 1 乐观锁 CAS 2 悲观 ...
java中怎么判断一段代码时线程安全还是非线程安全_24张图带你彻底理解Java中的21种锁...
(给ImportNew加星标,提高Java技能) 转自:悟空聊架本篇主要内容如下: 本篇文章已收纳到我的 Java 在线文档. Github.我的 SpringCloud 实战项目持续更新中. 帮你 ...
多图带你彻底理解Java中的21种锁！
作者 | 悟空聊架构来源 | 悟空聊架构(ID:PassJava666) 本篇主要内容如下: 本篇主要内容本篇文章已收纳到我的Java在线文档. Github 我的SpringCloud实战项目持 ...
java 设计模式之几种常见设计模式详解 demo
1.单例模式单例模式,它的定义就是确保某一个类只有一个实例,并且提供一个全局访问点. 单例模式具备典型的3个特点:1.只有一个实例. 2.自我实例化. 3.提供全局访问点. 因此当系统中只需要一个实 ...
Java中的21种锁
本篇主要内容如下: 本篇主要内容本篇文章已收纳到我的Java在线文档. Github 我的SpringCloud实战项目持续更新中帮你总结好的锁: 序号锁名称应用1乐观锁CAS2悲观锁synchr ...

java 设计模式常用21种

java 设计模式常用21种相关推荐

最新文章

热门文章

java 设计模式 常用21种

java 设计模式 常用21种相关推荐

最新文章

热门文章

java 设计模式常用21种

java 设计模式常用21种相关推荐