反射、设计模式：第九次实验室报告

类的加载：当程序要使用某个类时，如果该类还未加载到内存中，则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。

1、加载：就是指将class文件读入内存，并为之创建一个Class对象。
任何类被使用时系统都会建立一个Class对象。
2、连接：
验证 是否有正确的内部结构，并和其他类协调一致。
准备 负责为类的静态成员分配内存，并设置默认初始化值。
解析 将类的二进制数据中的符号引用替换为直接引用。
3、初始化。

类的初始化时机：

1、访问类的静态变量，或者为静态变量赋值
2、调用类的静态方法
3、使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
4、初始化某个类的子类（创建子类，必先创建父类）
5、直接使用java.exe命令来运行某个主类

类加载器：
组成：根类加载器：也被称为引导类加载器，负责java核心类的加载。
扩展类加载器：负责JRE的扩展目录中jar包的加载。
------------------->在JDK中JRE的lib目录下ext目录。
系统类加载器：负责在JVM启动时加载来自java命令的class文件，以及classpath环境变量所指定的jar包和类路径。(我们定义的类就在这里加载)

反射

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
要想解剖一个类，必须要先获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法，所以要先获取到每一个字节码文件对应的Class类型的对象。

反射：就是使用class文件对象，使用对象的成员变量，构造方法和方法。
要想使用反射，就必须获得class文件对象，其实也就是得到Class类的对象

获取class文件对象的方法：
1、Object类的getClass方法
2、数据类型的静态属性的class
3、Class类中的静态方法：
static Class<?> forName(String className)

第一种方式：

People p1=new People();
        People p2=new People();
        Class c1=p1.getClass();
        Class c2=p2.getClass();
        System.out.println(p1==p2);//false
        System.out.println(c1==c2);//true

方式2：

 Class c3=People.class;
        System.out.println(c1==c3);//true

方式3：

        //static Class<?> forName(String className)    className为类的全路径：包名+类名
        Class c4=Class.forName("reflect.People");
        System.out.println(c1==c4);//true

在何种场景下用？
1；自己玩：任选一种，第二种比较方便
2、开发：第三种方法，因为其括号内是一个字符串，而不是一个类，所以我们可以把字符串配置到配置文件中。

注意：Method[] methods=c.getMethods();----------获取自己以及父类的所有公共方法。
而构造器和字段的获取都是自身的公共方法。

通过配置文件并用反射运行类的方法:

public static void main(String[] args) throws Exception {
        //用属性类配置文件
        Properties p=new Properties();
        p.put("className","reflect.Teacher");
        p.put("methodName","love");
        PrintStream ps=new PrintStream("class.txt");
        p.list(ps);
        ps.close();

        //用属性类加载文件
        p=new Properties();
        InputStream is=new FileInputStream("class.txt");
        p.load(is);
        is.close();
        String className=p.getProperty("className");
        String methodNmae=p.getProperty("methodName");

        Class c=Class.forName(className);
        Constructor con=c.getConstructor();
        Object obj=con.newInstance();
        Method method=c.getMethod(methodNmae);
        method.invoke(obj);
    }

给ArrayList< Integer >集合中传入一个字符串数据(一般方法肯定不行，但是反射可以):

public static void main(String[] args) throws Exception {
        ArrayList<Integer> array=new ArrayList<>();
        //ArrayList里的泛型是给编译器看的，但是在底层add(E e)里的参数依然是Object类型,它进行了一步强转成泛型指定的类型
        Class c=array.getClass();
        Method method=c.getMethod("add",Object.class);
        method.invoke(array,"hello");
        System.out.println(array);//成功导入字符串类型
    }

动态代理: 在程序运行过程中产生的这个对象，而这个对象其实是涉及反射的内容。所以动态代理其实就是通过反射来生成一个代理。
接口：

public interface User {
    public abstract void add();

    public abstract void delete();

    public abstract void update();

    public abstract void find();
}

实现类：

public class UserDao implements User{
    public void add(){
        System.out.println("添加功能");
    }

    public void delete(){
        System.out.println("删除操作");
    }

    public void update(){
        System.out.println("修改操作");
    }

    public void find(){
        System.out.println("查找操作");
    }
}

重点：实现InvocationHandler接口。

public class MyInvocationHandler implements InvocationHandler{
    private Object target;
    public MyInvocationHandler(Object target){
        this.target=target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Exception {
        System.out.println("权限校验");
        Object result=method.invoke(target,args);
        System.out.println("日志记录");
        return result;//返回的是动态代理对象
    }
}

测试类：

public class Test {
    public static void main(String[] args) {
        User ud=new UserDao();
        MyInvocationHandler handler=new MyInvocationHandler(ud);
        User proxy=(User) Proxy.newProxyInstance(ud.getClass().getClassLoader(),ud.getClass().getInterfaces(),handler);//必须强转，要不然无法使用下面的方法
       proxy.add();
       proxy.delete();
       proxy.update();
       proxy.find();
    }
}

具体统计总结一下javase涉及到的设计模式：
常见设计模式：

简单工厂模式和工厂方法模式（接口）
模板设计模式（抽象类）
装饰设计模式（IO流）
单例设计模式（多线程）
适配器模式（GUI）

面向对象思想设计原则：（高内聚，低耦合）

单一职责原则：只有一个职责，对外只提供一种功能，引起类变化的原因只有一个。

开闭原则：核心思想：一个对象对扩展开放，对修改关闭。
对类的改动是通过增加代码进行的，而不是修改现有代码。（借助抽象和多态）。

里氏替换原则：核心思想：在任何父类出现的地方都可以用它的子类代替。
同一继承体系中的对象应该有共同行为特征。

依赖注入原则：核心思想：要依赖于抽象，不要依赖于具体实现。
在应用程序中，所有的类如果使用或依赖于其他类，则应该依赖这些类的抽象类，而不是这些类的具体类。为了实现这一原则，就要求我们在编程的时候针对抽象类或者接口编程。

接口分离原则：核心思想：不应该强迫程序依赖它们不需要使用的方法。
一个接口不需要提供太多的行为，一个接口应该只提供一种对外的功能，不应该把所有的操作都封装到一个接口中。

迪米特原则：核心思想：一个对象应当对其他对象尽可能少的了解。
降低各个对象之间的耦合，提高系统的可维护性，在模块之间应该只通过接口编程，而不理会模块的内部工作原理，它可以使各个模块耦合度降到最低，促进软件的复用。

设计模式的分类：
1、创建型模式 对象的创建
2、结构型模式 对象的组成（结构）
3、行为型模式 对象的行为
举例：
创建型模式：简单工厂模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式、单例
结构型模式：外观模式、适配器模式、代理模式、装饰模式、桥接模式、组合模式、享元
行为型模式：模板方法、观察者模式、状态模式、职责链模式、命令模式、访问者模式、策
略模式、备忘录模式、迭代器模式、解释器模式

1、模板设计模式：通俗点说就是提供一个模板，使用者只需实现其中的部分功能即可，减少代码的重复。
具体操作：在模板类（抽象类）中构造抽象方法，新建一个类让其继承于摸板类，实现抽象
方法。
优点：使用模板设计方法模式，在定义算法骨架的同时，可以很灵活的实现具体的算法，满足用户灵活多变的需求。
缺点：如果算法骨架有修改的话，则需要修改抽象类。

2、简单工厂模式：又叫静态工厂方法模式，它定义一个具体的工厂类来创建一些类的实例。
优点：客户端不需要负责对象的创建，从而明确了各个类的职责。
缺点：这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期的维护。

3、工厂方法模式：该模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继承抽象工厂的具体类实现。
优点：客户端不需要负责对象的创建，从而明确了各个类的职责。如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性。
缺点：需要额外的编写代码，增加了工作量。

4、单例设计模式：确保类在内存中只有一个对象，该实例必须自动创建，并且对外提供。
优点：在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象，单利模式无疑可以提高系统的性能。
缺点：没有抽象层，因此扩展很难。
职责过重，在一定的程度上违背了单一职责。
饿汉式和懒汉式：

饿汉式：一加载就创建对象。

public class Student {
    private static Student s=new Student();

    private Student(){
    }

    public static Student getStudent(){
        return s;
    }

    public void dowhat(){
        System.out.println("好好学习");
    }
}

懒汉式：使用时才创建对象。

public class Teacher {
    private static Teacher t=null;

    private Teacher(){
    }
    //牵扯到线程安全问题
    public synchronized static Teacher getTeacher(){
        if(t==null){
            t=new Teacher();
        }
        return t;
    }

    public void dowhat(){
        System.out.println("教书育人");
    }
}

应用场景：
开发：饿汉式（不会出问题）
面试：懒汉式（有考点）：
-------懒加载（延迟加载）
------线程安全问题：
-------------------是否多线程环境
-------------------是否共享数据
-------------------是否多条语句操作共享数据
请参照上面的懒汉式代码（synchronized）学习。