创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
一.责任链模式
二.工厂模式(让调用方只去关注接口，而不需要关注具体对象如何创建，如何实现)
1.简单工厂模式
2.工厂方法模式
3.抽象工厂模式
三.迭代器模式
四.策略模式
五.代理模式
六.单例模式
七.适配器模式
八.观察者模式
九.原型设计模式
浅拷贝： 因为 Java 做了一个偷懒的拷贝动作， Object 类提供的方法 clone 只是拷贝本对象，其对象内部的数组、引用对象等都不拷贝，还是指向原生对象的内部元素地址，这种拷贝就叫做浅拷贝，确实是非常浅，两个对象共享了一个私有变量，你改我改大家都能改，是一个种非常不安全的方式。
注：内部的数组和引用对象才不拷贝，其他的原始类型比如int,long,String(Java 就希望你把 String 认为是基本类型， String 是没有 clone 方法的)等都会被拷贝的。
深拷贝：对一个对象的内部对象也进行拷贝
十.建造者模式
*工厂方法创建一个对象是只需要new即可，但是建造者模式创建一个对象需要一些复杂步骤，是对这些建造步骤的封装
十一. 装饰器模式
十二.桥接模式
一.责任链模式
增强了的代码的可扩展性
当在一个请求流程中，设计到某个信息需要多次处理，当把所有的处理代码写死在同一个类中，这就会导致代码的耦合度变高 ，当需要加入新的处理模块时就会变得非常不方便。责任链模式是解决这种问题的优秀模式。
二.设计模式之工厂模式
java设计开发需要遵循的设计原则：
（1）遵循单一职责原则
（2）开放-封闭原则
（3）里氏代换原则（LSP）
（4）依赖倒置原则
（5）接口隔离原则
（6）迪米特法则（Law of Demeter）
二.工厂模式（使用工厂方法可以减小代码耦合，如果不使用工厂，当某个类在多个地方被new时，有一天需要替换时，需要大量修改，而使用工厂的话只需要修改工厂就行）
1.简单工厂模式：一个综合的工厂类，当需要实力化新的类时需要修改这个类的方法，需要对工厂类的源码进行修改，这不符合开放-封闭原则（即扩展开放，对源码的修改封闭）。
2.工厂方法模式：
3.抽象工厂模式 （抽象指的是逻辑抽象，而不一定是使用抽象类）
三.迭代器模式
优点：给不同的聚集类设计统一的迭代器，在遍历时不需要关心内部表现，当从一个容器改换成另一个容器时，不做大篇幅修改即可实现。（封装，降低耦合）
四.策略模式
五.代理模式
*jdk动态代理生成的代理类
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
import com.bluemsun.service.ATMInterface;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class ATMProxy extends Proxy implements ATMInterface {
private static Method m1;
private static Method m2;
private static Method m3;
private static Method m0;
public ATMProxy(InvocationHandler var1) throws {
super(var1);
}
public final boolean equals(Object var1) throws {
try {
return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final String toString() throws {
try {
return (String)super.h.invoke(this, m2, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final void getMoney() throws {
try {
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final int hashCode() throws {
try {
return (Integer)super.h.invoke(this, m0, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m2 = Class.forName("java.lang.Object").getMethod("toString");
m3 = Class.forName("com.bluemsun.service.ATMInterface").getMethod("getMoney");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
六.单例模式
懒汉模式：
1.非线程安全
package com.cbf4life.singleton3;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
* 通用单例模式
*/
@SuppressWarnings("all")
public class SingletonPattern {
private static SingletonPattern singletonPattern= null;
//限制住不能直接产生一个实例
private SingletonPattern(){
}
public SingletonPattern getInstance(){
if(this.singletonPattern == null){ //如果还没有实例，则创建一个
this.singletonPattern = new SingletonPattern();
}
return this.singletonPattern;
}
}DCL（双重检测）：保证懒汉式单例模式的线程安全
性能好 懒加载（为了推迟和数据库交互的时间，推迟到真正需要这个对象数据的时候。提高系统的性能） 线程安全
import java.net.Socket;
import java.sql.Connection;
//Double-check-locking
public class DCL {
Connection conn;
Socket socket;
private volatile static DCL instance=null;
private DCL(){
}
public static DCL getInstance(){
if(null==instance)
synchronized (DCL.class){
if(null==instance)
instance=new DCL();
}
return instance;
}
public static void main(String[] args) {
for (int i = 0; i < 20; i++) {
new Thread(()->{
System.out.println(DCL.getInstance());
}).start();
}
}
}
多线程单例（饿汉式）：
package com.cbf4life.singleton3;
/**
* @author cbf4Life cbf4life@126.com
* I'm glad to share my knowledge with you all.
* 通用单例模式
*/
@SuppressWarnings("all")
public class SingletonPattern {
private static final SingletonPattern singletonPattern= new SingletonPattern();
//限制住不能直接产生一个实例
private SingletonPattern(){
}
public synchronized static SingletonPattern getInstance(){
return singletonPattern;
}
}
package com.bluemsun.entity;
/**
* Created by mafx on 2019/1/25.
* @author mafx.
* 饿汉式单例模式
* 1.线程安全
* 2.没有延迟加载 长时间驻留内存不使用 影响性能
*/
public class HungryChineseSingletonPattern{
private static HungryChineseSingletonPattern hcsp=new HungryChineseSingletonPattern();
public static HungryChineseSingletonPattern getInstance(){
return hcsp;
}
}
class Test implements Runnable{
@Override
public void run() {
System.out.println(HungryChineseSingletonPattern.getInstance());
}
public static void main(String[] args) {
Test test=new Test();
Thread t1=new Thread(test);
Thread t2=new Thread(test);
Thread t3=new Thread(test);
Thread t4=new Thread(test);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
构造型
public class HolderDemo {
private HolderDemo(){
}
private static class Holder{
private static HolderDemo instance=new HolderDemo();
}
//懒加载
//synchronized
//<init>
public static HolderDemo getInstance(){
return Holder.instance;
}
//广泛的一种单例模式
}
七.适配器模式
*在软件开发中，也就是系统的数据和行为都正确，但是接口不符时，我们应该考虑用适配器，目的是使控制范围之外的一个原有对象与某个接口匹配。 适配器模式主要应用于希望服用一些现存的类，但是接口又与服用环境要求不一致的情况。
*使用一个已经存在的类，但如果它的接口，也就是它的方法和你的要求不相同时，就应该考虑使用适配器模式。
*两个类所做的事情相同或相似，但是具有不同的接口时要使用它。
八.观察者模式
*观察者模式的使用场景
1.当一个对象的改变需要同时修改其他对象的时候，而且它不知道具体you对少对象有待改变时。
十一. 装饰器模式
十二.桥接模式
扫一扫
171万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
