JAVA学习笔记(五十七)- 常用设计模式

单例模式

/*
 * 单例模式
 * 应用场合：有些对象只需要一个，此时可以使用单例模式
 * 作用：保证整个应用中某个实例有且只有一个
 * 类型：饿汉模式、懒汉模式
 */
public class Test04 {
    // 1.将构造方式私有化，不允许外界直接创建对象
    private Test04() {
    }

    // 2.创建类的唯一对象，使用private static修饰
    private static Test04 instance=new Test04();

    // 3.提供一个用于获取唯一实例的方法，使用public static修饰
    public static Test04 getInstance(){
        return instance;
    }
}

懒汉模式

/*
 * 懒汉模式
 * 区别：
 * 1.饿汉模式的特点，在类加载时会创建类的唯一实例，导致类加载比较慢，但运行时获取对象的速度较快，线程安全
 * 2.懒汉模式的特点，在第一次获取实例时会创建类的唯一实例，导致第一次获取时较慢，但类加载比较快，线程不安全
 *
 */
public class Test05 {
    // 1.将构造方法私有化
    private Test05() {
    }

    // 2.声明类的唯一实例，但并未实例化
    private static Test05 instance;

    // 3.提供一个用于获取唯一实例的静态方法
    public static Test05 getInstance() {
        if(instance==null){
            instance=new Test05();//判断如果为空，则创建一个唯一的实例
        }
        return instance;
    }
}

工厂模式

/*
 * 工厂模式Factory Method
 * 简单工厂模式
 * 定义：建立一个工厂类，对实现了同一个接口的多个类进行实例化对象的操作
 */
public class Test06 {
    public static void main(String[] args) {
        Factory factory=new Factory();
        Moveable m1=factory.product("plane");
        Moveable m2=factory.product("bus");
        Moveable m3=factory.product("bike");
        m2.move();
    }
}

interface Moveable {
    public void move();
}

class Plane implements Moveable {

    @Override
    public void move() {
        System.out.println("马航死亡航班。。。");
    }
}

class Bus implements Moveable {

    @Override
    public void move() {
        System.out.println("昌河校车。。。");
    }
}

class Bike implements Moveable {

    @Override
    public void move() {
        System.out.println("捷安特自行车");
    }
}

/*
 * 生产产品的工厂类
 */
class Factory {
    public Moveable product(String need) {
        if (need.equals("plane")) {
            return new Plane();
        } else if (need.equals("bus")) {
            return new Bus();
        } else {
            return new Bike();
        }
    }
}