反射的扩展和设计模式

通过反射创建对象

public class ReflectNew {
    public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        // 通过反射，创建出一个对象

        // 反射，是通过对象，表示一个类
        // 即一个对象变量，变量名叫: stuClz，它能够表示Student类
        // 所以可以使用stuClz，创建对象
        // 使用类对象的newInstance方法，创建对象。会间接地调用此类中的无参构造
        // 如果无参构造没有权限，会抛异常
        Class<Student> stuClz = Student.class;
        Student student = stuClz.newInstance();

        System.out.println(student);

        System.out.println("----------------");

        // 显式调用Student类的构造器
        Constructor<Student> constructor = stuClz.getConstructor(String.class, String.class, Date.class, String.class);
        Student student2 = constructor.newInstance("张三", "male", new Date(), "大连市");
        System.out.println(student2);
    }
}

反射中方法的调用

public class ReflectInvoke {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        // 通过反射，调用一个对象的方法

        // 反射，是想让程序知道这个类的细节，而不是由程序员确认
        // 所以，也可以让程序动态地，调用由字符串所表示的方法

        // 前提是
        // 1. 获取类对象
        // 2. 由类对象，获取方法
        Class<Student> stuClz = Student.class;
        Method method = stuClz.getMethod("method");

        // 想要让某个对象，调用它的method方法

        // 类中的method方法，已经找到了
        // 但不知道这个method方法，要作用于哪一个对象
        Student student = new Student();

        // 调用student对象的method方法
        // 以前的调用方法:
        // student.method()

        // 到底调的是method方法，还是setName方法，还是getName方法，由一个字符串确定
        // 现在通过反射的调用方法:
        method.invoke(student);

        Method setName = stuClz.getMethod("setName", String.class);
        setName.invoke(student, "张三");

        System.out.println(student);
    }
}

反射中成员变量的使用

public class ReflectField {
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
        // 操作成员变量

        // 反射: 通过一个对象，来表示一个类
        // 可以通过反射，知道这个类中有哪些成员变量

        // 前提
        // 1. 获取类对象
        // 2. 获取这个类中的成员变量
        // 3. 获取成员变量，修改成员变量，必须拥有访问权限。Field是成员变量，跟类有关系。
        // 想要获取(get)或修改(set)某个对象的成员变量，必须要明确指定哪个对象
        // 4. 找到一个对象
        Class<Student> stuClz = Student.class;
        Field name = stuClz.getField("name");

        Student student = new Student();

        // 以前的调用方式
        // student.name = "王五";
        name.set(student, "王五");

        // student.name
        System.out.println(name.get(student));
    }
}

设计模式

工厂方法模式

Factory Method Pattern

两个角色: 第一个角色是产品 第二个角色是工厂。工厂中有一个方法，当调用这个方法之后，会得到一个产品 这就是工厂方法模式

public class Product {
    // 产品名称
    private String name;

    // 产地
    private String originPlace;

    @Override
    public String toString() {
        return "Product{" +
                "name='" + name + '\'' +
                ", originPlace='" + originPlace + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

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

    public String getOriginPlace() {
        return originPlace;
    }

    public void setOriginPlace(String originPlace) {
        this.originPlace = originPlace;
    }
}

public class Factory {

    // 生产

    public static Product produce() {

        Product product = new Product();

​

        product.setName("Apple iPhone 13");

        product.setName("Califonia");

​

        return product;

    }

}

单例模式

Singleton Pattern 有时也叫单件模式 类是对象的模板，可以通过类，创建一个对象 希望这个类，有且只有一个实例 一个公司只有一个老板 一个员工只有一个管理者...

单例模式要解决的问题是: 要在程序中保证某个类的实例有且只有一个

1. 不能随意调用构造方法

2. 由本类中保持对于这有且只有一个的对象的保存 所以需要使用到static关键字，因为这个关键字与类有关系，与对象没关系，而且类只会加载一次

3. 可以通过一个static方法，来获取这个对象