java反射

反射：把Java类中的各种成分映射成单独的Java对象进行操作。

类的对象：基于某个类new 出来的对象，也称为实例对象。

类对象：类加载的产物，封装了一个类的所有信息（类名、父类、接口、属性、方法、构造方法）

• Class类—可获取类和类的成员信息
• Field类—可访问类的属性
• Method类—可调用类的方法
• Constructor类—可调用类的构造方法

创建一个测试类

public class Student implements Serializable, Cloneable{
    private String name;
    private int age;

    public Student() {
        System.out.println("无参构造执行了");
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("带参构造执行了");
    }

    private Student(String name) {
        this.name = name;
    }

    //1.无参无返回值的方法
    public void show() {
        System.out.println(this.name + " " + this.age);
    }

    //2.有参无返回值的方法
    public void show(String addr) {
        System.out.println("地址:" + addr);
    }

    //3.无参带返回值的方法
    @Override
    public String toString() {
        return "Student{" +
            "name='" + name + '\'' +
            ", age=" + age +
            '}';
    }

    //4.静态方法
    public static void calcount() {
        System.out.println("计算学生数量");
    }

    //5.私有方法
    private void study() {
        System.out.println("好好学习！");
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

• 实例对象.getClass()
• 类名.calss()
• Class.forName("类的全名称带包名")

[wppay]

public class ReflectionDemo {
    public static void main(String[] args) throws Exception {
        reflectOpe1();
    }

    //1.反射获取类对象
    public static void reflectOpe1() throws Exception {
        //1.创建一个实例对象,调用实例对象的getClass()方法
        Student student = new Student("a", 22);
        Class<?> aClass = student.getClass();
        System.out.println(aClass.hashCode());
        //2.使用类名.class属性
        Class<Student> aClass1 = Student.class;
        System.out.println(aClass1.hashCode());
        //3.Class.forName() 方法获取，类的全名称带包名
        //推荐:编译时不依赖于目标类，耦合性低，灵活，扩展性强
        Class<?> aClass2 = Class.forName("com.fq.lz.Day24.Reflection_4.Student");
        System.out.println(aClass1.hashCode());
    }
}

首先要获取类对象

• 获取所有的公开的构造方法
  • 类对象.getConstructors()
• 获取私有的，保护的，公有的所有构造方法
  • 类对象.getDeclaredConstructors()
• 获取一个无参构造方法
  • 类对象.getConstructor()
  • 使用构造方法创建对象
    • 无参构造对象.newInstance("as", 12);
  • 简写创建对象的方式调用无参构造
    • 类对象.newInstance();

    //2.获取构造方法
    public static void reflectOpe2() throws Exception {
        //1.获取类对象
        Class<?> aClass2 = Class.forName("com.fq.lz.Day24.Reflection_4.Student");
        //2.获取构造方法
        //获取所有的公开的构造方法
        Constructor<?>[] constructors = aClass2.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println(constructor);
        }
        System.out.println("----------------------------");
        //获取私有的，保护的，公有的所有构造方法
        Constructor<?>[] constructors1 = aClass2.getDeclaredConstructors();
        for (Constructor<?> constructor : constructors1) {
            System.out.println(constructor);
        }
        System.out.println("----------------------------");


        //3.获取一个无参构造方法
        Constructor<?> constructor = aClass2.getConstructor();
        //创建一个学生对象
        Student instance = (Student) constructor.newInstance();
        System.out.println(instance.toString());
        System.out.println("----------------------------");

        //4.获取一个带参的构造方法
        Constructor<?> constructor1 = aClass2.getConstructor(String.class, int.class);
        //创建一个学生对象
        Student instance1 = (Student) constructor1.newInstance("as", 12);
        System.out.println(instance1.toString());

        //5.简写创建对象的方式 - 无参构造
        Student o = (Student) aClass2.newInstance();

    }

首先要获取类对象

• 获取所有的公开方法,包括继承的
  • 类对象.getMethods();
• 获取一个无参无返回值的方法
  • 类对象.getMethods("方法名");
  • 调用此方法
    • 1.创建实例对象：类对象.newInstance();
    • 2.无参无返回值对象.invoke(实例对象);
• 获取一个有参无返回值的
  • 类对象.getMethod("方法名", 参数类型.class);
• 获取无参带返回值的
  • 类对象.getMethod("方法名");
  • 获取返回值：无参带返回值对象.nvoke(实例对象);
• 获取静态方法
  • 类对象.getMethod("方法名");
  • 调用，静态方法对象.invoke(null);
• 获取私有方法
  • 类对象.getDeclaredMethod("方法名");
  • 私有方法对象.setAccessible(true); 把私有的访问权限设置为无效
  • 私有方法对象.invoke(实例对象);

         //1.首先拿到类对象
        Class<?> aClass2 = Class.forName("com.fq.lz.Day24.Reflection_4.Student");

        //2.获取所有的公开方法,包括继承的
        Method[] methods = aClass2.getMethods();
        for (Method method : methods) {
            System.out.println(method.toString());
        }

        //3.获取类中所有的方法，包括私有保护默认，不包括继承
        Method[] methods1 = aClass2.getDeclaredMethods();
        for (Method method : methods1) {
            System.out.println(method);
        }

        //4.1获取一个无参无返回值的方法
        Method show = aClass2.getMethod("show");
        //要调用方法要创建对象
        Student instance = (Student) aClass2.newInstance();
        System.out.println(show.invoke(instance));

        //4.2 获取一个有参无返回值的
        Method show2 = aClass2.getMethod("show", String.class);
        show2.invoke(instance, "北京");

        //4.3 获取无参带返回值的
        Method toString = aClass2.getMethod("toString");
        String invoke = (String) toString.invoke(instance);
        System.out.println(invoke);

        //5.获取静态方法
        Method calcount = aClass2.getMethod("calcount");
        calcount.invoke(null);

        //6.获取私有方法
        Method study = aClass2.getDeclaredMethod("study");
        //把私有的访问权限设置为无效
        study.setAccessible(true);
        study.invoke(instance);

首先拿到类对象

• 获取所有的属性
  • 类对象.getDeclaredFields();
• 获取单个属性(私有的)
  • 类对象.getDeclaredField("属性名");
  • 属性对象.setAccessible(true);
  • 属性对象.set(实例对象, 值);

    //4.获取类的属性
    public static void reflectOpe4() throws Exception {
        //1.首先拿到类对象
        Class<?> aClass2 = Class.forName("com.fq.lz.Day24.Reflection_4.Student");
        //2.获取所有的属性
        Field[] declaredFields = aClass2.getDeclaredFields();
        for (Field field : declaredFields) {
            System.out.println(field);
        }
        //3.获取单个属性(私有的)
        Field name = aClass2.getDeclaredField("name");
        Field age = aClass2.getDeclaredField("age");
        Student student = (Student) aClass2.newInstance();
        name.setAccessible(true);
        name.set(student, "asd");
        age.setAccessible(true);
        age.set(student, 20);
        System.out.println(student.toString());
    }

    //5.获取这个类的名字，包名，父类，实现接口，继承的类
    public static void reflectOpe5() throws Exception {
        //1.首先拿到类对象
        Class<?> aClass2 = Class.forName("com.fq.lz.Day24.Reflection_4.Student");
        //全名称
        System.out.println(aClass2.getName());
        //简单名称
        System.out.println(aClass2.getSimpleName());
        //包名
        System.out.println(aClass2.getPackage().getName());
        //类的父类
        System.out.println(aClass2.getSuperclass().getName());
        //类实现的接口
        Class<?>[] interfaces = aClass2.getInterfaces();
        for (Class<?> anInterface : interfaces) {
            System.out.println(anInterface);
        }
    }

1. new关键字 调用构造方法
2. 反序列化 自动不调用构造方法，手动调用
3. 反射 调用构造方法
4. 克隆 不调用构造方法(注意事项：类必须实现Cloneable接口，重写clone方法)

• 浅克隆(浅拷贝)
• 深克隆(深拷贝)

优点：

• 提高了Java程序的灵活性和扩展性，降低了耦合性，提高自适应能力
• 允许程序创建和控制任何类的对象，无需提前硬编码目标类

缺点：

• 性能问题
• 代码维护问题

步骤：先编写接口，创建一个类实现接口，编译这个实现类，拿出来这个类的class文件，删除这个文件(class文件也被删除类)，将保存的class文件重新加入out目录下。创建一个txt文本，保存这个实现类的包名。

接口

public interface CarService {
    void run();
    void turn();
}

实现类

public class BMW implements CarService{
    @Override
    public void run() {
        System.out.println("1");
    }

    @Override
    public void turn() {
        System.out.println("2");
    }
}

测试类

public class Test {
    public static void main(String[] args) throws Exception {
        FileReader fr = new FileReader("cars.txt");
        BufferedReader br = new BufferedReader(fr);
        String data;
        while ((data = br.readLine())!=null){
            Class<?> aClass = Class.forName(data);
            CarService carService = (CarService) aClass.newInstance();
            carService.run();
            carService.turn();
        }
        br.close();
    }
}

txt文件

com.fq.lz.Day25.Demo1.BMW

通过反射获取类的getter和setter方法，对属性进行设置。

• PropertyDescriptor：属性描述符，代表一个属性
• BeanInfo：实体类信息,包含类的信息
• Introspector：工具类

public class TestIntrospector {
    public static void main(String[] args) throws Exception {
        //使用反射创建学生
        Class<?> aClass = Class.forName("com.fq.lz.Day25.Demo2.Student");
        Student student = (Student) aClass.newInstance();

        //1.使用内省技术对属性赋值
        PropertyDescriptor pd1 = new PropertyDescriptor("name", aClass);
        pd1.getWriteMethod().invoke(student, "test");//setName
        //descriptor.getReadMethod();//getName
        PropertyDescriptor pd2 = new PropertyDescriptor("age", aClass);
        pd2.getWriteMethod().invoke(student, 20);

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

        //2.BeanInfo : 获取类的信息
        //Introspector : 内省的工具类
        BeanInfo beanInfo = Introspector.getBeanInfo(aClass);
        //属性：
        // * 狭义的属性：类中的字段
        // * 广义的属性：类中所包含的以getXxx(有返回值)和setXxx(有参数)，isXxx(返回值boolean值)表示这个类中有Xxx属性
        //age int
        //class class java.lang.Class  :  Object类中
        //name class java.lang.String
        PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();
        for (PropertyDescriptor pd : pds) {
            System.out.println(pd.getName() + " " + pd.getPropertyType());
        }
    }
}

什么是设计模式:

• 一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
• 可以简单理解为特定问题的固定解决方法。

好处:

• 使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、重用性。

• 定义一个工厂类，他可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类，简单工厂模式主要负责对象创建的问题。
• 开发中有一个非常重要的原则“开i闭原则”，对拓展开放、对修改关闭。
• 可通过反射进行工厂模式的设计，完成动态的对象创建。

简单工厂四个角色:

• 工厂角色:负责创建具体的产品。
• 父类产品:作为所有产品的父类，使用抽象类、接口表示·
• 子类产品:具体的产品
• 客户程序:使用工厂和产品的程序

//服装类
public abstract class Clothes {
    abstract void prepare();

    abstract void make();

    abstract void sell();
}

public class Trousers extends Clothes {
    @Override
    void prepare() {
        System.out.println("准备Trousers制作的材料");
    }

    @Override
    void make() {
        System.out.println("开始制作");
    }

    @Override
    void sell() {
        System.out.println("销售裤子");
    }
}

public class TShirt extends Clothes{
    @Override
    void prepare() {
        System.out.println("准备TShirt制作的材料");
    }

    @Override
    void make() {
        System.out.println("开始制作");
    }

    @Override
    void sell() {
        System.out.println("销售裤子");
    }
}

//衣服工厂
public class ClothesFactory {
    public static Clothes create(int type) {
        Clothes clothes = null;
        switch (type) {
            case 1:
                clothes = new Trousers();
                break;
            case 2:
                clothes = new TShirt();
                break;
            default:
                System.out.println("类型错误");
                break;
        }
        if (clothes!=null){
            clothes.prepare();
            clothes.make();
            clothes.sell();
        }
        return clothes;
    }
}

public class TestFactory {
    public static void main(String[] args) {
        System.out.println("请输入：1.裤子，2.T恤");
        Scanner scanner = new Scanner(System.in);
        int i = scanner.nextInt();
        switch (i){
            case 1:
                 ClothesFactory.create(1);
                break;
            case 2:
                ClothesFactory.create(2);
                break;
            default:
                System.out.println("输入错误");
                break;
        }
    }
}

存在的问题：再添加一个衣服时，衣服工厂类需要修改，不符合开闭原则

使用反射和配置文件对衣服工厂类进行优化

clothes.propertices

1=com.fq.lz.Day25.Factory.Trousers
2=com.fq.lz.Day25.Factory.TShirt

衣服工厂类

//衣服工厂
public class ClothesFactory {
    private static Properties properties = new Properties();

    static {
        try {
            FileInputStream fis = new FileInputStream("src\\clothes.propertices");
            properties.load(fis);
            fis.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static Clothes create(int type) {
        Clothes clothes = null;
        if (properties.containsKey(String.valueOf(type))) {
            String className = properties.getProperty(String.valueOf(type));
            try {
                clothes = (Clothes) Class.forName(className).newInstance();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        /*switch (type) {
            case 1:
                clothes = new Trousers();
                break;
            case 2:
                clothes = new TShirt();
                break;
            default:
                System.out.println("类型错误");
                break;
        }*/
        if (clothes != null) {
            clothes.prepare();
            clothes.make();
            clothes.sell();
        }
        return clothes;
    }
}

只允许创建一个该类的对象。

实现步骤：

• 1.私有化构造方法
• 2.在类内部创建一个该类的对象
• 3.在类中添加一个公开的静态方法，返回单例对象

方式1：饿汉式(类加载时创建，天生线程安全)

//饿汉式：类加载时对象实例化
// * 优点：线程安全
// * 缺点：生命周期长，占用空间时间长
public class SingleTon {
    //1.私有化构造方法
    private SingleTon() {
    }

    //2.在单例类的内部创建一个对象
    private static final SingleTon SINGLE_TON = new SingleTon();

    //3.添加公开的静态方法
    public static SingleTon getInstance() {
        return SINGLE_TON;
    }

    //测试方法
    public void show() {
        System.out.println("测试方法");
    }
}

class Test {
    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    SingleTon instance = SingleTon.getInstance();
                    System.out.println(instance.hashCode());
                }
            }).start();
        }
    }
}

//懒汉式：使用实例对象时初始化单例对象
// * 优点：节省空间
// * 缺点：解决线程安全问题
public class LazySingleton {
    private LazySingleton() {
    }

    //保证内存可见性和禁止指令重排序
    private volatile static LazySingleton singleTon2 = null;

    public static LazySingleton getInstance() {
        //DCL Double Check Lock 双重检查锁
        //多线程情况下也只需要一次实例化，提高效率
        if (singleTon2 == null) {
            //同步代码块 保证多线程情况下线程同步
            synchronized (LazySingleton.class) {
                //当singleTon2为空时才创建对象，但是多线程情况下，不能保证创建唯一对象
                if (singleTon2 == null) {
                    singleTon2 = new LazySingleton();
                    //1.在堆中开辟空间，给属性赋值默认值 new dup
                    //2.执行构造方法 invokespecial
                    //3.局部变量赋值 a_store
                    //可能执行的顺序会改变
                }
            }
        }
        return singleTon2;
    }

    public void show() {
        System.out.println("显示");
    }
}

class Test2 {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    LazySingleton instance = LazySingleton.getInstance();
                    System.out.println(instance.hashCode());
                }
            }).start();
        }
    }
}

使用时创建，线程安全

//静态内部类写法
public class King {
    //1.私有化构造方法
    private King() {
    }

    //2.在静态内部类中创建对象(不使用静态内部类，不会加载)
    private static class Holder {
        private static final King KING = new King();
    }

    //3.添加公开的静态方法返回对象
    public static King getInstance() {
        return Holder.KING;
    }
}

什么是枚举：

• 枚举是一个引用类型，枚举是一个规定了取值范围的数据类型。
• 枚举变量不能使用其他的数据，只能使用枚举中常量赋值，提高程序安全性。
• 定义枚举使用enum关键字。

注意事项

• 1.枚举中可以包含public static final静态常量(只写常量名)，常量之间用逗号隔开，后面的分号可写可不写
• 2.枚举还可以包含属性和方法,必须在常量的后面，常量后面的分号必须写
• 3.也可以写构造方法，但是必须是私有的，不写也是私有的

public enum Gender {
    ONE,
    TWO;

    private Gender() {
    }

    private int value;

    public void show() {
        System.out.println(value);
    }
}
class Person{
    private int age;
    private Gender gender;

    public Person() {
    }

    public Person(int age, Gender gender) {
        this.age = age;
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "Person{" +
            "age=" + age +
            ", gender=" + gender +
            '}';
    }
}
class Test{
    public static void main(String[] args) {
        Person person = new Person(10, Gender.ONE);
        System.out.println(person.toString());
    }
}

本质上说java引用数据类型只有数组、类、接口

• 枚举是一个终止类，并继承Enum抽象类。
• 枚举中常量是当前类型的静态常量。

package com.fq.lz.Day25.Enum5;

import java.io.PrintStream;

public final class Gender extends Enum
{

	public static final Gender ONE;
	public static final Gender TWO;
	private int value;
	private static final Gender $VALUES[];

	public static Gender[] values()
	{
		return (Gender[])$VALUES.clone();
	}

	public static Gender valueOf(String name)
	{
		return (Gender)Enum.valueOf(com/fq/lz/Day25/Enum5/Gender, name);
	}

	private Gender(String s, int i)
	{
		super(s, i);
	}

	public void show()
	{
		System.out.println(value);
	}

	static 
	{
		ONE = new Gender("ONE", 0);
		TWO = new Gender("TWO", 1);
		$VALUES = (new Gender[] {
			ONE, TWO
		});
	}
}

//枚举单例：只添加一个常量，类加载时就实例化，没有线程安全问题，
// 防止反射破解
public enum SingleTon {
    INSTANCE;

    public void show() {
        System.out.println("show");
    }
}

class Test3{
    public static void main(String[] args) {
        SingleTon instance = SingleTon.INSTANCE;
        SingleTon instance2 = SingleTon.INSTANCE;
        SingleTon instance3 = SingleTon.INSTANCE;
        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());
        System.out.println(instance3.hashCode());
    }
}

什么是注解：

• 注解(Annotation)是代码里的特殊标记, 程序可以读取注解，一般用于替代配置文件。

开发人员可以通过注解告诉类如何运行

• 在Java技术里注解的典型应用是：可以通过反射技术去得到类里面的注解，以决定怎么去运行类。

常见注解：@Override、@Deprecated

定义一个注解：使用@interface 使用注意事项：

• (1) 注解中只能包含属性,属性有括号

• (2) 注解中属性可以写默认值，使用default关键字添加默认值

• (3) 注解中属性的类型只能是5种：
  • 基本类型，字符串类型，class类型，枚举类型，注解类型, 以及这些类型的一维数组
• (4) 如果注解的属性名是value的可以省略
  • @Target(value = ElementType.METHOD)
  • @Target(ElementType.METHOD)

元注解:用来描述注解的注解。

• @Retention 设置注解保留的范围
  • 默认CLASS 字节码文件有，运行时消失
  • RUNTIME 字节码有，运行时有
  • SOURCE 源文件有，字节码没有
• @Target
  • 指定注解用于修饰类的哪个成员。

//定义一个注解：使用@interface
//使用注意事项：
//  (1) 注解中只能包含属性,属性有括号
//  (2) 注解中属性可以写默认值，使用default关键字添加默认值
//  (3) 注解中属性的类型只能是5种：
//     基本类型，字符串类型，class类型，枚举类型，注解类型,
//     以及这些类型的一维数组
//  (4) 如果注解的属性名是value的可以省略
//          @Target(value = ElementType.METHOD)
//          @Target(ElementType.METHOD)

//@Retention 设置注解保留的范围
//     默认CLASS 字节码文件有，运行时消失
//     RUNTIME 字节码有，运行时有
//     SOURCE 源文件有，字节码没有

//@Target：
// * 指定注解用于修饰类的哪个成员。

//6.修改保留级别
@Retention(value = RetentionPolicy.RUNTIME)
//7. 指定注解用于修饰类的哪个成员。一般不改
@Target(value = ElementType.METHOD)
public @interface MyAnnotation {
    //属性写括号,只能是public，不能是静态的
    public String name() default "test";

    //设置默认值
    public int age() default 20;

//    Class<?> CLASS();
//
//    Gender GENDER();
//
//    Test TEST();
}

@interface Test {
}

class Person {
    //5.但是运行的时候就没了
    @MyAnnotation(name = "test", age = 30)
    public void show() throws NoSuchMethodException {
        //使用反射获取注解的信息
        //1.获取类对象
        Class<Person> personClass = Person.class;
        //2.获取方法，由方法获得注解
        Method show = personClass.getMethod("show");
        //3.获取注解信息
        MyAnnotation annotation1 = show.getAnnotation(MyAnnotation.class);
        //4.打印注解的属性
        System.out.println(annotation1.age());
        System.out.println(annotation1.name());
    }
}

class Test2 {
    public static void main(String[] args) throws NoSuchMethodException {
        Person person = new Person();
        //运行错误 因为5，但是元注解可以解决问题见6
        person.show();
    }
}

注解的本质是接口

package com.fq.lz.Day25.Annotation6;

import java.lang.annotation.Annotation;

public interface MyAnnotation
	extends Annotation
{

	public abstract String name();

	public abstract int age();
}

[/wppay]