Java中的几个基本设计模式

1.单例模式

就是在整个应用中保证只有一个类的实例存在。单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

单例模式分为懒汉式单例和恶汉式单例。

//懒汉式
public class SingleInstance {
    public double d = Math.random();

    private static SingleInstance single = null;

    //私有化构造器：其他类不能创建此类的对象
    private SingleInstance() {

    }

    //静态工厂，用来生产对象的
    public static SingleInstance getInstance() {
        if (single == null) {
            single = new SingleInstance();
        }

        return single;
    }
}


class Test {
    public static void main(String[] args) {
        SingleInstance s1 = SingleInstance.getInstance();
        SingleInstance s2 = SingleInstance.getInstance();
        System.out.println(s1.d);
        System.out.println(s2.d);
    }
}

//饿汉式
public class SingleInstance {
    public double d = Math.random();

    private static SingleInstance single = new SingleInstance();

    //私有化构造器：其他类不能创建此类的对象
    private SingleInstance() {

    }

    //静态工厂，用来生产对象的
    public static SingleInstance getInstance() {

        return single;
    }
}

2.工厂模式

一抽象产品类派生出多个具体产品类；一抽象工厂类派生出多个具体工厂类；每个具体工厂类只能创建一个具体产品类的实例。
一个工厂类处于对产品类实例化调用的中心位置上，它决定哪一个产品应当被实例化，也就是说由工厂类来决定实例化哪一个具体产品类的对象
工厂模式是根据不同的参数得到不同的对象，用工厂方法代替new操作的一种模式，可带来更大的扩展性和尽量少的修改量。

//抽象产品类
public abstract class Car {
    public abstract void drive();
}

//具体产品类：大众车
class DazhongCar extends Car{

    @Override
    public void drive() {
        System.out.println("DazhongCar");
    }
}

//具体产品类：BMW
class BMW extends Car {

    @Override
    public void drive() {
        System.out.println("BMW");
    }
}

//具体产品类：QQCar
class QQCar extends Car {

    @Override
    public void drive() {
        System.out.println("QQCar");
    }
}

//工厂：根据用户的需求具体生产某一个产品
public class Factory {
    public static Car getCar(String s) {
        Car car = null;

        if (s.equals("dazhong")) {
            car = new DazhongCar();//生产大众车的
        } else if(s.equals("bmw")) {
            car = new BMW();//生产宝马车的
        } else if(s.equals("QQ")) {
            car = new QQCar();//生产QQ车
        }

        return car;//返回一个具体的车
    }
}

//测试类
public class Test {

    public static void main(String[] args) {
        Car car = Factory.getCar("QQ");//通过名称从工厂中得到车对象
        car.drive();

        Car car2 = Factory.getCar("bmw");
        car2.drive();
    }
}

3.代理模式

为其他对象提供一种代理以控制对这个对象的访问
在某些情况下，一个对象不想或不能直接引用一个对象，而代理对象可以在客户端与目标对象之间起到中介的作用。
代理是触发真正做事情的入口，通过被代理（目标对象）的业务逻辑方法来实现抽象方法，并可以附加自己的操作。

//抽象角色
public abstract class SaleTickets {
    public abstract void sale();
}

//真实角色：也就是真正的卖票点
class TrainStation extends SaleTickets {

    @Override
    public void sale() {
        System.out.println("卖票");
    }
}

//代理角色:票务中心
public class Helper extends SaleTickets {
    TrainStation ts = new TrainStation();

    @Override
    public void sale() {
        ts.sale();
    }
}

//使用者对象
public class User {

    public static void main(String[] args) {
        Helper help = new Helper();//通过代理来买票
        help.sale();
    }
}

4.观察者模式

当一个抽象模型有两个方面，其中一个方面依赖于另一方面。将这两者封装在独立的对象中以使它们可以各自独立的改变和复用。
当对一个对象的改变需要同时改变其他对象，而不知道具体有多少对象有待改变。
当一个对象必须通知其他对象，而它又不能假定其他对象是谁。换言之，你不希望这些对象是紧密耦合的。

//抽象观察者角色
public abstract class Watcher {
    public abstract void update();
}

//具体的观察者角色：警察
class Police extends Watcher {

    @Override
    public void update() {
        System.out.println("运输车有情况，警察保驾护航");
    }
}

//具体的观察者角色：保镖
class Protector extends Watcher {

    @Override
    public void update() {
        System.out.println("运输车有情况，保镖贴身保护");
    }
}

//具体的观察者角色：劫匪
class Thief extends Watcher {

    @Override
    public void update() {
        System.out.println("运输车有情况，劫匪准备动手");
    }

}

//抽象主题角色：提供抽象的方法用来添加、删除以及通知所有的观察者对象
public abstract class Transfer {
    //添加观察者对象
    public abstract void addWatcher(Watcher w);

    //删除观察者对象
    public abstract void deleteWatcher(Watcher w);

    //通知所有的观察者对象
    public abstract void notifyWatcher();
}

//具体主题角色
class CreateTransfer extends Transfer {
    List<Watcher> list = new ArrayList<Watcher>();

    //添加观察者对象
    @Override
    public void addWatcher(Watcher w) {
        list.add(w);
    }

    //删除观察者对象
    @Override
    public void deleteWatcher(Watcher w) {
        list.remove(w);//根据元素名称删除一个数据
    }

    //通知所有的观察者对象：调用观察者中的更新状态的方法
    @Override
    public void notifyWatcher() {
        for (Watcher w : list) {
            w.update();
        }
    }

}

//测试类
public class Test {

    public static void main(String[] args) {
        //创建观察者对象
        Police police = new Police();
        Protector protect = new Protector();
        Thief thief = new Thief();

        //创建具体主题角色对象，然后往里面添加观察者对象
        CreateTransfer ct = new CreateTransfer();
        ct.addWatcher(police);
        ct.addWatcher(protect);
        ct.addWatcher(thief);

        //通知所有的观察者对象
        ct.notifyWatcher();
    }

}

5.适配器模式

这个模式后面在安卓中，我还会详细介绍~~（比较重要）
想要使用一个已经存在的类，但如果它的方法不满足需求时。
两个类的职责相同或相似，但是具有不同的接口
应该在双方都不太容易修改的时候再使用适配器模式适配，而不是一有不同就使用。
接口要尽量简单，可以实现多个接口来实现多个功能。使用适配器来实现多个接口，并重写接口中所有的抽象方法，再写一个子类来继承这个适配器，就可以实现想要的方法，而不是在子类中重写所有的抽象方法。使用适配器扩展性较好，若接口中需要添加新的抽象方法，就可以只在适配器中重写该方法，对子类不会造成影响。

//目标类
public class Target {
    public int get110v(){
        System.out.println("220v");

        return 220;
    }
}

//需要适配的类
interface Adaptee {
    public int get380v();
    public int get110v();
}

//公用方法接口
public interface Inf1 {
    public void work();
}

class Target {
    public void work() {
        System.out.println("target work");
    }
}
//重写目标方法
class Adapter extends Target  {
    class Inner implements Inf1 {

        @Override
        public void work() {
            System.out.println("inf work");
        }
    }

}

//适配器：Adapter
public class Adapter extends Target implements Adaptee {

    @Override
    public int get380v() {

        return 220;
    }
}


class Test {//把110V和380V电压都适配到220V使用
    public static void main(String[] args) {
        Adapter a = new Adapter();
        System.out.println(a.get110v());
        System.out.println(a.get380v());
    }
}