筆記之_java整理設計模式

設計模式分類：
        建立型：new方法，實例化
        結構型：類的結合，套用
        行爲型：方法的操做
必須掌握的設計模式：工廠、模板、單例、命令、適配器、代理
接口先定義，後實現
抽象類與接口：
光用繼承會致使，父類一改變，子類就不得不改變，代碼可複用
光用接口子類必需要重寫父類全部方法，代碼不能複用
反射機制：
反射機制是在運行狀態中，對於任意一個類，都可以知道這個類的全部屬性和方法；對於任意一個對象，都可以調用它的任意一個方法和屬性；這種動態獲取的信息以及動態調用對象的方法的功能稱爲java語言的反射機制
反射機制主要提供瞭如下功能：
    在運行時判斷任意一個對象所屬的類；
    在運行時構造任意一個類的對象；
    在運行時判斷任意一個類所具備的成員變量和方法；
    在運行時調用任意一個對象的方法；
    生成動態代理。
經過一個對象得到完整的包名和類名
new 類名().getClass().getName()
得到類
Class.forName("net.xsoftlab.baike.TestReflect");
new TestReflect().getClass();
TestReflect.class;
獲取一個對象的父類與實現的接口
取得父類
Class<?> parentClass = clazz.getSuperclass();
獲取全部的接口
Class<?> intes[] = clazz.getInterfaces();
經過反射機制實例化一個類的對象
實例化默認構造方法
User user = (User) class1.newInstance()
取得所有的構造函數 使用構造函數賦值
Constructor<?> cons[] = class1.getConstructors();
取得構造函數的參數
cons[i].getParameterTypes();
取得本類的所有屬性
Field[] field = clazz.getDeclaredFields();
權限修飾符
int Modifier= field[i].getModifiers();
String priv = Modifier.toString(mo);
屬性類型
Class<?> type = field[i].getType();
取得實現的接口或者父類的屬性
Field[] filed1 = clazz.getFields();
取得類的所有方法
Method method[] = clazz.getMethods();
取得方法返回值類型
Class<?> returnType = method[i].getReturnType();
取得方法參數
Class<?> para[] = method[i].getParameterTypes();
取得方法修飾符
int temp = method[i].getModifiers();
取得方法異常類型
Class<?> exce[] = method[i].getExceptionTypes();
經過反射機制調用某個類的方法
Method method = clazz.getMethod("reflect1");
method.invoke(clazz.newInstance());
經過反射機制操做某個類的屬性
能夠直接對 private 的屬性賦值
        Field field = clazz.getDeclaredField("proprety");
        field.setAccessible(true);
        field.set(obj, "Java反射機制");
在泛型爲Integer的ArrayList中存放一個String類型的對象
public static void main(String[] args) throws Exception {
        ArrayList<Integer> list = new ArrayList<Integer>();
        Method method = list.getClass().getMethod("add", Object.class);
        method.invoke(list, "Java反射機制實例。");
        System.out.println(list.get(0));
 }
經過反射修改數組的值
Array.set(temp, 0, 100);
經過反射機制修改數組的大小
System.arraycopy(舊數組名, 0,新數組名, 0, 舊數組長度);
設計模式：前輩程序員在解決具體的程序開發問題時給出的方案經驗
單例模式：程序中對於某個類型的對象只能有一份
構造方法私有化
        建立靜態的惟一對象，初值爲null
        提供公共的靜態方法返回惟一對象(判斷對象是否已被實例化過)
        public class SingletonClass{
private static SingletonClass instance=null;
private SingletonClass(){
        }
           public static　synchronized　SingletonClass getInstance(){
            if(instance==null){
                   instance=new SingletonClass();
            }
            return instance;
        }
}
遞歸調用：
    public class Test{
        public static void main(String[] args) {
            System.out.println(method(5));
        }
        public static int method(int n){
            if (n == 1){
                return 1;
            }else{
                return n * method(n-1);
            }
        }
}
代理模式：
爲其餘對象提供一種代理，並以控制對這個對象的訪問
代理模式在不一樣的場景，都會要創建不一樣的接口，致使代碼不能複用
        Java中提供了一種反射機制叫作動態代理
在java的動態代理機制中，有兩個重要的類或接口，
一個是 InvocationHandler(Interface)
InvocationHandler這個接口的惟一一個方法 invoke 方法：
Object invoke(Object proxy, Method method, Object[] args) throws Throwable
proxy:　　指代咱們所代理的那個真實對象
method:　　指代的是咱們所要調用真實對象的某個方法的Method對象
args:　　指代的是調用真實對象某個方法時接受的參數
另外一個則是 Proxy(Class)
Proxy這個類的做用就是用來動態建立一個代理對象的類
public static Object newProxyInstance(
ClassLoader loader, 
Class<?>[] interfaces, 
InvocationHandler h) throws IllegalArgumentException
loader:　　一個ClassLoader對象，定義了由哪一個ClassLoader對象來對生成的代理對象進行加載
interfaces:　一個Interface對象的數組，表示的是我將要給我須要代理的對象提供一組什麼接口，若是我提供了一組接口給它，那麼這個代理對象就宣稱實現了該接口(多態)，這樣我就能調用這組接口中的方法了
h:　　一個InvocationHandler對象，表示的是當我這個動態代理對象在調用方法的時候，會關聯到哪個InvocationHandler對象上
代理實例：
        代理公共接口：
            public interface ReadInterface {
    public void reader();
}
        被代理人(客戶)：
            public class person implements ReadInterface{
    @Override
    public void reader() {
        System.out.println("---------如今開始讀書---------");
        System.out.println("---------讀了一章---------");
        System.out.println("---------又讀了一章--------");
        System.out.println("---------這一章節很精彩---------");
        System.out.println("---------讀了一天了---------");
        System.out.println("---------讀完了---------");
    }
}
        代理人：
            public class ProxyRead implements InvocationHandler{
    private Object subject;
    public ProxyRead(Object subject) {
        this.subject = subject;
    }
    public Object createProxy(){
        return Proxy.newProxyInstance(subject.getClass().getClassLoader(),
                subject.getClass().getInterfaces(),this);
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        long begin=System.currentTimeMillis();
        System.out.println("--------萬能代理類開始作事情----------");
        Object obj=method.invoke(subject, args);
        System.out.println("--------萬能代理類作完作事情----------");
        long end=System.currentTimeMillis();
        System.out.println("執行程序花了"+(end-begin)*1.0/1000+"秒");
        return obj;
    }
}
        測試類：
            public class Test {
    public static void main(String[] args) {
        ProxyRead pr=new ProxyRead(new person());
        ReadInterface read=(ReadInterface) pr.createProxy();
        read.reader();
    }
}










將反射機制應用於工廠模式
interface fruit {
    public abstract void eat();
}
class Apple implements fruit {
    public void eat() {
        System.out.println("Apple");
    }
}
class Orange implements fruit {
    public void eat() {
        System.out.println("Orange");
    }
}
class Factory {
    public static fruit getInstance(String ClassName) {
        fruit f = null;
        try {
            f = (fruit) Class.forName(ClassName).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return f;
    }
}
策略模式：將可變的能力設爲接口，在公共的父類中，設爲變量，並調用其方法，另有子類實現接口，並在具體繼承抽象父類時爲接口變量賦值
    抽象父類：
public abstract class Duck {
    private FlyAble flyAble = null;
    public void setFlyAble(FlyAble flyAble) {
        this.flyAble = flyAble;
    }
    public void fly() {
        // 飛對象.飛();
        flyAble.fly();
    }
    public void swim() {
        System.out.println("浮水......");
    }
public abstract void dispaly();
}
    接口：
        public interface FlyAble {
    public void fly();
}
    接口實現：
        public class RocketFly implements FlyAble{
    @Override
    public void fly() {
        System.out.println("藉助火箭飛........");
    }
}
public class WingFly implements FlyAble {
    @Override
    public void fly() {
        System.out.println("用自己翅膀飛.....");
    }
}
    繼承抽象類：
public class RedDuck extends Duck{
     public RedDuck() {
        super.setFlyAble(new WingFly());
    }
    @Override
    public void dispaly() {
         System.out.println("紅頭鴨，頭是紅的");
    }
}
    測試：
        public class Test {
    public static void main(String[] args) {
        test3();
    }
    public static void test3(){
        Duck duck=new RedDuck();     
        //變性的    吱吱叫
        //火箭 綁上去，看一看飛行效果
        duck.setFlyAble(new RocketFly());
        duck.dispaly();
        duck.swim();
        duck.fly();    
    }
}
模板模式：
public  class Benz{
public  void start(){
   System.out.println(「奔馳車啓動」);
}
public void trunLeft(){
   System.out.println(「奔馳車左轉彎」);
}
public void alerm(){
   System.out.println(「奔馳車響笛一聲」);
}
public void stop(){
  System.out.println(「奔馳車停車」);
}
}
public  class BMW{
public  void start(){
   System.out.println(「寶馬車啓動」);
}
public void trunLeft(){
   System.out.println(「寶馬車左轉彎」);
}
public void alerm(){
   System.out.println(「寶馬車響笛一聲」);
}
public void stop(){
  System.out.println(「寶馬車停車」);
}
}
模板：
public  abstract class Car{
public  abstract void start()
    public  abstract void trunLeft();
public  abstract  void alerm();
Public  abstract  void stop();
public  void begin(){
    this.start();
    this.trunLeft();
    this.alerm();
    this.stop();
}
}