单例模式 Build模式 观察者模式 工厂模式 适配器模式 代理模式
单例模式 Build模式 观察者模式 工厂模式 适配器模式
单例模式：
/**
* 单例模式
* 1.每次从getInstance()都能返回一个且唯一的一个对象。
* 2.资源共享情况下，getInstance()必须适应多线程并发访问。
* 3.提高访问性能。
* 4.懒加载（Lazy Load），在需要的时候才被构造。
*/
public class SingletonMode {
/**
* 单例模式 懒汉式 缺点：不适应多线程并发访问。
*/
public static class SingletonModeA {
private static SingletonMode instance;
public static SingletonMode getInstance() {
if (instance == null) {
instance = new SingletonMode();
}
return instance;
}
}
/***
* 单例模式 懒汉式 缺点：加锁性能瓶颈 耗时大
*/
public static class SingletonModeB {
private static SingletonModeB instance;
public static synchronized SingletonModeB getInstance() {
if (instance == null) {
instance = new SingletonModeB();
}
return instance;
}
}
/**
* 单例模式 饿汉式 缺点：不能带参数
*/
public static class SingletonModeC {
private static SingletonModeC instance = new SingletonModeC();
public static SingletonModeC getInstance() {
return instance;
}
}
/**
* 单例模式 懒汉式的 优点：同时读取实例的时候不会进行同步，没有性能缺陷；也不依赖JDK版本。
*/
public static class SingletonModeD implements Serializable {
private static class SingletonHoulder {
static final SingletonModeD sinletonMode = new SingletonModeD();
}
public static SingletonModeD getInstance() {
return SingletonHoulder.sinletonMode;
}
// private的构造函数用于避免外界直接使用new来实例化对象
private SingletonModeD() {
}
//readResolve方法应对单例对象被序列化时候
public Object readResolve() {
return getInstance();
}
}
Build模式：
/**
* build模式
* Created by LG on 2018/8/20.
*/
public class BuildMode {
private int icon;
private String title;
private String message;
private boolean isCancel;
//使用
public void use() {
BuildMode.Buidler buidler = new BuildMode.Buidler();
buidler.setIcon(1)
.setCancel(true)
.setMessage("build模式")
.setTitle("标题")
.builder();
}
private BuildMode(Buidler buidler) {
this.icon = buidler.icon;
this.title = buidler.title;
this.message = buidler.message;
this.isCancel = buidler.isCancel;
}
public int getIcon() {
return icon;
}
public void setIcon(int icon) {
this.icon = icon;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public boolean isCancel() {
return isCancel;
}
public void setCancel(boolean cancel) {
isCancel = cancel;
}
static class Buidler {
private int icon;
private String title;
private String message;
private boolean isCancel;
public int getIcon() {
return icon;
}
public Buidler setIcon(int icon) {
this.icon = icon;
return this;
}
public String getTitle() {
return title;
}
public Buidler setTitle(String title) {
this.title = title;
return this;
}
public String getMessage() {
return message;
}
public Buidler setMessage(String message) {
this.message = message;
return this;
}
public boolean isCancel() {
return isCancel;
}
public Buidler setCancel(boolean cancel) {
isCancel = cancel;
return this;
}
public BuildMode builder() {
return new BuildMode(this);
}
}观察者模式：
/**
* 观察者模式
* Created by LG on 2018/8/20.
*/
public class ObserverMode {
// 使用
public void use() {
//添加观察者
MyObservable myObservable = new MyObservable();
MyObserver myObserver = new MyObserver(1);
myObservable.addObserver(myObserver);
//改变数据
myObservable.setName("观察者模式");
myObservable.setAge(10);
myObservable.setSex("男");
}
/**
* 被观察者
*/
class MyObservable extends Observable {
private String name;
private int age;
private String sex;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
setChanged();
notifyObservers();
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
setChanged();
notifyObservers();
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
setChanged();
notifyObservers();
}
@Override
public String toString() {
return "MyPerson [name=" + name + ", age=" + age + ", sex=" + sex + "]";
}
}
/**
* 观察者
*/
class MyObserver implements Observer {
private int id;
private MyObservable myObservable;
public MyObserver(int id) {
this.id = id;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public MyObservable getMyObservable() {
return myObservable;
}
public void setMyObservable(MyObservable myObservable) {
this.myObservable = myObservable;
}
@Override
public void update(Observable observable, Object o) {
this.myObservable = (MyObservable) observable;
}
}
工厂模式：
/**
* 工厂模式
* Created by LG on 2018/8/20.
*/
public class FactoryMode {
/**
* 简单工厂模式
*/
static class SimpleFactory {
public void use() {
INoodles noodles = SimpleNoodlesFactory.createNoodles(SimpleNoodlesFactory.TYPE_LZ);
noodles.desc();
}
//抽象方法
public abstract static class INoodles {
public abstract void desc();
}
//产品类
public static class LzNoodles extends INoodles {
@Override
public void desc() {
System.out.println("刀削面");
}
}
//产品类
public static class PaoNoodles extends INoodles {
@Override
public void desc() {
System.out.println("泡面");
}
}
//工厂类
public static class SimpleNoodlesFactory {
public static final int TYPE_LZ = 1;//刀削面
public static final int TYPE_PM = 2;//泡面
public static INoodles createNoodles(int type) {
switch (type) {
case TYPE_LZ:
return new LzNoodles();
case TYPE_PM:
return new PaoNoodles();
default:
return new PaoNoodles();
}
}
}
}
/**
* 抽象工厂模式
*/
static class AbstractFactory {
//使用
public void use() {
IFactory factory = new Factory();
factory.createProduct1().show();
factory.createProduct2().show();
}
interface IProduct1 {
public void show();
}
interface IProduct2 {
public void show();
}
class Product1 implements IProduct1 {
public void show() {
System.out.println("这是1型产品");
}
}
class Product2 implements IProduct2 {
public void show() {
System.out.println("这是2型产品");
}
}
interface IFactory {
public IProduct1 createProduct1();
public IProduct2 createProduct2();
}
public class Factory implements IFactory {
public IProduct1 createProduct1() {
return new Product1();
}
public IProduct2 createProduct2() {
return new Product2();
}
}
}
适配器模式：
/**
* 适配器模式
* Created by LG on 2018/8/20.
*/
public class AdapterMode {
/**
* 对象/类 适配器模式
*/
static class ClassAdapter {
public void use() {
Xiaomi mi1 = new Xiaomi();
mi1.takeAlong();
mi1.store();
}
public interface Usb {
void store();
void takeAlong();
}
public class Phone {
public void call() {
System.out.println("Phone call");
}
public void sms() {
System.out.println("Phone sms");
}
public void takeAlong() {
System.out.println("Phone takeAlong");
}
}
/**
* 类的适配器模式
* phone + Usb
* 将Phone的功能扩展到Usb里
*/
public class Xiaomi extends Phone implements Usb {
@Override
public void store() {
// TODO Auto-generated method stub
System.out.println("store implements usb");
}
}
/**
* 对象的适配器模式
*/
public class XiaomiWrapper implements Usb {
private Phone phone;
public XiaomiWrapper(Phone phone) {
this.phone = phone;
}
@Override
public void store() {
// TODO Auto-generated method stub
System.out.println("store implements usb");
}
@Override
public void takeAlong() {
// TODO Auto-generated method stub
phone.takeAlong();
}
}
/**
* 接口适配器
*/
static class ImplementAdapter {
public void use() {
Phone1 p1 = new Phone1();
Phone2 p2 = new Phone2();
p1.store();
p2.takeAlong();
}
/**
* 接口的适配器模式
* 1.借助于一个抽象类，该抽象类实现了该接口，实现了所有的方法
* 2.继承类可以选择性的实现接口中的方法
*/
public abstract class AbsPhone implements Usb {
public void store() {
System.out.println("AbsPhone implements usb's store methond");
}
public void takeAlong() {
System.out.println("AbsPhone implements usb's takeAlong methond");
}
}
public class Phone1 extends AbsPhone {
public void call() {
System.out.println("Phone1 call");
}
public void sms() {
System.out.println("Phone1 sms");
}
public void store() {
System.out.println("Phone1 need usb's store methond");
}
}
public class Phone2 extends AbsPhone {
public void call() {
System.out.println("Phone2 call");
}
public void sms() {
System.out.println("Phone2 sms");
}
public void takeAlong() {
System.out.println("Phone2 need usb's takeAlong methond");
}
}
}
}
还差一个代理模式，会及时更新。