设计模式—常用的设计模式介绍
1.单例模式(Singleton)
简单点说，就是一个应用程序中，某个类的实例对象只有一个，你没有办法去new，因为构造器是被private修饰的，一般通过getInstance()的方法来获取它们的实例。getInstance()的返回值是一个对象的引用，并不是一个新的实例
- 1>懒汉式写法(线程不安全)
/**
* 懒汉式(线程不安全)
*/
public class Singleton {
private static Singleton singleton;
private Singleton() {
}
public static Singleton getInstance() {
if (singleton == null) {
singleton = new Singleton();
}
return singleton;
}
}
- 2>懒汉式写法(线程安全)
/**
* 懒汉式(线程安全)
*/
public class Singleton2 {
private static Singleton2 singleton;
private Singleton2() {
}
/**
* 使用了synchronized关键字
* @return
*/
public static synchronized Singleton2 getInstance() {
if (singleton == null) {
singleton = new Singleton2();
}
return singleton;
}
}
- 3>饿汉式写法
/**
* 饿汉式
*/
public class Singleton3 {
private static Singleton3 singleton = new Singleton3();
private Singleton3() {
}
public static Singleton3 getInstance() {
return singleton;
}
}
- 4>静态内部类写法
/**
* 静态内部类写法
*/
public class Singleton4 {
/**
* 静态内部类
*/
private static class SingletonHolder{
private static final Singleton4 instance = new Singleton4();
}
private Singleton4() {
}
public static Singleton4 getInstance() {
return SingletonHolder.instance;
}
}
- 5>双重校验锁
/**
* 双重校验锁
*/
public class Singleton5 {
private volatile static Singleton5 singleton;
private Singleton5() {
}
public static Singleton5 getInstance() {
if (singleton == null) {
synchronized (Singleton5.class) {
if (singleton == null) {
singleton = new Singleton5();
}
}
}
return singleton;
}
}
2.工厂模式(Factory Method)
- 1>简单工厂模式：一个抽象的接口，多个抽象接口的实现类，一个工厂类，用来实例化抽象的接口
// 抽象产品类
abstract class Car {
public abstract void run();
public abstract void stop();
}
// 具体实现类
class Benz extends Car {
public void run() {
System.out.println("Benz开始启动了。。。。。");
}
public void stop() {
System.out.println("Benz停车了。。。。。");
}
}
class Ford extends Car {
public void run() {
System.out.println("Ford开始启动了。。。");
}
public void stop() {
System.out.println("Ford停车了。。。。");
}
}
// 工厂类
class Factory {
public static Car getCarInstance(String type) {
Car c = null;
if ("Benz".equals(type)) {
c = new Benz();
}
if ("Ford".equals(type)) {
c = new Ford();
}
return c;
}
}
public class Test {
public static void main(String[] args) {
Car c = Factory.getCarInstance("Benz");
if (c != null) {
c.run();
c.stop();
} else {
System.out.println("造不了这种汽车。。。");
}
}
}
- 2>工厂方法模式：有四个角色，抽象工厂模式，具体工厂模式，抽象产品模式，具体产品模式。不再是由一个工厂类去实例化具体的产品，而是由抽象工厂的子类去实例化产品
// 抽象产品角色
public interface Moveable {
void run();
}
// 具体产品角色
public class Plane implements Moveable {
@Override
public void run() {
System.out.println("plane....");
}
}
public class Broom implements Moveable {
@Override
public void run() {
System.out.println("broom.....");
}
}
// 抽象工厂
public abstract class VehicleFactory {
abstract Moveable create();
}
// 具体工厂
public class PlaneFactory extends VehicleFactory {
public Moveable create() {
return new Plane();
}
}
public class BroomFactory extends VehicleFactory {
public Moveable create() {
return new Broom();
}
}
// 测试类
public class Test {
public static void main(String[] args) {
VehicleFactory factory = new BroomFactory();
Moveable m = factory.create();
m.run();
}
}
- 3>抽象工厂模式：与工厂方法模式不同的是，工厂方法模式中的工厂只生产单一的产品，而抽象工厂模式中的工厂生产多个产品
//抽象工厂类
public abstract class AbstractFactory {
public abstract Vehicle createVehicle();
public abstract Weapon createWeapon();
public abstract Food createFood();
}
//具体工厂类，其中Food,Vehicle，Weapon是抽象类，
public class DefaultFactory extends AbstractFactory{
@Override
public Food createFood() {
return new Apple();
}
@Override
public Vehicle createVehicle() {
return new Car();
}
@Override
public Weapon createWeapon() {
return new AK47();
}
}
//测试类
public class Test {
public static void main(String[] args) {
AbstractFactory f = new DefaultFactory();
Vehicle v = f.createVehicle();
v.run();
Weapon w = f.createWeapon();
w.shoot();
Food a = f.createFood();
a.printName();
}
}
3.观察者模式(Observer)
对象间一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
public interface Person {
//老王和老李通过这个接口可以接收到小美发过来的消息
void getMessage(String s);
}
public class LaoWang implements Person {
private String name = "老王";
public LaoWang() {
}
@Override
public void getMessage(String s) {
System.out.println(name + "接到了小美打过来的电话，电话内容是：" + s);
}
}
public class LaoLi implements Person {
private String name = "老李";
public LaoLi() {
}
@Override
public void getMessage(String s) {
System.out.println(name + "接到了小美打过来的电话，电话内容是：->" + s);
}
}
老王和老李都喜欢小美,并且都实现了Person接口
这天,小美给执行了一个方法,老王和老李都收到了信息
public class XiaoMei {
List<Person> list = new ArrayList<Person>();
public XiaoMei(){
}
public void addPerson(Person person){
list.add(person);
}
//遍历list，把自己的通知发送给所有暗恋自己的人
public void notifyPerson() {
for(Person person:list){
person.getMessage("今天家里就我一个人，你们过来吧，谁先过来谁就能得到我!");
}
}
}
4.代理模式(Proxy)
代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。
/**
* 代理接口
*/
public interface ProxyInterface {
//需要代理的是结婚这件事
void marry();
}
/**
* 代理类
*/
public class WeddingCompany implements ProxyInterface {
private ProxyInterface proxyInterface;
public WeddingCompany(ProxyInterface proxyInterface) {
this.proxyInterface = proxyInterface;
}
@Override
public void marry() {
System.out.println("我们是婚庆公司的");
System.out.println("我们在做结婚前的准备工作");
System.out.println("节目彩排...");
System.out.println("礼物购买...");
System.out.println("工作人员分工...");
System.out.println("可以开始结婚了");
proxyInterface.marry();
System.out.println("结婚完毕，我们需要做后续处理，你们可以回家了，其余的事情我们公司来做");
}
}
/**
* 客户类
*/
public class NormalHome implements ProxyInterface{
@Override
public void marry() {
System.out.println("我们结婚啦～");
}
}
public class Test {
public static void main(String[] args) {
ProxyInterface proxyInterface = new WeddingCompany(new NormalHome());
proxyInterface.marry();
}
}
