全国做的最棒的网站,域名的作用是什么,黑龙江省建设安全监督网站,个人做论坛网站单例模式 指一个应用程序中#xff0c;某个类的实例对象只有一个#xff0c;你没有办法去new#xff0c;因为构造器是被private修饰的#xff0c;一般通过getInstance()的方法来获取它们的实例。 getInstance()的返回值是一个对象的引用#xff0c;并不是一个新的实例某个类的实例对象只有一个你没有办法去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() { } }此种写法不仅能避免多线程同步问题而且还能防止反序列化重新创建新的对象但是对于我们的认识可能会有些生疏如下所示。 双重校验锁 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; } }在选择写法的时候我们应该根据业务需求逻辑思考选择最适合我们的写法。 观察者模式 对象间一对多的依赖关系当一个对象的状态发生改变时所有依赖于它的对象都得到通知并被自动更新。 观察者模式UML图 上图解析示例假设有三个人小美女22小王和小李。小美很漂亮小王和小李是两个程序猿时刻关注着小美的一举一动。有一天小美说了一句“谁来陪我打游戏啊。”这句话被小王和小李听到了结果乐坏了蹭蹭蹭没一会儿小王就冲到小美家门口了在这里小美是被观察者小王和小李是观察者被观察者发出一条信息然后观察者们进行相应的处理看代码 public interface Person {//小王和小李通过这个接口可以接收到小美发过来的消息void getMessage(String s); }这个接口相当于小王和小李的电话号码小美发送通知的时候就会拨打getMessage这个电话拨打电话就是调用接口看不懂没关系先往下看 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);}}代码很简单我们再看看小美的代码 public class XiaoMei {ListPerson list new ArrayListPerson();public XiaoMei(){}public void addPerson(Person person){list.add(person);}//遍历list把自己的通知发送给所有暗恋自己的人public void notifyPerson() {for(Person person:list){person.getMessage(你们过来吧谁先过来谁就能陪我一起玩儿游戏!);}} }我们写一个测试类来看一下结果对不对 public class Test {public static void main(String[] args) {XiaoMei xiao_mei new XiaoMei();LaoWang lao_wang new LaoWang();LaoLi lao_li new LaoLi();//小王和小李在小美那里都注册了一下xiao_mei.addPerson(lao_wang);xiao_mei.addPerson(lao_li);//小美向小王和小李发送通知xiao_mei.notifyPerson();} } 装饰者模式 对已有的业务逻辑进一步的封装使其增加额外的功能如Java中的IO流就使用了装饰者模式用户在使用的时候可以任意组装达到自己想要的效果。 解析示例我想吃三明治首先我需要一根大大的香肠我喜欢吃奶油在香肠上面加一点奶油再放一点蔬菜最后再用两片面包夹一下很丰盛的一顿午饭营养又健康。ps不知道上海哪里有卖好吃的三明治的求推荐那我们应该怎么来写代码呢 首先我们需要写一个Food类让其他所有食物都来继承这个类看代码 public class Food {private String food_name;public Food() {}public Food(String food_name) {this.food_name food_name;}public String make() {return food_name;}; } 然后我们写几个子类继承它 //面包类 public class Bread extends Food {private Food basic_food;public Bread(Food basic_food) {this.basic_food basic_food;}public String make() {return basic_food.make()面包;} }//奶油类 public class Cream extends Food {private Food basic_food;public Cream(Food basic_food) {this.basic_food basic_food;}public String make() {return basic_food.make()奶油;} }//蔬菜类 public class Vegetable extends Food {private Food basic_food;public Vegetable(Food basic_food) {this.basic_food basic_food;}public String make() {return basic_food.make()蔬菜;}}这几个类都是差不多的构造方法传入一个Food类型的参数然后在make方法中加入一些自己的逻辑接着是我们的Test类。 public class Test {public static void main(String[] args) {Food food new Bread(new Vegetable(new Cream(new Food(香肠))));System.out.println(food.make());} }一层一层的封装我们从里往外看最里面我new了一个香肠在香肠的外面我包裹了一层奶油在奶油的外面我又加了一层蔬菜最外面我放的是面包我们一起来看一下运行结果吧。 适配器模式 将两种完全不同的事物联系到一起就像现实生活中的变压器。假设一个手机充电器需要的电压是20V但是正常的电压是220V这时候就需要一个变压器将220V的电压转换成20V的电压这样变压器就将20V的电压和手机联系起来了。 public class Test {public static void main(String[] args) {Phone phone new Phone();VoltageAdapter adapter new VoltageAdapter();phone.setAdapter(adapter);phone.charge();} }// 手机类 class Phone {public static final int V 220;// 正常电压220v是一个常量private VoltageAdapter adapter; // 充电public void charge() {adapter.changeVoltage();}public void setAdapter(VoltageAdapter adapter) {this.adapter adapter;} }// 变压器 class VoltageAdapter {// 改变电压的功能public void changeVoltage() {System.out.println(正在充电...);System.out.println(原始电压 Phone.V V);System.out.println(经过变压器转换之后的电压: (Phone.V - 200) V);} }运行结果展示 工厂模式 简单工厂模式一个抽象的接口多个抽象接口的实现类一个工厂类用来实例化抽象的接口 // 抽象产品类 abstract class Car {public void run();public void stop(); }// 具体实现类 class Benz implements Car {public void run() {System.out.println(Benz开始启动了。。。。。);}public void stop() {System.out.println(Benz停车了。。。。。);} }class Ford implements 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(造不了这种汽车。。。);}}}工厂方法模式有四个角色抽象工厂模式具体工厂模式抽象产品模式具体产品模式。不再是由一个工厂类去实例化具体的产品而是由抽象工厂的子类去实例化产品 // 抽象产品角色 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();} }抽象工厂模式与工厂方法模式不同的是工厂方法模式中的工厂只生产单一的产品而抽象工厂模式中的工厂生产多个产品 /抽象工厂类 public abstract class AbstractFactory {public abstract Vehicle createVehicle();public abstract Weapon createWeapon();public abstract Food createFood(); }//具体工厂类其中Food,VehicleWeapon是抽象类 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();} } 代理模式proxy 有两种静态代理和动态代理。先说静态代理解析示例到了一定的年龄我们就要结婚结婚是一件很麻烦的事情包括那些被父母催婚的。有钱的家庭可能会找司仪来主持婚礼显得热闹洋气好了现在婚庆公司的生意来了我们只需要给钱婚庆公司就会帮我们安排一整套结婚的流程。整个流程大概是这样的家里人催婚-男女双方家庭商定结婚的黄道即日-找一家靠谱的婚庆公司-在约定的时间举行结婚仪式-结婚完毕 婚庆公司打算怎么安排婚礼的节目在婚礼完毕以后婚庆公司会做什么我们一概不知。。。别担心不是黑中介我们只要把钱给人家人家会把事情给我们做好。所以这里的婚庆公司相当于代理角色。 实例展示 //代理接口 public interface ProxyInterface { //需要代理的是结婚这件事如果还有其他事情需要代理比如吃饭睡觉上厕所也可以写 void marry(); //代理吃饭(自己的饭让别人吃去吧) //void eat(); //代理拉屎自己的屎让别人拉去吧 //void shit(); } 接下来我们看看婚庆公司的代码: 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(); } } 运行结果如下 生产者/消费者模式 什么是生产者/消费者模式 某个模块负责产生数据这些数据由另一个模块来负责处理此处的模块是广义的可以是类、函数、线程、进程等。产生数据的模块就形象地称为生产者而处理数据的模块就称为消费者。在生产者与消费者之间在加个缓冲区我们形象的称之为仓库生产者负责往仓库了进商品而消费者负责从仓库里拿商品这就构成了生产者消费者模式。结构图如下 生产者消费者模式有如下几个优点 1、解耦 　 由于有缓冲区的存在生产者和消费者之间不直接依赖耦合度降低。 2、支持并发 　 由于生产者与消费者是两个独立的并发体他们之间是用缓冲区作为桥梁连接生产者只需要往缓冲区里丢数据就可以继续生产下一个数据而消费者只需要从缓冲区了拿数据即可这样就不会因为彼此的处理速度而发生阻塞。 3、支持忙闲不均 缓冲区还有另一个好处。如果制造数据的速度时快时慢缓冲区的好处就体现出来 了。当数据制造快的时候消费者来不及处理未处理的数据可以暂时存在缓冲区中。 等生产者的制造速度慢下来消费者再慢慢处理掉。 生产者-消费者模型准确说应该是“生产者-仓储-消费者”模型这样的模型遵循如下的规则 1、生产者仅仅在仓储未满时候生产仓满则停止生产。 2、消费者仅仅在仓储有产品时候才能消费仓空则等待。 3、当消费者发现仓储没产品可消费时候会通知生产者生产。 4、生产者在生产出可消费产品时候应该通知等待的消费者去消费 此模型将要结合java.lang.Object的wait与notify、notifyAll方法来实现以上的需求。实例代码如下 创建所谓的“仓库”此类是本质上共同访问的共享数据区域 //此类是本质上共同访问的共享数据区域 public class SyncStack {private String[] str new String[10];private int index;//供生产者调用public synchronized void push(String sst){if(index sst.length()){try {wait();} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}this.notify();//唤醒在此对象监视器上等待的单个线程 str[index] sst;index;}//供消费者调用 public synchronized String pop(){if(index 0){try {wait();} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}this.notify();index--;String product str[index];return product;}//就是定义一个返回值为数组的方法,返回的是一个String[]引用 public String[] pro(){return str;} } 创建生产者 public class Producter implements Runnable {private SyncStack stack;public Producter(SyncStack stack){this.stack stack;}public void run(){for(int i 0;istack.pro().length;i){String producter 产品 i;stack.push(producter);System.out.println(生产了 producter);try {Thread.sleep(200);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}} }创建消费者 public class Consumer implements Runnable {private SyncStack stack;public Consumer(SyncStack stack){this.stack stack;}public void run(){for(int i0;istack.pro().length;i){String consumer stack.pop();System.out.println(消费了 consumer );try {Thread.sleep(400);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}} } 测试类 public class TestDeam {public static void main(String[] args) {SyncStack stack new SyncStack(); Consumer p new Consumer(stack); Producter c new Producter(stack); new Thread(p).start(); new Thread(c).start(); } } 测试结果 生产了:产品0 消费了产品0 生产了:产品1 生产了:产品2 消费了产品2 生产了:产品3 消费了产品3 生产了:产品4 生产了:产品5 生产了:产品6 消费了产品5 生产了:产品7 消费了产品6 消费了产品7 生产了:产品8 生产了:产品9 消费了产品8 消费了产品9 了解更多关注我哟