在 E:\学习文档子目录压缩\J2SE\23种设计模式
我的网盘/我的笔记/学习文档子目录压缩/ J2SE/23种设计模式/23种设计模式V1.1版.doc
工厂模式：工厂类 为实现同一接口的类创建实例的类
接口：
IFactory.javapackage com.xiangshuai.factory;
/**
* @create 2019-01-09 17:41
*/
public interface IFactory {
public String send();
}实现类：
ImplMessage.javapackage com.xiangshuai.factory;
/**
* @create 2019-01-09 17:42
*/
public class ImplMessage implements IFactory {
@Override
public String send() {
return "this 发送信息对象";
}
}
ImplQ.javapackage com.xiangshuai.factory;
/**
* @create 2019-01-09 17:44
*/
public class ImplQ implements IFactory {
@Override
public String send() {
return "this is 发送邮件对象";
}
}工厂类：
FactoryClass.javapackage com.xiangshuai.factory;
/**
* @create 2019-01-09 17:45
* T:接口，qclass:要创建实例的全类名，此类需是T的子类
*/
public class FactoryClass<T> {
public T createInstance(String qclass) throws Exception{
Class<T> aClass = (Class<T>)Class.forName(qclass);
return aClass.newInstance();
}
}测试类
Demo.javapackage com.xiangshuai.factory;
/**
* @create 2019-01-09 17:55
*/
public class Demo {
public static void main(String[] args) {
FactoryClass<IFactory> fc = new FactoryClass<IFactory>();
try {
IFactory instance = fc.createInstance("com.xiangshuai.factory.ImplMessage");
System.out.println(instance.send());
IFactory instance2 = fc.createInstance("com.xiangshuai.factory.ImplQ");
System.out.println(instance2.send());
}catch (Exception e){
e.printStackTrace();
}
}
}
单例模式
--懒汉式
MySingleton.javapackage com.xiangshuai.singleton;
/**
* @create 2019-01-09 22:20
* 懒汉式
*/
public class MySingleton {
private static MySingleton mySingleton=null;
/*私有构造方法，防止被实例化*/
private MySingleton() {
}
public static MySingleton getMySingleton(){
if(mySingleton==null){//只有第一次创建才会进入 synchronized加锁，提高性能
synchronized (MySingleton.class){
if(mySingleton==null){//加锁，防多线程，造出多个实例
try {
Thread.sleep(3000);
mySingleton=new MySingleton();
}catch (Exception e){
e.printStackTrace();
}
}
};
}
return mySingleton;
}
}测试类：Demo.java
package com.xiangshuai.singleton;
/**
* @create 2019-01-09 22:28
*/
public class Demo {
public static void main(String[] args) {
new Thread() {
public void run() {
MySingleton mySingleton = MySingleton.getMySingleton();
System.out.println(mySingleton);
}
}.start();//开启线程
try {
Thread.sleep(3000);
MySinglenton mySingleton = MySingleton.getMySingleton();
System.out.println(mySingleton);
}catch (Exception e){
e.printStackTrace();
}
}
}
创建者模式（Builder）
MyBuilder.javapackage com.xiangshuai.builder;
/**
* @create 2019-01-10 22:12
* 、建造者模式（Builder）如果一个对象有很多字段，有一些是可选有一些是必选，可以考虑建造者模式来创建对象
*/
public class MyBuilder {
private String builderName;//必选参数
private String builderSex;//必选参数
private String age;//可选参数
private String sex;//可选参数
private String address;//可选参数
public MyBuilder(String builderName, String builderSex) {// 用必选参数做构造器
this.builderName = builderName;
this.builderSex = builderSex;
}
public MyBuilder setAge(String age) {//可选参数,返回对象
this.age = age;
return this;
}
public MyBuilder setSex(String sex) {//可选参数,返回对象
this.sex = sex;
return this;
}
public MyBuilder setAddress(String address) {//可选参数,返回对象
this.address = address;
return this;
}
@Override
public String toString() {
return "MyBuilder{" +
"builderName='" + builderName + '\'' +
", builderSex='" + builderSex + '\'' +
", age='" + age + '\'' +
", sex='" + sex + '\'' +
", address='" + address + '\'' +
'}';
}
}
测试类：Demo.java
package com.xiangshuai.builder;
/**
* @create 2019-01-10 22:18
*/
public class Demo {
public static void main(String[] args) {
MyBuilder myBuilder = new MyBuilder("小丫头", "女");
myBuilder.setAddress("山东");
System.out.println(myBuilder);
}
}
适配器模式：主要分为三类：类的适配器模式、对象的适配器模式、接口 的适配器模式。
01、类的适配器模式
package com.xiangshuai.adapter.classadapter;
/**
* @create 2019-01-12 14:51
* 类适配器模式：核心思想就是通 过适配器类Adapter 将这个类ClassAdapter的方法 扩展到接口Targetable中
*/
public class ClassAdapter {
public void method1(){
System.out.println("待扩展到接口的方法");
}
}
package com.xiangshuai.adapter.classadapter;
/**
* 待扩展的接口
* @create 2019-01-12 15:00
*/
public interface Tartable {
public void method1();
public void method2();
}
package com.xiangshuai.adapter.classadapter;
/**
* 适配器Adapter将类ClassAdapter 的method1方法扩展到Tartable接口中
* 应用场景: ：当希望将一个类转换成满足另一个新接口的类时，可以使用类的适配器模式，创建一个新类，继承原有的类，实现新的接口即可
* @create 2019-01-12 15:01
*/
public class Adapter extends ClassAdapter implements Tartable{
@Override
public void method2() {
System.out.println("接口的方法");
}
}
package com.xiangshuai.adapter.classadapter;
/**
* @create 2019-01-12 15:05
*/
public class Demo {
public static void main(String[] args) {
Tartable adapter = new Adapter();
adapter.method1();
adapter.method2();
}
}
02、对象的适配器模式
package com.xiangshuai.adapter.objectadapter;
/**
* 对象适配器模式：核心思想就是通 过适配器类Adapter 将这个类ObjectAdapter的方法 扩展到接口Targetable中，
* 不同与类适配器模式的是，这些并不事继承ObjectAdapter，而是持有bjectAdapter对象来扩展类ObjectAdapter的方法
* @create 2019-01-12 15:22
*/
public class ObjectAdapter {
public void method1(){
System.out.println("待扩展到接口的方法--对象适配器模式");
}
}
package com.xiangshuai.adapter.objectadapter;
/**
* 待扩展的类
* @create 2019-01-12 15:00
*/
public interface Tartable {
public void method1();
public void method2();
}
package com.xiangshuai.adapter.objectadapter;
/**
* 应用场景：：当希望将一个对象转换成满足另一个新接口的对象时，可以创建一个Wrapper类，实现这个接口
* 持有原类的一个实例，在Wrapper类的方法中，调用实例的方法就行
* @create 2019-01-12 15:32
*/
public class Adapter implements Tartable{
private ObjectAdapter objectAdapter;
public Adapter(ObjectAdapter objectAdapter) {
this.objectAdapter = objectAdapter;
}
@Override
public void method1() {
objectAdapter.method1();
}
@Override
public void method2() {
System.out.println("接口的方法--对象适配器模式");
}
}
package com.xiangshuai.adapter.objectadapter;
/**
* @author 刘期香
* @create 2019-01-12 15:36
*/
public class Demo {
public static void main(String[] args) {
Adapter adapter = new Adapter(new ObjectAdapter());
adapter.method1();
adapter.method2();
}
}
03、接口的适配器模式
package com.xiangshuai.adapter.interfaceadapter;
/**
* @create 2019-01-12 15:45
*/
public interface InterfaceAdapter {
public void method1();
public void method2();
}
package com.xiangshuai.adapter.interfaceadapter;
/**
* @author 刘期香
* @create 2019-01-12 15:46
*/
public abstract class Tarble implements InterfaceAdapter{
@Override
public void method1() {
}
@Override
public void method2() {
}
}
package com.xiangshuai.adapter.interfaceadapter;
/**
* @create 2019-01-12 15:48
*/
public class Adapter extends Tarble{
@Override
public void method1() {
System.out.println("如果我只用到这个method1，我就只实现这一个方法");
}
}
package com.xiangshuai.adapter.interfaceadapter;
/**
* @author 刘期香
* @create 2019-01-12 15:50
*/
public class Demo {
public static void main(String[] args) {
InterfaceAdapter adapter = new Adapter();
adapter.method1();
adapter.method2();
}
}
7、装饰模式（Decorator）
package com.xiangshuai.decorator;
/**
* Sourceable接口：装饰类和被装饰类均需实现的接口
* @create 2019-01-12 18:00
*/
public interface Sourceable {
public void method();
}
package com.xiangshuai.decorator;
/**
* 被装饰类： 实现和装饰类共同实现的接口
* @create 2019-01-12 18:03
*/
public class Source implements Sourceable{
@Override
public void method() {
System.out.println("目标方法");
}
}
package com.xiangshuai.decorator;
/**
* Decorator:装饰类 ,实现和装饰类共同实现的接口,
* 同时持有被装饰类对象，已便对被装饰类 目标方法进行加强
* 这里有点AOP的意思了
* 以后每次执行装饰类的方法 即执行了被装饰类加强的目标方法了
* @create 2019-01-12 18:02
*/
public class Decorator implements Sourceable{
private Source source;
public Decorator(Source source) {
this.source = source;
}
@Override
public void method() {
System.out.println("目标方法执行前执行的代码块");
source.method();
System.out.println("目标方法执行后执行的代码块");
}
}
package com.xiangshuai.decorator;
/**
* @author 刘期香
* @create 2019-01-12 18:13
*/
public class Demo {
public static void main(String[] args) {
Decorator decorator = new Decorator(new Source());
decorator.method();
}
}
10、桥接模式（Bridge）
package com.xiangshuai.bridge;
/**
* OracleDriver,MysqlDriver均需要实现的驱动接口
* @create 2019-01-12 18:56
*/
public interface Driver {
public String getConnention();
}
package com.xiangshuai.bridge;
/**
* mysql实现jdbc驱动
* @create 2019-01-12 20:12
*/
public class MysqlDriver implements Driver {
@Override
public String getConnention() {
return "mysql connection";
}
}
package com.xiangshuai.bridge;
/**
* oralce实现 jdbc驱动
* @create 2019-01-12 20:10
*/
public class OracleDriver implements Driver{
@Override
public String getConnention() {
return "oracle connection";
}
}
package com.xiangshuai.bridge;
/**
* Bridge 抽象类
* 定义一个抽象的桥接类 持有Driver接口实例 已实现抽象与实例Connection的连接
* 。桥接的用意是：将抽象化与实现化解耦，使得二者可以独立变化，
* 像我们常用的JDBC桥DriverManager一样，JDBC进行连接数据库的时候，在各个数据库之间进行切换，基本不需要动太多的代码，
* 甚至丝毫不用动，原因就是JDBC提供统一接口，每个数据库提供各自的实现，
* 用一个叫做数据库驱动的程序来桥接就行了
* @create 2019-01-12 20:22
*/
public abstract class DriverManager {
private Driver driver;
public Driver getDriver() {
return driver;
}
public void setDriver(Driver driver) {
this.driver = driver;
}
public String getConnection(){
return driver.getConnention();
}
}
package com.xiangshuai.bridge;
/**
* @create 2019-01-12 20:45
*/
public class MyDrvierManager1 extends DriverManager{
@Override
public String getConnection() {
return super.getConnection();
}
}
package com.xiangshuai.bridge;
/**
* @author 刘期香
* @create 2019-01-12 20:27
*/
public class Demo {
public static void main(String[] args) {
MyDrvierManager1 myDrvierManager1 = new MyDrvierManager1();
myDrvierManager1.setDriver(new MysqlDriver());
String connection = myDrvierManager1.getConnection();
System.out.println(connection);
}
}
组合模式
package com.xiangshuai.composite;
import java.util.Vector;
/**
* @create 2019-01-14 15:03
* 组合模式，组合模式有时又叫部分-整体模式在处理类似树形结构的问题时比较方便
*/
public class TreeNode {
private String name;
private TreeNode parent; // 此对象节点的父节点
private Vector<TreeNode> children; //此对象节点的子节点
public TreeNode(String name) {
this.name = name;
}
public String getName() {
return name;
}
public TreeNode getParent() {
return parent;
}
public void setParent(TreeNode parent) {
this.parent = parent;
}
public Vector<TreeNode> getChildren() {
return children;
}
public void setChildren(Vector<TreeNode> children) {
this.children = children;
}
@Override
public String toString() {
return "TreeNode{" +
"name='" + name + '\'' +
", children=" + children +
'}';
}
}
package com.xiangshuai.composite;
/**
* @create 2019-01-14 15:21
*/
public class Tree {
private String name;
private TreeNode root;
public Tree(String name) {
this.name = name;
}
public String getName() {
return name;
}
public TreeNode getRoot() {
return root;
}
public void setRoot(TreeNode root) {
this.root = root;
}
@Override
public String toString() {
return "Tree{" +
"name='" + name + '\'' +
", root=" + root +
'}';
}
}
package com.xiangshuai.composite;
import java.util.Vector;
/**
* @create 2019-01-14 15:23
*/
public class Demo {
//新建一个 中国 广东--广州，深圳，佛山，湖南-长沙，株洲，湘潭的树
public static void main(String[] args) {
//树根节点 -- 国
TreeNode zgTn=new TreeNode("中国");
Tree root = new Tree("中国");
root.setRoot(zgTn);
Vector<TreeNode> zgChildrens = new Vector<>();
zgTn.setChildren(zgChildrens);
//树父节点 -- 省
TreeNode gdTn = new TreeNode("广州");
TreeNode hlTn = new TreeNode("湖南");
Vector<TreeNode> gdChildrens = new Vector<>();
Vector<TreeNode> hlChildrens = new Vector<>();
gdTn.setParent(zgTn);
hlTn.setParent(zgTn);
zgChildrens.add(hlTn);
zgChildrens.add(gdTn);
//树子节点 -- 市
TreeNode gzTn = new TreeNode("广州");
TreeNode szTn = new TreeNode("深圳");
TreeNode fsTn = new TreeNode("佛山");
gzTn.setParent(gdTn);
szTn.setParent(gdTn);
fsTn.setParent(gdTn);
gdChildrens.add(gzTn);
gdChildrens.add(szTn);
gdChildrens.add(fsTn);
TreeNode csTn = new TreeNode("长沙");
TreeNode zzTn = new TreeNode("株洲");
TreeNode stTn = new TreeNode("湘潭");
csTn.setParent(hlTn);
zzTn.setParent(hlTn);
stTn.setParent(hlTn);
hlChildrens.add(csTn);
hlChildrens.add(zzTn);
hlChildrens.add(stTn);
System.out.println(root);
}
}
12、享元模式（Flyweight）
package com.xiangshuai.flyweight;
import java.sql.Connection;
import java.sql.DriverManager;
import java.util.Vector;
/**
* 享元模式的主要目的是实现对象的共享，即共享池，当系统中对象多的时候可以减少内存的开销，通常与工厂模式一起使用
* 最典型的引用，数据库连接池的创建 ，获取，回收Coonection连接
* @create 2019-01-15 21:47
*
*/
public class ConnectionPool {
private Vector<Connection> poll=null;
private String url="jdbc:mysql://localhost:3306/test";
private String username="root";
private String password="root-----";
private String driverClassName="com.mysql.jdbc.Driver";
private int poolSize=10;
/*初始化数据库连接池，里面放10个数据库连接*/
public ConnectionPool() {
poll=new Vector<Connection>(poolSize);
for(int i=0;i<poolSize;i++){
try {
Class.forName(driverClassName);
Connection conn = DriverManager.getConnection(url, username, password);
poll.add(conn);
} catch (Exception e) {
e.printStackTrace();
}
}
}
/*获取数据库连接*/
public synchronized Connection getConnection(){
Connection conn=poll.get(0);
poll.remove(conn);
return conn;
}
/*用完连接后归还于连接池*/
public synchronized void release(Connection conn){
poll.add(conn);
}
}
package com.xiangshuai.flyweight;
import java.sql.*;
/**
* @author
* @create 2019-01-19 18:25
*/
public class Demo {
public static void main(String[] args) {
ConnectionPool connectionPool = new ConnectionPool();
Connection conn = connectionPool.getConnection();
try {
PreparedStatement ps = conn.prepareStatement("select * from crm.base_dict limit ?,? ");
ps.setObject(1,0);
ps.setObject(2,5);
ResultSet resultSet = ps.executeQuery();
while(resultSet.next()){
String s1 = resultSet.getString(1);
String s2=resultSet.getString(2);
String s3=resultSet.getString(3);
System.out.println("s1="+s1+"--------"+"s2="+s2+"--------"+"s3="+s3+"--------");
}
} catch (SQLException e) {
e.printStackTrace();
}finally {
//用完后归还给连接池
connectionPool.release(conn);
}
}
}
父类与子类关系
13、策略模式（strategy）
package com.xiangshuai.strategy;
/**
* 策略模式定义了一系列算法，并将每个算法封装起来，
* 使他们可以相互替换，且算法的变化不会影响到使用算法的客户。
* 需要设计一个接口，为一系列实现类提供统一的方法，多个实现类实现该接口，设计一个抽象类（可有可无，属于辅助类）
* ，提供辅助函数
* 公用方法接口
* 动物类
* @create 2019-01-20 14:38
*/
public interface Animals {
public void eat();
}
package com.xiangshuai.strategy;
/**
* @create 2019-01-20 14:46
*
* 抽象类 抽象方法--辅助方法
*/
public abstract class PrAnimals {
public abstract void foot();
}
package com.xiangshuai.strategy;
/**
* @create 2019-01-20 14:50
*/
public class Person extends PrAnimals implements Animals {
@Override
public void eat() {
System.out.println("人类吃饭");
}
@Override
public void foot() {
System.out.println("人类用四条腿走路");
}
}
package com.xiangshuai.strategy;
/**
* @author 刘期香
* @create 2019-01-20 15:11
*/
public class Pig extends PrAnimals implements Animals {
@Override
public void eat() {
System.out.println("猪吃饭");
}
@Override
public void foot() {
System.out.println("猪四角走路");
}
}
package com.xiangshuai.strategy;
/**
* @create 2019-01-20 16:36
*/
public class Demo {
public static void main(String[] args) {
Person person = new Person();
person.eat();person.foot();
Pig pig = new Pig();
pig.eat();
pig.foot();
}
}
14、模板方法模式（Template Method）
package com.xiangshuai.abstractCalculator;
/**
* 解释一下模板方法模式，就是指：一个抽象类中，有一个主方法，再定义1...n个方法，可以是抽象的，
* 也可以是实际的方法，定义一个类，继承该抽象类，重写抽象方法，通过调用抽象类，实现对子类的调用
* @create 2019-01-21 21:31
*/
public abstract class AbstractCalculator {
/*主方法，实现本来对其他方法的调用*/
public final int mainMethod(String exp,String opt){
int[] iarr = split(exp, opt);
return this.calculate(iarr[0],iarr[1]);//此抽象类的实现类完成调用
}
public abstract int calculate(int num1,int num2);
public int[] split(String exp,String opt){
String[] arr = exp.split(opt);
int[] iarr=new int[2];
iarr[0]=Integer.parseInt(arr[0]);
iarr[1]=Integer.parseInt(arr[1]);
return iarr;
}
}
package com.xiangshuai.abstractCalculator;
/**
* 求和
* @create 2019-01-21 21:41
*/
public class Plus extends AbstractCalculator{
@Override
public int calculate(int num1, int num2) {
return num1+num2;
}
}
package com.xiangshuai.abstractCalculator;
/**
* @create 2019-01-21 21:45
*/
public class Demo {
public static void main(String[] args) {
AbstractCalculator ac=new Plus();
int calculate = ac.mainMethod("8,2", ",");
System.out.println(calculate);
}
}
15、观察者模式（Observer）
package com.xiangshuai.observer;
/**
* 包括这个模式在内的接下来的四个模式，都是类和类之间的关系，
* 不涉及到继承，学的时候应该 记得归纳，记得本文最开始的那个图。
* 观察者模式很好理解，类似于邮件订阅和RSS订阅，当我们浏览一些博客或wiki时，
* 经常会看到RSS图标，就这的意思是，当你订阅了该文章，如果后续有更新，会及时通知你。其实，
* 简单来讲就一句话：当一个对象变化时，其它依赖该对象的对象都会收到通知，并且随着变化！
* 对象之间是一种一对多的关系
* @create 2019-02-01 18:08
*/
public interface Observer {
public void update();
package com.xiangshuai.observer;
/**
* @create 2019-02-01 18:09
*/
public class Observer1 implements Observer{
@Override
public void update() {
System.out.println("被观察者对象1更新");
}
}
package com.xiangshuai.observer;
/**
* @create 2019-02-01 18:11
*/
public class Observer2 implements Observer{
@Override
public void update() {
System.out.println("被观察者对象2更新");
}
}
package com.xiangshuai.observer;
/**
*：MySubject类就是我们的主对象，Observer1和Observer2是依赖于MySubject的对象，
* 当MySubject变化时，Observer1和Observer2必然变化。AbstractSubject类中定义着需要监控的对象列表，
* 可以对其进行修改：增加或删除被监控对象，且当MySubject变化时，负责通知在列表内存在的对象
*/
public interface Subject {
/* 增加观察者 */
public void add(Observer observer);
/*删除观察者 */
public void del(Observer observer);
/* 通知所有的观察者 */
public void notifyObserver();
/* 自身的操作 */
public void operation();
}
package com.xiangshuai.observer;
import java.util.Enumeration;
import java.util.Vector;
/**
* @create 2019-02-01 18:14
*/
public class AbstractSubject implements Subject{
private Vector<Observer> vector=new Vector<Observer>();
@Override
public void add(Observer observer) {
vector.add(observer);
}
@Override
public void del(Observer observer) {
vector.remove(observer);
}
@Override
public void notifyObserver() {
Enumeration<Observer> elements = vector.elements();
while (elements.hasMoreElements()){
elements.nextElement().update();
}
}
@Override
public void operation() {
}
}
package com.xiangshuai.observer;
/**
* @create 2019-02-01 18:29
*/
public class MySubject extends AbstractSubject{
@Override
public void operation() {
System.out.println("update self");
notifyObserver();
}
}
package com.xiangshuai.observer;
/**
* @create 2019-02-01 18:31
*/
public class Demo {
public static void main(String[] args) {
MySubject mySubject = new MySubject();
mySubject.add(new Observer1());
mySubject.add(new Observer2());
mySubject.operation();
}
}
16、迭代子模式（Iterator）
顾名思义，迭代器模式就是顺序访问聚集中的对象，一般来说，集合中非常常见，如果对集合类比较熟悉的话，理解本模式会十分轻松。这句话包含两层意思：一是需要遍历的对象，即聚集对象，二是迭代器对象，用于对聚集对象进行遍历访问。
package com.xiangshuai.iterator;
/**
* @create 2019-02-03 13:13
*/
public interface Collection {
public void iterator();
/*获得集合中的第几个数据*/
public String get(int index);
/*集合的长度*/
public int size();
}
package com.xiangshuai.iterator;
/**
* @create 2019-02-03 13:13
*/
public interface Collection {
public void iterator();
/*获得集合中的第几个数据*/
public String get(int index);
/*集合的长度*/
public int size();
}
package com.xiangshuai.iterator;
/**
* @create 2019-02-03 13:28
*/
public class MyIterator implements Iterator {
Collection collection=null;
public int post=-1;
// 在初始化话MyIterator的时候对collection进行初始化
public MyIterator(Collection collection) {
post=0;
this.collection = collection;
}
@Override
public String previous() {
post--;
return collection.get(post-1);
}
@Override
public String next() {
if(hasNext()){
post++;
return collection.get(post-1);
}
return null;
}
@Override
public boolean hasNext() {
if(post>=collection.size()|| post==-1){
return false;
}
return true;
}
@Override
public String first() {
return collection.get(0);
}
}
package com.xiangshuai.iterator;
/**
* @create 2019-02-03 13:29
*/
public class MyCollection implements Collection{
String[] str={"A","B","C","D","E","F"};
@Override
public void iterator() {
}
@Override
public String get(int index) {
return str[index];
}
@Override
public int size() {
return str.length;
}
}
package com.xiangshuai.iterator;
/**
* @create 2019-02-03 14:03
*/
public class Demo {
public static void main(String[] args) {
MyIterator iter = new MyIterator(new MyCollection());
while (iter.hasNext()){
String next = iter.next();
System.out.println(next);
}
}
}
17、责任链模式（Chain of Responsibility）
package com.xiangshuai.chain;
/**
* @create 2019-02-03 19:04
*/
public interface Handler {
public void operation();
}
package com.xiangshuai.chain;
/**
* 接下来我们将要谈责任链模式，有多个对象每持一的引用这样就会形成条 接下来我们将要谈责任链模式，有多个对象每持一的引用这样就会形成条 接下来我们将要谈责任链模式，有多个对象每持一的引用这样就会形成条 接下来我们将要谈责任链模式，有多个对象每持一的引用这样就会形成条 接下来我们将要谈责任链模式，有多个对象每持一的引用这样就会形成条 * @create 2019-02-03 19:05
*/
public abstract class AbstractHandler {
protected Handler handler;
public Handler getHandler() {
return handler;
}
public void setHandler(Handler handler) {
this.handler = handler;
}
}
package com.xiangshuai.chain;
/**
* @create 2019-02-03 20:08
*/
public class MyHandler extends AbstractHandler implements Handler{
private String name;
public MyHandler(String name) {
this.name = name;
}
@Override
public void operation() {
System.out.println("处理器名字 "+name);
if(handler!=null){
getHandler().operation();
}
}
}
package com.xiangshuai.chain;
/**
* @create 2019-02-03 19:06
*/
public class Demo {
public static void main(String[] args) {
MyHandler h1 = new MyHandler("h1");
MyHandler h2 = new MyHandler("h2");
MyHandler h3 = new MyHandler("h3");
h1.setHandler(h2);
h2.setHandler(h3);
h1.operation();
}
}
18、命令模式（Command）
package com.xiangshuai.command;
/**
* 命令模式很好理解，举个例子，司令员下令让士兵去干件事情，从整个事情的角度来考虑，司令员的作用是，发出口令，口令经过传递，传到了士兵耳朵里，士兵去执行。这个过程好在，三者相互解耦，任何一方都不用去依赖其他人，只需要做好自己的事儿就行，司令员要的是结果，不会去关注到底士兵是怎么实现的
* @create 2019-02-03 20:39
*/
public class Invoke {
public Command command;
public Invoke(Command command) {
this.command = command;
}
public void action(){
command.exe();
};
}
package com.xiangshuai.command;
/**
* @create 2019-02-03 20:40
*/
public interface Command {
public void exe();
}
package com.xiangshuai.command;
/**
* @create 2019-02-03 20:42
*/
public class MyCommand implements Command {
public Receiver receiver;
public Receiver getReceiver() {
return receiver;
}
public void setReceiver(Receiver receiver) {
this.receiver = receiver;
}
@Override
public void exe() {
receiver.action();
}
}
package com.xiangshuai.command;
/**
* @create 2019-02-03 20:44
*/
public class Receiver {
public String name;
public Receiver(String name) {
this.name = name;
}
public void action(){
System.out.println("士兵 "+name+"执行命令");
}
}
package com.xiangshuai.command;
/**
* @create 2019-02-03 20:50
*/
public class Demo {
public static void main(String[] args) {
Receiver hml = new Receiver("花木兰");
MyCommand myCommand = new MyCommand();
myCommand.setReceiver(hml);
Invoke invoke = new Invoke(myCommand);
invoke.action();
}
}
19、备忘录模式（Memento）
package com.xiangshuai.original;
/**
* @create 2019-02-04 14:54
* @param value:一个要恢复的对象状态，Memento:备忘类
*/
public class Original {
private String value;
public Original(String value) {
this.value = value;
}
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
public Memento createMemento(){
return new Memento(value);
}
}
package com.xiangshuai.original;
/**
* 主要目的是保存一个对象的某个状态，以便在适当的时候恢复对象
* @create 2019-02-04 14:54
*/
public class Memento {
private String value;
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
public Memento(String value) {
this.value = value;
}
}
package com.xiangshuai.original;
/**
* @create 2019-02-04 14:58
*/
public class Storage {
private Memento memento;
public Memento getMemento() {
return memento;
}
public void setMemento(Memento memento) {
this.memento = memento;
}
}
package com.xiangshuai.original;
/**
* @create 2019-02-04 14:59
*/
public class Demo {
public static void main(String[] args) {
Original original = new Original("原始类1");
Memento memento = original.createMemento();
Storage storage = new Storage();
storage.setMemento(memento);
System.out.println(original.getValue());
original.setValue("被修改后的原始类");
System.out.println(original.getValue());
original.setValue(memento.getValue());
System.out.println(original.getValue());
}
}
20、状态模式（State）
package com.xiangshuai.state;
/**
* @create 2019-02-05 16:00
*/
public class State {
private String value;
public String getValue() {
return value;
}
public State(String value) {
this.value = value;
}
public void method1(){
System.out.println("状态1执行的方法");
}
public void method2(){
System.out.println("状态2执行的方法");
}
}
package com.xiangshuai.state;
/**
* 核心思想就是：当对象的状态改变时，同时改变其行为，很好理解！就拿QQ来说，有几种状态，在线、隐身、忙碌等，每个状态对应不同的操作，而且你的好友也能看到你的状态，
* 所以，状态模式就两点：1、可以通过改变状态来获得不同的行为。2、你的好友能同时看到你的变化。
* @create 2019-02-05 16:07
*/
public class Context {
private State state;
public State getState() {
return state;
}
public Context(State state) {
this.state = state;
}
public void method(){
if("1".equals(state.getValue())){
state.method1();
}else if("2".equals(state.getValue())){
state.method1();
}else{
System.out.println("无此状态");
}
}
}
package com.xiangshuai.state;
/**
* @author 刘期香
* @create 2019-02-05 16:10
*/
public class Demo {
public static void main(String[] args) {
Context context = new Context(new State("1"));
context.method();
}
}
21、访问者模式（Visitor）
package com.xiangshuai.visitor;
/**
* 访问者模式把数据结构和作用于结构上的操作解耦合，使得操作集合可相对自由地演化。访问者模式适用于数据结构相对稳定算法又易变化的系统。
* 因为访问者模式使得算法操作增加变得容易。若系统数据结构对象易于变化，经常有新的数据对象增加进来，则不适合使用访问者模式。
* 访问者模式的优点是增加操作很容易，因为增加操作意味着增加新的访问者。访问者模式将有关行为集中到一个访问者对象中，其改变不影响系统数据结构。
* 其缺点就是增加新的数据结构很困难。—— From 百科
* 简单来说，访问者模式就是一种分离对象数据结构与行为的方法，通过这种分离，可达到为一个被访问者动态添加新的操作而无需做其它的修改的效果
* @create 2019-02-05 17:12
*/
public interface Visitor {
public void visit(Subject subject);
}
package com.xiangshuai.visitor;
/**
* @create 2019-02-05 17:11
*/
public interface Subject {
public void accept(Visitor visitor);
public String getSubject();
}
package com.xiangshuai.visitor;
/**
* @create 2019-02-05 17:25
*/
public class MySubject implements Subject {
@Override
public void accept(Visitor visitor) {
visitor.visit(this);
}
@Override
public String getSubject() {
return "xiaoming";
}
}
package com.xiangshuai.visitor;
/**
* @create 2019-02-05 17:28
*/
public class MyVisitor implements Visitor {
@Override
public void visit(Subject subject) {
System.out.println("visit the subject: "+subject.getSubject());
}
}
package com.xiangshuai.visitor;
/**
* @create 2019-02-05 17:33
*/
public class Demo {
public static void main(String[] args) {
Subject subject = new MySubject();
Visitor visitor = new MyVisitor();
subject.accept(visitor);
}
}
22、中介者模式（Mediator）
package com.xiangshuai.mediator;
/**
* 两个类互相依赖，不利于维护和扩展，可用中介者模式
* 如 租房者和房东，那么可创一中介类Mediator,两类均持有中介对象即可
*
*
* 中介者模式也是用来降低类类之间的耦合的，因为如果类类之间有依赖关系的话，
* 不利于功能的拓展和维护，因为只要修改一个对象，其它关联的对象都得进行修改。
* 如果使用中介者模式，只需关心和Mediator类的关系，
* 具体类类之间的关系及调度交给Mediator就行，这有点像spring容器的作用
* @create 2019-02-05 18:54
*/
public abstract class User {
protected Mediator mediator;
public abstract void work();
public User(Mediator mediator) {
this.mediator = mediator;
}
}
package com.xiangshuai.mediator;
/**
* @author 房东
* @create 2019-02-05 19:43
*/
public class User1 extends User{
@Override
public void work() {
System.out.println("房东进行出租");
}
public User1(Mediator mediator) {
super(mediator);
}
}
package com.xiangshuai.mediator;
/**
* @create 2019-02-05 19:45
*/
public class User2 extends User {
@Override
public void work() {
System.out.println("租房者进行租房");
}
public User2(Mediator mediator) {
super(mediator);
}
}
package com.xiangshuai.mediator;
/**
* @create 2019-02-05 19:02
*/
public interface Mediator {
public void createMediator();//创建User--租客与房东对象
public void workAll(); // 执行租客的 work方法--租房 和房东的 work方法--出租
}
package com.xiangshuai.mediator;
/**
* @create 2019-02-05 19:46
*/
public class MyMediator implements Mediator {
private User user1;
private User user2;
@Override
public void createMediator() {
user1=new User1(this);
user2=new User2(this);
}
@Override
public void workAll() {
user1.work();
user2.work();
}
}
package com.xiangshuai.mediator;
/**
* @create 2019-02-05 19:47
*/
public class Demo {
public static void main(String[] args) {
MyMediator myMediator = new MyMediator();
myMediator.createMediator();
myMediator.workAll();
}
}
23、解释器模式（Interpreter）
package com.xiangshuai.interpreter;
/**
* 一般用再OOP开发中的编译器的开发中，所以适用面比较窄，
* Context类是一个上下文环境类，Plus和Minus分别是用来计算的实现
* @create 2019-02-05 20:05
*/
public interface Expression {
public int interpret(Context context);
}
package com.xiangshuai.interpreter;
/**
* 加法
* @create 2019-02-05 20:10
*/
public class Plus implements Expression{
@Override
public int interpret(Context context) {
return context.getNum1()+context.getNum2();
}
}
package com.xiangshuai.interpreter;
/**
* @author 减法
* @create 2019-02-05 20:15
*/
public class Minus implements Expression {
@Override
public int interpret(Context context) {
return context.getNum1()-context.getNum2();
}
}
package com.xiangshuai.interpreter;
/**
* 环境
* @create 2019-02-05 20:07
*/
public class Context {
private int num1;
private int num2;
public Context(int num1, int num2) {
this.num1 = num1;
this.num2 = num2;
}
public int getNum1() {
return num1;
}
public int getNum2() {
return num2;
}
}
package com.xiangshuai.interpreter;
/**
* @create 2019-02-05 20:16
* 计算 9+1-8的值
*/
public class Demo {
public static void main(String[] args) {
int interpret = new Minus().interpret(new Context(new Plus().interpret(new Context(9, 1)), 8));
System.out.println(interpret);
}
}