响应网站开发/使用软件提高百度推广排名
设计模式—常用的设计模式介绍
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 {@Overridepublic void run() {System.out.println("plane....");}
}public class Broom implements Moveable {@Overridepublic 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{@Overridepublic Food createFood() {return new Apple();}@Overridepublic Vehicle createVehicle() {return new Car();}@Overridepublic 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() {}@Overridepublic void getMessage(String s) {System.out.println(name + "接到了小美打过来的电话，电话内容是：" + s);}}public class LaoLi implements Person {private String name = "老李";public LaoLi() {}@Overridepublic 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;}@Overridepublic 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{@Overridepublic void marry() {System.out.println("我们结婚啦～");}}
public class Test {public static void main(String[] args) {ProxyInterface proxyInterface = new WeddingCompany(new NormalHome());proxyInterface.marry();}
}
