设计模式分类：        创建型：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
     
       list = new ArrayList
      
       ();        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 Throwableproxy:　　指代我们所代理的那个真实对象method:　　指代的是我们所要调用真实对象的某个方法的Method对象args:　　指代的是调用真实对象某个方法时接受的参数另一个则是 Proxy(Class)Proxy这个类的作用就是用来动态创建一个代理对象的类public static Object newProxyInstance(ClassLoader loader, Class
       [] interfaces, InvocationHandler h) throws IllegalArgumentExceptionloader:　　一个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();}}