设计模式

设计模式是对软件设计中普遍存在的各种问题所提出的 解决方案。换句话说设计模式是一套被反复使用、多数人知晓的、经过分类的、代码设计的 经验的总结。使用设计模式是为了可重用代码，让代码更容易被他人理解，保证代码可靠性。

设计模式的原则：1、开闭原则：对扩展开放，对修改封闭。在程序需要进行扩展的时候，不能去修改或影响原有的代码，实现一个热插拔的效果。简言之，是为了使程序的扩展性更好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类。

2、里氏代换原则（Liskov Substitution Principle）：里氏代换原则中任何基类可以出现的地方，子类一定可以出现。里氏代换原则是继承复用的基石，只有当子类可以替换掉基类，且软件单位的功能不受到影响时，基类才能真正被复用，而且子类也能够在基类的基础上增加新的行为。里氏代换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化，而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。

3、依赖倒转原则（Dependence Inversion Principle）：这个原则是开闭原则的基础，核心内容：针对接口编程，高层模块不应该依赖底层模块，二者都应该依赖抽象而不依赖于具体。

4、接口隔离原则（Interface Segregation Principle）：使用多个隔离的接口，比使用单个庞大的接口要好。其目的在于降低耦合度。其实设计模式就是从大型软件架构出发，便于升级和维护软件的设计思想。它强调低依赖、低耦合。

5、单一职责原则（Single Responsibility Principle）：类的职责要单一，不能将太多的职责放在一个类中。可能有的人会觉得单一职责原则和前面的接口隔离原则很相似，其实不然。其一，单一职责原则原注重的是职责；而接口隔离原则注重对接口依赖的隔离。其二，单一职责原则主要约束的是类，其次才是接口和方法，它针对的是程序中的实现和细节；而接口隔离原则主要约束接口，主要针对抽象，针对程序整体框架的构建。

6、最少知道原则（Demeter Principle）：也叫迪米特法则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。一个对象应该对其他对象保持最少的了解。类与类之间的关系越密切，耦合度越大，当一个类发生改变时，对另一个类的影响也越大。如果两个类不必彼此直接通信，那么这两个类就不应当发生直接的相互作用。如果其中一个类需要调用另一个类的某一个方法的话，可以通过第三者转发这个调用。所以在类的设计上，每一个类都应当尽量降低成员的访问权限。

7、合成复用原则（Composite Reuse Principle）：就是在一个新的对象里通过关联关系（组合关系、聚合关系）来使用一些已有的对象，使之成为新对象的一部分；新对象通过委派调用已有对象的方法达到复用功能的目的。简而言之，尽量多使用 组合/聚合 的方式，尽量少使用甚至不使用继承关系。

常用设计模式分为三大类：

创建型模式，共5种：工厂模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共7种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共11种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

1、工厂模式：对象的设计过程中，工厂通常是一个用来创建其他对象的对象，工厂模式根据不同的参数来实现不同的分配方案和创建对象。工厂3兄弟之：（1）普通工厂，（2）静态工厂方法，（3）抽象工厂方法

package factory;
 interface Humam{
	public void eat();
	public void sleep();
	public void beat();
}
 class Male implements Humam{
	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("male can eat");
	}
	@Override
	public void sleep() {
		// TODO Auto-generated method stub
		System.out.println("male can sleep");
	}
	@Override
	public void beat() {
		// TODO Auto-generated method stub
		System.out.println("male can beat");
	} 
 }
 class Fmale implements Humam{
	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("Fmale can eat");
	}
	@Override
	public void sleep() {
		// TODO Auto-generated method stub
		System.out.println("Fmale can sleep");
	}
	@Override
	public void beat() {
		// TODO Auto-generated method stub
		System.out.println("Fmale can beat");
	} 
 }
 class HumanFactory{
	 //简单工厂模式
	 Humam crateHuman(String gender) {
		 if(gender.equals("male")) {
			 return new Male();
		 }else if(gender.equals("fmale")) {
			 return new Fmale();
		 }else {
			 System.out.println("请输入正确的性别");
		return null;
		 }
	 }
	 //多工厂模式
	 public  Male ceatemale(){
		 return new Male();
	 }
	 public  Fmale ceateFmale(){
		 return new Fmale();
	 }
	 //静态工厂模式
	/* public static Male ceatemale(){
		 return new Male();
	 }
	 public static Fmale ceateFmale(){
		 return new Fmale();
	 }*/
 }
public class Factory {
public static void main(String[] args) {
	HumanFactory factory=new HumanFactory();
	Humam male=factory.crateHuman("male");
	male.beat();
	male.eat();
	male.sleep();
	//多工厂模式
	/*HumanFactory factory=new HumanFactory();
	Humam male=factory.cratemale();
	male.beat();
	male.eat();
	male.sleep();*/
	//静态工厂模式
	/* 
	Humam male=HumanFactory.cratemale();
	male.beat();
	male.eat();
	male.sleep();*/
}
}

普通工厂模式如果传入字符有误不能正确创建对象，静态工厂不需要实例化工厂类，所以一般使用静态工厂方法。java库里根据不同参数getInstance()方法返回不同的calendar对象。

抽象工厂模式：是一种软件开发设计的模式。他提供了一种方式可以将一组具有同一主题的单独工厂封装起来，抽象工厂是一个父类工厂是工厂的工厂。产品等级结构：比如一个抽象类是食物，其子类有苹果、牛奶等等，则抽象食物与具体食物名称之间构成了一个产品等级结构。食物是抽象的父类，而具体的食物名称是其子类。

产品族：在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品。如AKitchen 生产的苹果、刀子，苹果属于食物产品等级结构中，而刀子则属于餐具产品等级结构中。而 BKitchen 可能生成另一组产品，如牛奶、杯子。因此工厂方法模式、抽象工厂模式最大的区别在于：工厂方法模式：针对的是 一个产品等级结构。抽象工厂模式：针对 多个产品等级结构。

interface Food {// 抽象食物
    public String getFoodName();
}
interface TableWare {// 抽象餐具
    public String getToolName();
}
interface KitchenFactory {// 抽象工厂
    public Food getFood();
    public TableWare getTableWare();
}
class Apple implements Food{//具体食物 Apple
    public String getFoodName() {
        return "apple";
    }
}
class Knife implements TableWare { //具体餐具 Knife 
    public String getToolName() {
        return "knife";
    }
}
class AKitchen implements KitchenFactory {// 以具体工厂 AKitchen 为例
    public Food getFood() {
       return new Apple();
    }

    public TableWare getTableWare() {
       return new Knife();
    }
}
public class Foodaholic {// 搭配
    public void eat(KitchenFactory k) {
       System.out.println("A foodaholic is eating "+ k.getFood().getFoodName()
              + " with " + k.getTableWare().getToolName() );
    }
    public static void main(String[] args) {
       Foodaholic fh = new Foodaholic();
       KitchenFactory kf = new AKitchen();
       fh.eat(kf);
    }
}

2、适配器模式（电器接口的转换）

public interface CnPluginInterface {// 国标插头
    void chargeWith2Pins();
}
// 实现国标插座的充电方法
public class CnPlugin implements CnPluginInterface {
    public void chargeWith2Pins() {
        System.out.println("charge with CnPlugin");
    }
}
// 在国内家中充电
public class Home {
    private CnPluginInterface cnPlugin;
    public Home() { }
    public Home(CnPluginInterface cnPlugin) {
        this.cnPlugin = cnPlugin;
    }
    public void setPlugin(CnPluginInterface cnPlugin) {
        this.cnPlugin = cnPlugin;
    }
    // 充电
    public void charge() {
        // 国标充电
        cnPlugin.chargeWith2Pins();
    }
}
// 国标测试类
public class CnTest {
    public static void main(String[] args) {
        CnPluginInterface cnPlugin = new CnPlugin();
        Home home = new Home(cnPlugin);
        // 会输出 “charge with CnPlugin”
        home.charge();
    }
}

1、适配器必须实现原有的旧的接口的。2、适配器对象中持有新接口的引用，当调用旧的接口委托实现新接口对象来处理，即适配器对象中组合了一个新接口。

public interface EnPluginInterface {// 英标插头
    void chargeWith3Pins();
}
// 实现英标插座的充电方法
public class EnPlugin implements EnPluginInterface {
    public void chargeWith3Pins() {
        System.out.println("charge with EnPlugin");
    }
}
//适配器
public class PluginAdapter implements CnPluginInterface {
     private EnPluginInterface enPlugin;
     public PluginAdapter(EnPluginInterface enPlugin) {
         this.enPlugin = enPlugin;
 }
 // 这是重点，适配器实现了英标的插头，然后重载国标的充电方法为英标的方法
 @Override
public void chargeWith2Pins() {
    enPlugin.chargeWith3Pins();
     }
}

// 适配器测试类
public class AdapterTest {
    public static void main(String[] args) {
        EnPluginInterface enPlugin = new EnPlugin();
        Home home = new Home();
        PluginAdapter pluginAdapter = new PluginAdapter(enPlugin);
        home.setPlugin(pluginAdapter);
        // 会输出 “charge with EnPlugin”
        home.charge();
    }
}

3、装饰着模式：动态的把职责附加到已有对象上去，实现功能扩展。（各国特色女孩）

public abstract class Girl {// 抽象类 Girl
    String description = "no particular";
    public String getDescription(){
        return description;
    }
}
// 美国女孩
public class AmericanGirl extends Girl {
    public AmericanGirl() {
        description = "+AmericanGirl";
    }
}
// 国产妹子
public class ChineseGirl extends Girl {
    public ChineseGirl() {
        description = "+ChineseGirl";
    }
}
// 装饰者
public abstract class GirlDecorator extends Girl {
    public abstract String getDescription();
}
// 给美国女孩加上金发
public class GoldenHair extends GirlDecorator {
    private Girl girl;
    public GoldenHair(Girl g) {
        girl = g;
    }
    @Override
    public String getDescription() {
        return girl.getDescription() + "+with golden hair";
    }
}
// 加上身材高大的特性
public class Tall extends GirlDecorator {
    private Girl girl;
    public Tall(Girl g) {
        girl = g;
    }
    @Override
    public String getDescription() {
        return girl.getDescription() + "+is very tall";
    }
}
// 检验一下
public class Test {
    public static void main(String[] args) {
        Girl g1 = new AmericanGirl();
        System.out.println(g1.getDescription());
        GoldenHair g2 = new GoldenHair(g1);
        System.out.println(g2.getDescription());
        Tall g3 = new Tall(g2);
        System.out.println(g3.getDescription());
        // Girl g = new Tall(new GoldenHair(new AmericanGirl())); 
    }
}

Java IO类中有一个经典的对象添加功能，BufferReader装饰了InputStreamReader。

BufferedReader input = new BufferedReader(newInputStreamReader(System.in));InputStreamReader(InputStream in) - InputSteamReader 读取bytes字节内容，然后转换成 characters 流输出。BufferedReader(Reader in) - 从characters 流中读取内容并缓存。关于装饰者和适配器模式的区别：在增加新职责方面：适配器也可以增加新职责但是主要目的不在此，装饰者主要目的就是给被装饰者添加新职责。适配器模式使用新街口调用原接口，装饰者使用原接口。适配器知道被适配者的详细情况，而装饰者只知道其接口是什么至于具体类型只有在运行期间才知道。

4、观察者模式：也可称为模式-视图模式，源-监听者模式。由一个目标对象管理所有依赖于他观察者的对象（在线等更新）

public interface Subject {// Subject 主题接口
    public void registerObserver(Observer o);
    public void removeObserver(Observer o);
    public void notifyAllObservers();
}
// 观察者接口
public interface Observer {
    public void update(Subject s);
}
// 视频网站某狐 实现 Subject 接口
public class VideoSite implements Subject{
    // 观察者列表 以及 更新了的视频列表
    private ArrayList userList;
    private ArrayList videos;
    public VideoSite(){
        userList = new ArrayList();
        videos = new ArrayList();
    }
    @Override
    public void registerObserver(Observer o) {
        userList.add(o);
    }
    @Override
    public void removeObserver(Observer o) {
        userList.remove(o);
    }
    @Override
    public void notifyAllObservers() {
        for (Observer o: userList) {
            o.update(this);
        }
    }
    public void addVideos(String video) {
        this.videos.add(video);
        notifyAllObservers();
    }
    public ArrayList getVideos() {
        return videos;
    }
    public String toString(){
        return videos.toString();
    }
}
// 实现观察者，即看视频的美剧迷们
public class VideoFans implements Observer {
    private String name;
    public VideoFans(String name){
        this.name = name;
    }
    @Override
    public void update(Subject s) {
        System.out.println(this.name + ", new videos are available! ");
        // print video list
        System.out.println(s);
    }
}
public class Main {
    public static void main(String[] args) {
        VideoSite vs = new VideoSite();
        vs.registerObserver(new VideoFans("LiLei"));
        vs.registerObserver(new VideoFans("HanMeimei"));
        vs.registerObserver(new VideoFans("XiaoMing"));
        // add videos
        vs.addVideos("Video 1");
        //vs.addVideos("Video 2");
    }
}

在java中的体现就是java中的各种listener，按键添加事件完成指定动作。

5、单例模式：实例化的对象只有一个，为了达到节约或者控制系统资源的目的。

1）饿汉模式：一上来就创建一个实例，缺点就是不管有没有调用创建实例的方法都会新建一个实例。

public class Wife {// 饿汉模式
    // 一开始就新建一个实例
    private static final Wife wife = new Wife();
    // 默认构造方法
    private Wife() {}
    // 获得实例的方法
    public static Wife getWife() {
        return wife;
    }
}

2、懒汉模式：需要时再创建，先判断是否为空如果为空就会创建一个新的实例。

public class Wife {
    //一开始没有新建实例
    private static Wife wife;
    private Wife() { }
    // 需要时再新建
    public static Wife getWife() {
        if (wife == null) {
            wife = new Wife();
        }
        return wife;
    }
}

3、懒汉模式在多线程调用时会创建多个实例，所以创建线程安全的懒汉模式。设置线程同步：

public class Wife {
    private static Wife wife;
    private Wife() { }
    // 添加了 synchronized 关键字
    public static synchronized Wife getWife() {
        if (wife == null) {
            wife = new Wife();
        }
        return wife;
    }
    /*双重锁的 getWife() 方法
    public static Wife getWife() {
     // 第一个检验锁，如果不为空直接返回实例对象，为空才进入下一步
     if (wife == null) {
         synchronized (Wife.class) {
             //第二个检验锁，因为可能有多个线程进入到 if 语句内
             if (wife == null) {
                 wife = new Wife();
             }
         }
     }
     return wife ;
    }*/
}

线程同步作用保证同一时刻最多只有一个线程运行，但效率不高每次调用getWife()都要进行同步，如果有实例就不需要同步了。可以对getwife方法进行双重锁。但是wife=new wife（）实际上不是一个原子性操作大致可以分为3件事1、给wife实例分配内存单元，2、初始化wife的构造器，3、将wife对象指向对象的分配内存空间。多线程执行中如果线程切换恰好后来的线程拿走了还没有确定指向内存地址的对象就使用就会报错，所以给实例加上一个volatile关键字防止编译器自行优化代码。但volatile关键字在某些老版本的JDK无法正常工作，可以改用静态内部类的方式，利用JVM自身的机制保证线程安全

public class Wife {
    private static class WifeHolder {
        private static final Wife wife = new Wife();
    }
    private Wife() { }
    public static Wife getWife() {
        return WifeHolder.wife;
    }
}