单列设计模式
- 简单的来说 一个Application 某个类的实例对象只有一个,我们`没有办法new 的时候因为构造方法是被private修饰的 一般通过getInstance()方法获取它的实列对象 getInstance()返回的是一个对象的引用,并不是一个新的实例,废话不多说了 直接上代码!
public class Singleton {
private static Singleton singleton;
private Singleton() {
}
public static Singleton getInstance() {
if (singleton == null) {
singleton = new Singleton();
}
return singleton;
}
}
上面的是最基本的写法 也叫懒汉式写法(线程不安全的)
public class Singleton {
private static Singleton instance;
private Singleton (){}
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
再看看我们的饿汉式的写法吧
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton (){}
public static Singleton getInstance() {
return instance;
}
}
静态内部类
public class Singleton {
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
private Singleton (){}
public static final Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}
枚举
public enum Singleton {
INSTANCE;
public void whateverMethod() {
}
}
这种方式是Java Bloach提倡的写法 他不仅能够避免线程同步的问题 而且还能防止反序列化重新创建新的对象
双重校验锁
public class Singleton {
private volatile static Singleton singleton;
private Singleton (){}
public static Singleton getSingleton() {
if (singleton == null) {
synchronized (Singleton.class) {
if (singleton == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
}
观察者设计模式
对象存在一对多的关系 当一个对一个对象发生改变的时候,他所依赖的对象也会发生相应通知和改变 例如:有三个人,小雅(女),小铁箱(男),小木箱(男),小雅长得比较漂亮,平时很风骚,小木箱和小铁箱时刻关注着小雅的举动,有一天小雅说了一句话:我今天老公不在好无聊呀~,这句话被小铁箱和小木箱听到了乐坏了,摩擦摩擦,小铁箱就来到了小雅的家里面,于是进门了———————————-啪啪啪啪,在这里小雅是被观察者,小铁箱和小木箱是观察者,被观察者发送一条Message,让观察者接收,并且观察者做出相应的处理
直接上代码:
小铁箱的代码:
小木箱的代码:
这个借口相当于小木箱和小铁箱的电话号码,小雅发送通知的时候,就会拨打getMessage这个电话,拨打电话就是调用这个接口,
public interface Person {
//通知Micro和Kibaco发送的消息
void getMessage(String msg);
}
然后 我们再过来看看小雅的代码:
public class Beauty {
List<Person> list= new ArrayList<Person>();
public Beauty() {
}
public void addPerson(Person person){
list.add(person);
}
//遍历给该集合发送给自己的暗恋的人
public void notifyPerson(){
for (Person person : list) {
person.getMessage("今天老公不在,就小女子一人,你们过来吧,你们谁先到,就能先得到我,今晚十一点等你哦~~~");
}
}
结果到底是什么样的,我们来测试一把!
public class TestObserver {
public static void main(String[] args) {
Kibaco kibaco = new Kibaco();
Micro micro = new Micro();
Beauty beauty = new Beauty();
//小铁箱和小木箱都在小雅那里注册了一下
beauty.addPerson(kibaco);
beauty.addPerson(micro);
//小雅给小铁箱和小木箱发送通知
beauty.notifyPerson();
}
}
- 运行结果
Perfect!!!
装饰设计模式
对已有的业务逻辑进行封装,使其中增加外的功能,比如我们在Java里面学的IO流就用了装饰设计模式,用户在使用的时候可以任意组装,最终的目的是达到自己目的,例如:我想吃臭豆腐,首先我需要将炸好的豆腐干,我喜欢吃辣椒,在豆腐干外面浇一层辣椒汁,再放一点葱花,最好加一点秘制的排骨汤,美味营养又健康(ps:不知道长沙哪里有好吃的臭豆腐,博主推荐一下黑色经典),那么我们怎么写代码了?首先我们需要一个Tofu类,让所有的配料都继承这个类!!看代码:
- 辣椒汁类
public class chilli extends Tofu {
private Tofu mingredients;
public chilli( Tofu ingredients) {
this.mingredients = ingredients;
}
@Override
public String make() {
return mingredients.make()+"辣椒汁";
}
}
- 葱花类
public class leek extends Tofu {
private Tofu mingredients;
public leek( Tofu ingredients) {
this.mingredients = ingredients;
}
@Override
public String make() {
return mingredients.make()+"葱花+";
}
}
- 排骨汤类
public class ribs extends Tofu {
private Tofu mingredients;
public ribs(Tofu ingredients) {
this.mingredients = ingredients;
}
@Override
public String make() {
return mingredients.make()+"排骨汤+";
}
}
- 测试类
public class Testdecorate {
public static void main(String[] args) {
Tofu tofu =new chilli( new leek(new ribs(new Tofu("豆腐干+"))));
System.out.println(tofu.make());
}
}
看到没有一层层包裹,我们从里面往外面看,最里面我new了一个豆腐干,豆腐干外面我浇了一层排骨汤,浇完排骨汤,我再撒了一把葱花,最后再浇了一层辣椒汁,这就是黑色经典臭豆腐的秘制做工,来看看我们的运行结果吧!
- 运行结果
一碗香喷喷的长沙臭豆腐就做好了
适配器模式
将两种完全不同的事务联系起来,就像生活中的变压器,假设一个手机充电需要22v,但是正常的交流电是220v这个时候就需要一个变压器,将220v电压转化成20v的电压,这样变压器就将20v的电压和手机联系起来了
- 手机类
public class Phone {
public static final int V = 220;//正常电压是220v,是一个常量
private VoltageAdapter adapter;
//充电
public void charge(){
adapter.changeTransformer();
}
public void setAdapter(VoltageAdapter adapter) {
this.adapter = adapter;
}
}
- 变压器类
public class Phone {
public static final int V = 220;//正常电压是220v,是一个常量
private VoltageAdapter adapter;
//充电
public void charge(){
adapter.changeTransformer();
}
public void setAdapter(VoltageAdapter adapter) {
this.adapter = adapter;
}
}
- 测试类
public class TestAdapter {
public static void main(String[] args) {
Phone phone = new Phone();
VoltageAdapter adapter = new VoltageAdapter();
phone.setAdapter(adapter);
phone.charge();
}
}
- 运行结果
观察者设计模式
- 简单工厂模式
抽象接口
abstract interface car {
void run(); //奔跑
void stop();//停止
}
多个抽象接口的实现类
public class Benz implements car {
@Override
public void run() {
System.out.println("奔驰开始启动了");
}
@Override
public void stop() {
System.out.println("奔驰熄火停止了-----");
}
}
public class BMW implements car {
@Override
public void run() {
System.out.println("宝马开始启动了");
}
@Override
public void stop() {
System.out.println("宝马熄火停止了-----");
}
}
一个工厂类
实例化抽象接口
扫描二维码关注公众号,回复: 5546993 查看本文章
class Factory {
static car getCarInstance(String type) {
car c = null;
if ("Benz".equals(type)) {
c = new Benz();
}
if ("BMW".equals(type)) {
c = new BMW();
}
return c;
}
}
测试类
public class TestFactory {
public static void main(String[] args) {
car car = Factory.getCarInstance("BMW");
if (car!=null){
car.run();
car.stop();
}else {
System.out.println("造不了这种汽车-----");
}
}
}
- 运行结果
抽象产品角色
public abstract class FactoryMeyhod {
abstract Moveable create();
}
具体产品角色
public class Broom implements Moveable {
@Override
public void run() {
System.out.println("Broom-----------");
}
}
public class Plane implements Moveable {
@Override
public void run() {
System.out.println("Plane-----------");
}
}
抽象工厂方法
public abstract class FactoryMeyhod {
abstract Moveable create();
}
测试类
public class TestFactoryMeyhod {
public static void main(String[] args) {
FactoryMeyhod broomFactory = new BroomFactory();
Moveable moveable = broomFactory.create();
moveable.run();
}
}
- 运行结果
Broom———–
小木箱的第一篇博客,网上资料很多,感谢”代码也是人”材料借鉴,觉得写得好的话点个赞支持一下呗