设计模式

设计模式

单例设计模式:

单例设计模式: 就是让某个类,只能有一个对象(任务管理器就是使用的单利设计模式)

/*
 * 饿汉单例设计模式--刚刚开始直接创建对象,当用户调用get方法了,直接返回已经创建好的对象即可!
 * */
public class Person {
    /*  实现步骤:
    *   a.私有化构造方法,目的是不让用户自己去创建对象
        b.在类的内部创建一个该类的对象,并且加上private static修饰
        c.提供一个静态的get方法,在方法中返回刚刚创建的那个对象
    *
    * */
    private Person() {
    }

    private static Person p = new Person();

    public static Person getInstance() {
        return p;
    }
}

/*
* 	懒汉式:

	刚刚开始我们不创建对象,当用户调用get方法了,再创建对象!
*
* */
public class Dog {
    private Dog() {
    }
    //定义一个对象,但不赋值
    private static Dog dog;
    private synchronized static Dog getDog() {
        //判断对象是否为空,为空就创建一个对象,不为空就直接将该对象返回
        if (dog == null) {
            dog = new Dog();
        }
        return dog;
    }
}

多例设计模式:

让某个类只能创建指定个数的对象.

/*  多例设计模式: 让某个类只能创建指定数量的对象
*   	实现步骤:
*               a.私有化构造方法,目的是不让用户随意创建对象
                b.在类的内部创建一个private static修饰的集合,用于保存我们指定个数的对象
                c.提供一个静态的get方法,该方法从集合中随机获取一个对象返回给用户即可!
* */
public class Cat {
    private Cat() {
    }
    //定义一个变量,用来指定创建的个数
    private static final int count = 3;
	//定义一个集合,用来储存对象
    private static ArrayList<Cat> list = new ArrayList<>();

    static {
        // 把创建的对象添加到集合,在静态代码块中执行这段代码,可以在对象调用的时候就执行,且只执行一次啊
        for (int i = 0; i < count; i++) {
            list.add(new Cat());
        }
    }
    // 提供一个方法,获取对象
    private static Cat getInstance() {
        //从集合中随机返回一个对象
        return list.get(new Random().nextInt(count));
    }
}

工厂模式设计模式

工厂模式是常见的设计模式之一,本来我们以前创建对象是直接自己new的方式创建的,有了工厂模式之后,我们把new的操作交给工厂,我们只需要调用工厂的方法获取对象即可!!!

​ 优点： 1、一个调用者想创建一个对象，只要知道其名称就可以了。 2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现，调用者只关心产品的接口。

​ **缺点：**每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

// 定义一个接口.
public interface DriveMethod {
    void drive();
}
//定义2个类.实现接口
public class Car2 implements DriveMethod {
    @Override
    public void drive() {
        System.out.println("car2 开车了");
    }
}
public class Car1 implements DriveMethod {
    @Override
    public void drive() {
        System.out.println("car1 开车了");
    }
}

//定义一个工厂类,根据不同的参数返回不同的实现类对象
public class CarFactory {
    public static DriveMethod getCar(int i) {
        DriveMethod driveMethod = null;
        if (i == 1) {
            driveMethod = new Car1();
        } else if (i == 2) {
            driveMethod = new Car2();
        }
        return driveMethod;
    }

    //测试
    @Test
    public void method() {
        DriveMethod car = CarFactory.getCar(1);
        car.drive();
    }

    @Test
    public void method1() {
        DriveMethod car = CarFactory.getCar(2);
        car.drive();
    }
}

策略者模式

• 执行者（谁执行策略）
• 策略（策略接口）
  • 策略实现
  • …
• 调用者
  • 创建策略传递给执行

每一个方法都是一种策略,在执行时才将策略的具体实现传递给方法

//定义一个接口,接口方法定义策略
public interface Sport {
    void sport();
}
//执行者的方法,传入策略,但是并没有告诉策略怎么执行
public class Person {
    public void play(Sport s) {
        s.sport();
    }
}
// 在具体执行策略是,执行者会将策略的方法具体并执行
class Text {
    public static void main(String[] args) {
        Person p = new Person();
        p.play(() -> {
            System.out.println("踢足球");
        });
    }
}