Web学习笔记 - 第009天

创建对象

1. 构造器创建对象

        Student stu1 = new Student("kygo", 100);
        System.out.println(stu1);

2. 通过克隆创建对象(内存复制)
实现Cloneable接口，重写clone()方法

    @Override
    public Object clone() {
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException();
        }
    }

测试

        Student stu2 = (Student) stu1.clone();
        System.out.println(stu2);

3. 通过反序列化创建对象(从流中读取对象)
实现序列化接口Serializable

        ByteArrayOutputStream out = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(out);
        oos.writeObject(stu2);
        ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(in);
        Student stu3 = (Student) ois.readObject();
        System.out.println(stu3);

4. 通过反射(reflection)创建对象
拿到一个类的原始数据类对象
1.根据路径

        Class clazz1 = Class.forName("com.kygo.Student");

2.用类.class

        Class clazz2 = Student.class;

3.用类对象实例的getClass()方法

        Class clazz3 = stu3.getClass();

根据类的类对象可以创建这个类的对象实例

        Student stu4 = (Student) clazz1.newInstance();

根据类的类对象使用getConstructor()方法的到这个类的构造器，使用构造器可以创建对象

        Constructor constructor = clazz2.getConstructor(String.class, int.class);
        Student stu5 = (Student) constructor.newInstance("wang Dachui", 18);

测试：

        Class clazz1 = Class.forName("com.kygo.Student");
        Class clazz2 = Student.class;
        Class clazz3 = stu3.getClass();
        // System.out.println(clazz1 == clazz2);   // true
        // System.out.println(clazz2 == clazz3);   // true
        Student stu4 = (Student) clazz1.newInstance();
        System.out.println(stu4);
        // System.out.println(stu4.getName());
        Constructor constructor = clazz2.getConstructor(String.class, int.class);
        Student stu5 = (Student) constructor.newInstance("wang Dachui", 18);
        System.out.println(stu5);
        // System.out.println(stu5.getName());
        // System.out.println(stu5.getAge());
        Constructor[] constructors = clazz3.getConstructors();
        for (Constructor temp : constructors) {
            Student stu6 = (Student) temp.newInstance();
            System.out.println(stu6);
        }

设计模式

单例

单例 - 让一个类只能创建出一个对象(服务器上常用)

1. 将构造器私有(不允许直接使用构造器创建对象)
2. 通过公开的静态的方法向外界返回该类的唯一实例

饿汉式单例

public class StudentManager {
    private static StudentManager instance = new StudentManager();
    
    // ...
    
    private StudentManager() {
    }
    
    public static StudentManager getInstance() {
        return instance;
    }
    
    // ...
}

懒汉式单例(懒加载单例)

public class StudentManager {
    private static StudentManager instance = null;
    
    // ...
    
    private StudentManager() {
    }
    
    public static synchronized StudentManager getInstance() {
        if (instance == null) {
            instance = new StudentManager();
        }
        return instance;
    }
    
    // ...
}

登记式单例

public class ServiceFactory {
    private static Map, Object> map = new HashMap<>();
    // 登记式单例
    static {
        map.put(DeptService.class, 
                ServiceProxy.getProxyInstance(new DeptServiceImpl()));
        map.put(EmpService.class, 
                ServiceProxy.getProxyInstance(new EmpServiceImpl()));
    }
    
    private ServiceFactory() {
        throw new AssertionError();
    }
    
    public static Object factory(Class serviceType) {
        return map.get(serviceType);
    }
}

一般类里面没有状态属性都可以改造成单例模式类

简单工厂模式

简单工厂模式(静态工厂模式)
将对象的实例化过通过工厂方法隐藏起来
使得对象的使用者可以和具体的对象以及创建对象的过程解耦合

例子1:在工厂用构造器创建对象

工厂类：

public class FruitFactory {
    
    public static Fruit factory(String type) {
        Fruit fruit = null;
        switch (type.toLowerCase()) {
        case "apple":
            fruit = new Apple();
            break;
        case "banana":
            fruit = new Banana();
            break;
        case "durian":
            fruit = new Durian();
            break;
        }
        return fruit;
    }
}

测试：

        Fruit apple = FruitFactory.factory("apple");
        Fruit durian = FruitFactory.factory("durian");
        Fruit grape = FruitFactory.factory("grape");
        System.out.println(apple);
        System.out.println(durian);
        System.out.println(grape);

例子2：使用反射

工厂类：

public class FruitFactory {
    
    public static Fruit factory(String className) {
        try {
            Class clazz = Class.forName(className);
            return (Fruit) clazz.newInstance();
        } catch (Exception e) {
            // throw new RuntimeException();
            return null;
        }
    }
    
    public static Fruit factory(Class fruitType) {
        try {
            return (Fruit) fruitType.newInstance();
        } catch (Exception e) {
            throw new RuntimeException();
        }
    }
}

测试：

        Fruit apple = FruitFactory.factory(Apple.class);
        Fruit durian = FruitFactory.factory(Durian.class);
        Fruit grape = FruitFactory.factory("com.kygo.Grape");
        System.out.println(apple);
        System.out.println(durian);
        System.out.println(grape);

动态代理

JDK 1.3引入了动态代理机制 - 可以通过反射的方式动态生成代理对象
InvocationHandler - invoke(Object, Method, Object[])
Proxy类 - newProxyInstance(ClassLoader, Class[], InvocationHandler)

旧做法：创建代理类并实现要代理的类相同的接口，重写接口方法，在要代理的方法，添加自己的东西（日志等）
例子1：考生找枪手代考
考生接口：

public interface Candidate {

    public void joinExam();
}

人类：

public class Person {
    protected String name;
    
    public Person(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
}

懒学生：

public class LazyStudent extends Person implements Candidate {
    
    public LazyStudent(String name) {
        super(name);
    }

    @Override
    public void joinExam() {
        System.out.println("姓名: " + name);
    }
}

枪手：

public class ExamAgent extends Person implements Candidate {
    private Candidate target;
    
    public ExamAgent(String name) {
        super(name);
    }
    
    public void setTarget(Candidate target) {
        this.target = target;
    }
    
    @Override
    public void joinExam() {
        target.joinExam();
        System.out.println(name + "奋笔疾书答案.");
        System.out.println(name + "答题完毕交卷.");
    }
}

测试：

        LazyStudent student = new LazyStudent("王大锤");
        ExamAgent agent = new ExamAgent("骆昊");
        agent.setTarget(student);
        agent.joinExam();

现在：

• 第一步　创建代理类并实现InvocationHandler的接口

class ListProxy implements InvocationHandler

• 第二步　添加被代理对象的属性，和代理对象的构造器 - 单例

        private Object target; // 被代理的对象(目标对象)
        
        private ListProxy(Object target) {
            this.target = target;
        }

• 第二步 实现静态方法getProxyInstance()拿到代理类对象
  通过Proxy工具类的newProxyInstance方法生成动态代理

        public static  Object getProxyInstance(Object target) {
            Class clazz = target.getClass();
            // 通过Proxy工具类的newProxyInstance方法生成动态代理
            // 第一个参数是被代理对象的类加载器
            // 第二个参数是被代理对象实现的接口(被代理对象和代理对象要实现相同的接口)
            // 第三个参数是实现了InvocationHandler接口的对象
            return Proxy.newProxyInstance(clazz.getClassLoader(), 
                    clazz.getInterfaces(), new ListProxy(target));
        }

• 第三步　重写回调方法invoke()
  InvocationHandler接口(单方法接口/函数式接口)中的invoke方法是一个回调方法
  当执行被代理对象target的任何一个方法时不是直接执行而是回调代理对象的invoke方法
  该方法的第二个参数代表了需要执行的方法 第三个参数是执行方法时传入的参数

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable

        // InvocationHandler接口(单方法接口/函数式接口)中的invoke方法是一个回调方法
        // 当执行被代理对象target的任何一个方法时不是直接执行而是回调代理对象的invoke方法
        // 该方法的第二个参数代表了需要执行的方法 第三个参数是执行方法时传入的参数
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            // 被代理对象的所有方法都要通过代理对象来帮它调用执行
            // 调用被代理对象的方法 第一个参数是被代理的对象 第二个参数是方法参数
            // 如果被代理对象当前要执行的方法没有参数那么args的值就是null
            // 如果被代理对象的方法有返回值那么retValue就保存该返回值
            // 如果被代理对象的方法没有返回值那么retValue的值就是null
            Object retValue = method.invoke(target, args);
            // 如果执行的方法名以add、remove、clear、retain打头
            // 那么通过下面代码给这些方法增加在控制台打印日志的功能
            String methodName = method.getName();
            // System.out.println("正在执行" + methodName + "方法");
            if (methodName.startsWith("add") || methodName.startsWith("remove")
                    || methodName.startsWith("clear") || methodName.startsWith("retain")) {
                if (target instanceof List) {
                    List list = (List) target;
                    // 以下代码就是代理对象附加的行为(被代理对象没有的行为)
                    System.out.println("Size = " + list.size());
                    System.out.println(Arrays.toString(list.toArray()));
                }
            }
            // 将之前执行被代理对象的方法得到的返回值返回
            return retValue;
        }   
    }