Java学习---常见的模式

Java的常见模式

适配器模式

 package com.huawei;

 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;

 import java.util.Observable;
 import java.util.Observer;

 interface Window
 {
     public  void open();
     public  void close();
     public  void active();
 }

 abstract class WindowAdapter implements Window
 {
     public  void open(){}
     public  void close(){}
     public  void active(){}
 }

 class WindowImpl extends WindowAdapter
 {
     public  void open()
     {
         System.out.println("Open.......");
     }
     public  void close()
     {
         System.out.println("Close.......");
     }
     public  void active()
     {
         System.out.println("Active.......");
     }
 }

 public class ForNumber
 {
     public static void main(String args[])
     {
        Window win = new WindowImpl();
        win.open();
        win.close();
     }
 }

工厂模式

 package com.huawei;

 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;

 import java.util.Observable;
 import java.util.Observer;

 interface Fruit
 {
     public void eat();
 }

 class Apple implements Fruit
 {

     public void eat()
     {
         System.out.println("Eat Apple");
     }

 }

 class Orange implements Fruit
 {
     public void eat()
     {
         System.out.println("Eat Orange");
     }
 }
 //定义工厂
 class Factory
 {
     public static Fruit getInstance(String className)
     {
         Fruit f = null;
         if ("apple".equals(className))
         {
             f = new Apple();
         }

         if ("orange".equals(className))
         {
             f = new Orange();
         }

         return f;
     }
 }

 public class ForNumber
 {
     public static void main(String args[])
     {
        Fruit f = null;                      //定义接口对象
        f = new Factory().getInstance("apple");
        f.eat();
     }
 }

 代理模式

 package com.ftl.xmlparse;

 interface Network
 {
     public void browse();
 }

 class Real implements Network
 {

     public void browse()
     {
         System.out.println("Real Connection...");
     }

 }

 class Proxy implements Network
 {
     private Network network;

     public Proxy(Network network)
     {
         this.network = network;
     }

     public void check()
     {
         System.out.println("Checking...");
     }

     public void browse()
     {
         this.check();
         this.network.browse();
     }

 }

 public class TestDemo
 {
     public static void main(String[] args)
     {
         Proxy proxy = new Proxy(new Real());
         proxy.browse();
         System.out.println("-------------");
         Network net = new Proxy(new Real());
         net.browse();
     }
 }

单例模式

 package com.ftl.xmlparse;
 //  懒汉法： 来一个开一个内存地址空间
 class Singleton{
     public static Singleton single = null;
     private Singleton(){};

     public static Singleton getSingleton(){
         single = new Singleton();
         return single;
     }
 }

 //  饿汉法： 线程不安全
 class Singleton1 {
     public static Singleton1 single = null;
     private Singleton1(){};

     public static Singleton1 getSingleton1(){
         if(single != null){
             single = new Singleton1();
         }
         return single;
     }
 }

 //  轮番法： 线程安全，却效率低
 class Singleton2 {
     public static Singleton2 single = null;
     private Singleton2(){};

     public static Singleton2 getSingleton2(){
         synchronized (Singleton1.single) {
             if(single != null){
                 single = new Singleton2();
             }
         }
         return single;
     }
 }
 //  轮番法： 线程安全，却效率低
 class Singleton4 {
     public static Singleton4 single = null;
     private Singleton4(){};

     public static Singleton4 getSingleton4(){
         if(single != null){
             synchronized (Singleton1.single) {
                 single = new Singleton4();
             }
         }
         return single;
     }
 }

 // 双重校验锁
 // volatile：一般的变量是在寄存器内，一个变量一个寄存器，添加了volatile关键字后，变量保存在内存中
 // 告诉系统直接从内从中获取变量的数值,且变量的更改会通知到每个线程，确保了数据的安全
 // 且不允许编译系统优化代码，必须按照代码的顺序编译
 class Singleton3 {
     public static volatile Singleton3 single = null;
     private Singleton3(){};
     public static Singleton3 getSingleton3(){
         if(single == null){
             synchronized (Singleton1.single) {
                 if(single == null){
                     single = new Singleton3();
                 }
             }
         }
             return single;
     }
 }

 public class TestDemo
 {
     public static void main(String[] args)
     {
         Singleton  singleton = Singleton.getSingleton();
         Singleton1 singleton1 = Singleton1.getSingleton1();
         Singleton2 singleton2 = Singleton2.getSingleton2();
         Singleton3 singleton3 = Singleton3.getSingleton3();
         Singleton4 singleton4 = Singleton4.getSingleton4();
     }
 }

生产者消费者模式

 package com.ftl;

 import java.util.HashMap;
 import java.util.Map;
 /**
  * 生产者和消费者模型
  *
  * @author 小a玖拾柒
  * Date:   2018年8月18日
  *
  */

 class Info{
     private String name;
     private String content;
     private boolean flag = false;

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public String getContent() {
         return content;
     }

     public void setContent(String content) {
         this.content = content;
     }

     public synchronized void set(String name, String content){
 //        System.out.println("进入到set函数()...");
         if(flag){
             try {
                 super.wait();
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
         }
         this.setName(name);
         try {
             Thread.sleep(1000);
         } catch (InterruptedException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
         this.setContent(content);
         this.flag = true;
         super.notify();
     }

     public synchronized void get(){
 //        System.out.println("进入到get函数()...");
         if(!flag){
             try {
                 super.wait();
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
         }
         try {
             Thread.sleep(1000);
         } catch (InterruptedException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
         System.out.println("Name:" + this.getName() + ", Content:" + this.getContent());
         this.flag = false;
         super.notify();
     }
 }

 class Producer implements Runnable{
     private Info info;
     private boolean flag = true;
     public Producer(Info info){
         this.info = info;
     }
     @Override
     public void run() {
         // TODO Auto-generated method stub
         for(int i = 0 ; i < 10; i++){
             if(flag){
                 this.info.set("A", "AAAA");
                 this.flag = false;
             }else{
                 this.info.set("B", "BBBB");
                 this.flag = true;
             }
         }
     }

 }

 class Consumer implements Runnable{
     private Info info;

     public Consumer(Info info){
         this.info = info;
     }
     @Override
     public void run() {
         for(int i = 0 ; i < 10; i++){
             this.info.get();
         }
     }
 }
 public class Test2018 {
     public static void main(String[] args) {
         Info info = new Info();
         Consumer con = new Consumer(info);
         Producer pro = new Producer(info);
         new Thread(con).start();
         new Thread(pro).start();
     }
 }

[生产者消费者更多参考] https://www.cnblogs.com/chentingk/p/6497107.html