3、设计模式—单例、工厂、代理、适配器、观察者

1、  设计模式——单例模式

单例模式负责创建自己的对象，同时确保只有一个对象被创建。

比如，我们要统计网站的访问用户数，在任何时候都只有一个对象在记录用户数，否则就可能出现重复写入的问题，这是单例模式应用的一个场景

实现如下

class Person{
    //私有构造函数，组织对象实例化，从而阻止创建多个对象
    private Person(){}
    //私有对象变量
    privatestatic Person p;
    //在main函数执行前执行，产生一个实例对象
    static{
        p =new Person();
    }
    //获取单例对象
    publicstatic Person getPerson(){
        if(p ==null){
            p =new Person();
        }
        System.out.println("get single person object");
        return p;
    }
}
 
publicclass hello{
    publicstaticvoid main(String args[]){
        //获取单例对象，并比较是否是同一个对象
        Person p1 = Person.getPerson();
        Person p2 = Person.getPerson();
        if(p1 == p2){
            System.out.println("is the same object");
        }else{
            System.out.println("is not the same object");
        }
        
    }
}

2、  设计模式——工厂模式

首先看下面代码，Apple和Orange实现了Fruit接口，程序要调用Apple的eat方法的话，要先在代码中显示的实例化Apple类，才能调用

现在的问题是，如果我想要调用Orange的方法呢，这时就需要修改程序代码才能实现调用，这会非常麻烦，因为程序已经发布出去，你必须修改代码，再从新部署等等

interface Fruit{
    publicvoid eat();
}
class Apple implements Fruit{
    publicvoid eat(){
        System.out.println("apple has been eat");
    }
}
class Orange implements Fruit{
    publicvoid eat(){
        System.out.println("orange has been eat");
    }
}
 
publicclass hello{
    publicstaticvoid main(String args[]){
        Fruit fruit =new Apple();
        fruit.eat();
    }
}

那有没有什么更简单的方法呢？有，通过工厂模式，我们可以由类名来自动生成类的实例，再通过接口来调用实例中的方法即可。这样如果我们要调用其它的类对象的方法，通过传递不同的类名作为参数就可以了，是不是简单了很多，因为不要修改代码，也不需要重新部署等等，如下

interface Fruit{
    publicvoid eat();
}
class Apple implements Fruit{
    publicvoid eat(){
        System.out.println("apple has been eat");
    }
}
class Orange implements Fruit{
    publicvoid eat(){
        System.out.println("orange has been eat");
    }
}
class Factory{
    static Fruit getInstance(String className){
        if("Apple".equals(className)){
            returnnew Apple();
        }
        elseif("Orange".equals(className)){
            returnnew Orange();
        }
        else{
            returnnull;
        }
    }
}
 
publicclass hello{
    publicstaticvoid main(String args[]){
        Fruit fruit = Factory.getInstance("Orange");
        fruit.eat();
    }
}

3、  设计模式——代理模式

所谓代理模式，是指客户端不直接调用实际的对象，而是通过调用代理对象来间接的调用实际的对象。

比如我要打官司，实际是我在打官司，但是现实中会通过律师来代理我来打官司，因为律师可以为我完成我不会或者无法完成的一些操作，比如填写诉状、起诉等操作

//起诉人接口
interface Plaintiff{
    publicvoid sue();
}
//我是起诉人，要起诉xxx
class Me implements Plaintiff{
    publicvoid sue(){
        System.out.println("i will sue xxx");
    }
}
//代理律师，起诉人通过代理律师来起诉，并且由代理律师填写起诉书
class ProxyLayer implements Plaintiff{
    private Plaintiff p;
    //代理律师接受某起诉人的委托
    public ProxyLayer(Plaintiff p){
        this.p = p;
    }
    //律师填写起诉书
    publicvoid fillPlaint(){
        System.out.println("the layer filled the plaint");
    }
    //代为起诉
    publicvoid sue(){
        this.fillPlaint();  //填写起诉书
        this.p.sue();   //代起诉人起诉
    }
}
 
publicclass hello{
    publicstaticvoid main(String args[]){
        //我，委托代理律师
        Plaintiff p =new ProxyLayer(new Me());
        //进行起诉操作
        p.sue();
    }
}

4、  设计模式——适配器模式

如果一个类要实现一个接口，则必须实现这个接口的所有方法，但是有时候一个接口定义了非常多的方法，而要实现的类又没必要实现这么多方法的时候怎么办呢？

这时候就可以使用适配器模式，通过适配器，我们可以将复杂的接口转换成适合当前类的接口。

通过一个抽象类abstruct，先实现接口所有的方法（方法的实现为空），再由类来覆写这个抽象类，这样就实现了接口和类的适配

//汽车接口，有三个方法
interface Car{
    publicvoid run();
    publicvoid addOil();
    publicvoid carry();
}
//汽车接口适配器，实现了所有的汽车接口
abstractclass CarAdapter implements Car{
    publicvoid run(){}
    publicvoid addOil(){}
    publicvoid carry(){}
}
//跑车没有运载功能，通过适配器实现了对car接口的实现
class SportsCar extends CarAdapter{
    publicvoid run(){
        System.out.println("my car is running");
    }
    publicvoid addOil(){
        System.out.println("my car is adding oil");
    }
}
 
publicclass hello{
    publicstaticvoid main(String args[]){
        //实现了car接口的SportCar
        Car c =new SportsCar();
        c.run();
        c.addOil();
    }
}

5、  设计模式——观察者模式

通过观察者模式，我们可以监控被观察对象的变化，达到及时监督的目的。

import java.util.Observable;
import java.util.Observer;
 
//房屋（被观察对象），需继承Obserable类
class House extends Observable{
    privatefloat price;
    public House(float price){this.price = price;}
    publicfloat getPrice(){returnthis.price;}
    publicvoid setPrice(float price){
        //设置观察点
        super.setChanged();
        //通知观察者
        super.notifyObservers(price);
        this.price = price;
    }
    public String toString(){
        return"house's price is "+this.price;
    }
}
 
//观察者，需实现Observer接口，接口中只有update方法需要实现
class HouseObserver implements Observer{
    private String name;
    public HouseObserver(String name){this.name = name;}
    //观察者观察到的对象，和观察到的改变了的参数
    publicvoid update(Observable obj, Object arg){
        if(arg instanceofFloat){
            System.out.println(this.name +" observ the price changed to : "+(float)arg);
        }
    }
}
 
publicclass hello{
    publicstaticvoid main(String args[])throws Exception{
        //观察对象
        House house =new House(10000);
        //三个观察者
        HouseObserver ho1 =new HouseObserver("kaka");
        HouseObserver ho2 =new HouseObserver("fedy");
        HouseObserver ho3 =new HouseObserver("tony");
        //观察者关注观察对象
        house.addObserver(ho1);
        house.addObserver(ho2);
        house.addObserver(ho3);
        //输出房屋价格，修改房屋价格，输出修改后的服务价格
        //查看观察者是否观察到房屋价格的变化
        System.out.println(house);
        house.setPrice(12888);
        System.out.println(house);
    }
}