基础加强·反射 和 枚举
类的加载概述和加载时机
* A：类的加载概述
* 当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载、连接、初始化来实现对这个类的初始化
* 加载
* 就是指将 class文件读入内存，并为之创建一个 Class对象，任何类被使用时系统都会建立一个 Class对象
* 连接
* 验证：是否有正确的内部结构和其他类协调一致
* 准备：负则为类的静态成员分配内存，并设置默认初始化值
* 解析：将类的二进制数据中的符号引用替换为直接引用
* 初始化
* 就是我们以前讲过的初始化步骤
* B：加载时机
* 创建类的实例
* 访问类的静态变量，或者为静态变量赋值
* 调用类的静态方法
* 使用反射方式来强制创建某个类或接口对应的 java.lang.Class对象
* 初始化某个类的子类
* 直接使用 java.exe命令来运行某个主类
类加载器的概述和分类
* A：类加载器的概述
* 负则将 .class文件加载到内存中，并为之生成对应的 Class对象。
* B：类加载器的分类
* Bootstrap ClassLoader ：根类加载器
* Extension ClassLoader ：扩展类加载器
* System ClassLoader ：系统类加载器
* C：类加载器的作用
* Bootstrap ClassLoader ：根类加载器
* 也被称为引导类加载器，负则Java核心类的加载
* 比如 System、String等，在 JDK中 JRE的 lib目录下的 rt.jar文件中
* Extension ClassLoader ：扩展类加载器
* 负则 JRE的扩展目录中 jar包的加载
* 在 JDK中 JRE的 lib目录下 ext目录
* System ClassLoader ：系统类加载器
* 负则在 JVM启动时加载来自 java命令的 class文件，以及 classpath环境变量所指定的 jar包和类路径
反射概述
* A：反射概述
* Java反射机制时在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法
* 对于任意一个对象，都能够调用它的任意一个方法和属性
* 这种动态获取的信息以及动态调用对象的方法的功能称为 Java语言的反射机制
* 想要解剖一个类，必须先要获取到该类的字节码文件对象
* 而解剖使用的就是 Class类中的方法，所以先要获取到每一个字节码文件对应的 Class类型的对象
* B：三种方式
* a：Object类的 getClass()方法，判断两个对象是否是同一个字节码文件
* b：静态属性 class，锁对象
* c：Class类中静态方法 forName()，读取配置文件
* C：案例演示
* 获取 class文件对象的三种方式
package com.heima.reflect; import com.heima.bean.Person; public class Demo1_Reflect { public static void main(String[] args) throws ClassNotFoundException { Class clazz1 = Class.forName("com.heima.bean.Person"); // 源文件阶段获取 Class clazz2 = Person.class; // 字节码阶段获取 Person person = new Person(); Class clazz3 = person.getClass(); // 通过对象反向获取 System.out.println(clazz1 == clazz2); // true System.out.println(clazz3 == clazz2); // true，都是同一个字节码文件 } }
Class.forName()读取配置文件
* 榨汁机（Juicer）榨汁的案例
* 分别有水果（Fruit）、苹果（Apple）、香蕉（Banana）、橘子（Orange）、榨汁（squeeze）
package com.heima.reflect; import java.io.BufferedReader; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; public class Demo2_Reflect { public static void main(String[] args) throws IOException, Exception { // demo1(); // 多态 // demo2(); // 反射 } public static void demo2() throws FileNotFoundException, ClassNotFoundException, IOException, InstantiationException, IllegalAccessException { // 用反射和配置 BufferedReader br = new BufferedReader(new FileReader("config.properties")); // 创建带缓冲的字符输入流 Class clazz = Class.forName(br.readLine()); // 根据整行读取的内容获取字节码文件 Fruit fruit = (Fruit) clazz.newInstance(); // 用字节码对象来创建实例,会自动提升为Object,需要强转 Juicer j = new Juicer(); j.run(fruit); } public static void demo1() { // 用多态 Juicer j = new Juicer(); // 购买榨汁机 j.run(new Apple()); // 向榨汁机中放入苹果 j.run(new Orange()); // 父类引用指向子类对象 } } interface Fruit { // 创建接口 public void squeeze(); // 定义方法 } class Apple implements Fruit{ public void squeeze() { System.out.println("榨出一杯苹果汁"); } } class Orange implements Fruit{ public void squeeze() { System.out.println("榨出一杯橘子汁"); } } class Juicer { public void run(Fruit f) { // 多态 f.squeeze(); } }
通过反射获取带参构造方法并使用
* Constructor
* Class类的 newInstance()方法是使用该类无参的构造函数创建对象
如果要通过有参构造创建对象，可以调用Class类的getConstructor(String.class, int,class)方法获取构造函数，然后再调用 Constructor的 newInstance()方法
package com.heima.reflect; import java.lang.reflect.Constructor; import com.heima.bean.Person; public class Demo3_Constructor { public static void main(String[] args) throws Exception { Class clazz = Class.forName("com.heima.bean.Person"); //Person p = (Person)clazz.newInstance(); // 空参构造，Class的newInstance //System.out.println(p); Constructor c = clazz.getConstructor(String.class, int.class); // 获取有参构造 Person p = (Person) c.newInstance("张三", 23); // 有参构造，Constructor的newInstance System.out.println(p); } }
通过反射获取成员变量并使用
* Field
* Class,getField(String)方法可以获取类中指定的字段（可见的）
如果是私有的可以用 getDeclaredField(String)方法获取，通过 set(obj, String)方法可以设置指定对象上该字段的值
如果是私有的需要先调用 setAccessible(true)设置访问权限，用获取的指定的字段调用 get(obj)可以获取指定对象中该字段的值
package com.heima.reflect; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import com.heima.bean.Person; public class Demo4_Field { public static void main(String[] args) throws Exception { Class clazz = Class.forName("com.heima.bean.Person"); Constructor c = clazz.getConstructor(String.class, int.class); // 获取有参构造 Person p = (Person) c.newInstance("张三", 23); // 通过有参构造创建对象 Field f = clazz.getDeclaredField("name"); // 获取姓名的字段，暴力反射获取 f.setAccessible(true); // 去除私有权限 f.set(p, "李四"); // 修改姓名的值 System.out.println(p); } }
通过反射获取方法并使用
* Method
* Class.getMethod(String, Class ...) 和 Class.getDeclaredMethod(String, Class ...)方法可以获取类中指定的方法
调用 invoke(Object, Obejct ...) 执行获取到的方法
package com.heima.reflect; import java.lang.reflect.Constructor; import java.lang.reflect.Method; import com.heima.bean.Person; public class Demo5_Method { public static void main(String[] args) throws Exception { Class clazz = Class.forName("com.heima.bean.Person"); Constructor c = clazz.getConstructor(String.class, int.class); // 获取有参构造 Person p = (Person) c.newInstance("张三", 23); // 通过有参构造创建对象 Method m = clazz.getMethod("eat"); // 获取eat方法 m.invoke(p); // 传入对象 Method m2 = clazz.getMethod("eat", int.class); m2.invoke(p, 10); // 传入对象和参数 } }
通过反射越过泛型检查
* 在ArrayList<Integer>这个集合中添加 字符串元素
package com.heima.test; import java.lang.reflect.Method; import java.util.ArrayList; public class Test1 { public static void main(String[] args) throws Exception { ArrayList<Integer> list = new ArrayList<Integer>(); // 创建泛型为Integer的集合对象 list.add(111); // 向集合内添加int型数字 list.add(222); // list.add("abc"); // 泛型只在编译器有效，在运行期会被擦除 Class clazz = Class.forName("java.util.ArrayList"); // 获取到字节码对象 Method m = clazz.getMethod("add", Object.class); // 获取add方法 m.invoke(list, "abc"); // 调用add方法添加字符串 System.out.println(list); } }
练习
* 通过反射写一个通用的设置某个对象的某个属性为指定值
package com.heima.test; import java.lang.reflect.Field; public class Tool { // 此方法可将obj对象中名为propertyName的属性的值设置为value public void setProperty(Object obj, String propertyName, Object value) throws Exception, SecurityException { Class clazz = obj.getClass(); // 获取字节码对象 Field f = clazz.getDeclaredField(propertyName); // 暴力反射获取字段 f.setAccessible(true); // 设置权限 f.set(obj, value); // 修改值 } }
package com.heima.test; public class Test2 { public static void main(String[] args) throws Exception { Student s = new Student("张三", 23); // 创建对象 System.out.println(s); Tool t = new Tool(); // 创建工具类对象 t.setProperty(s, "name", "李四"); // 传入要修改的对象，字段 和 值 System.out.println(s); } } class Student { private String name; private int age; public Student() { super(); } public Student(String name, int age) { super(); this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "Student [name=" + name + ", age=" + age + "]"; } }
练习
* 写一个 Properties格式的配置文件，配置类的完整名称
* 写一个程序，读取这个配置文件，获得类的完整名称并加载这个类，用反射的方式运行 run()方法
package com.heima.test; public class DemoClass { public void run() { System.out.println("Welcome to China"); } }
package com.heima.test; import java.io.BufferedReader; import java.io.FileReader; public class Test3 { public static void main(String[] args) throws Exception { BufferedReader br = new BufferedReader(new FileReader("xxx.properties")); // 创建输入流，关联xxx.properties Class clazz = Class.forName(br.readLine()); // 读取配置文件中的类名，获取字节码对象 DemoClass dc = (DemoClass) clazz.newInstance(); // 通过字节码文件创建对象 dc.run(); // 调用DemoClass中的方法 } }
动态代理的概述和实现
* A：动态代理概述
* 代理：本来应该自己做的事情，请了别人来做，被请的人就是代理对象
* 举例：春节回家，让人代买火车票
* 动态代理：在程序运行过程中产生的代理对象
* 在Java中的 java.lang.reflect 包下提供了一个 Proxy类和一个 InvocationHandler接口，通过使用这个类和接口就可以生成动态代理对象
* JDK提供的代理只能针对接口做代理，我们有更强大的代理 cglib
* public static Objevt newProxyInstance(ClassLoader loader, Class<?>[ ] interface, InvocationHandler h)
* 最终会调用 InvocationHandler的方法
* InvocationHandler Object invoke(Object proxy, Method method, Object[ ] args)
package com.heima.invocation; public interface User { public void add(); public void delete(); }
package com.heima.invocation; public class UserImp implements User { @Override public void add() { //System.out.println("权限校验"); System.out.println("添加功能"); //System.out.println("日志记录"); } @Override public void delete() { //System.out.println("权限校验"); System.out.println("删除功能"); //System.out.println("日志记录"); } }
package com.heima.invocation; public interface Student { public void login(); public void submit(); }
package com.heima.invocation; public class StudentImp implements Student{ @Override public void login() { System.out.println("登录"); } @Override public void submit() { System.out.println("提交"); } }
package com.heima.invocation; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; 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 Throwable { System.out.println("权限校验"); method.invoke(target, args); // 执行被代理target对象的方法 System.out.println("日志记录"); return null; } }
package com.heima.invocation; import java.lang.reflect.Proxy; public class Test { public static void main(String[] args) { // demo1(); // demo2(); } public static void demo2() { StudentImp si = new StudentImp(); si.login(); si.submit(); System.out.println("-----------"); MyInvocationHandler m = new MyInvocationHandler(si); Student s = (Student)Proxy.newProxyInstance(si.getClass().getClassLoader(), si.getClass().getInterfaces(), m); s.login(); s.submit(); } public static void demo1() { UserImp ui = new UserImp(); ui.add(); ui.delete(); System.out.println("-------------"); User u = (User)Proxy.newProxyInstance( ui.getClass().getClassLoader(), ui.getClass().getInterfaces(), new MyInvocationHandler(ui)); u.add(); u.delete(); } }
模板设计模式
* A：模板设计模式的概述
* 模板设计模式就是定义一个算法的骨架，而将具体的算法延迟到子类中来实现
* B：优点和缺点
* a：优点
* 使用模板方法模式，在定义算法骨架的同时，可以很灵活的实现具体的算法，满足用户灵活多变的需求
* b：缺点
* 如果算法骨架有修改的话，就需要修改抽象类
* C：现在已经学了的设计模式
* 装饰、单例、简单工厂、工厂方法、适配器、模板
package com.heima.template; public class Demo_Template { public static void main(String[] args) { Demo d = new Demo(); System.out.println(d.getTime()); } } abstract class GetTime { public final long getTime() { long start = System.currentTimeMillis(); code(); long end = System.currentTimeMillis(); return end - start; } abstract public void code(); // 把code()留到子类中去写 } class Demo extends GetTime { @Override public void code() { int i = 0; while (i < 1000000) { System.out.println("x"); i++; } } }
自己实现枚举类
* A：枚举概述
* 是指将变量的值全部列出来，变量的值只限于列举出来的值的范围内
* 举例：一周只有7天，一年只有12个月等
* B：回想单例设计模式
* 单例类是一个类一个实例
* C：案例演示
* 自己实现枚举类
* D：JDK5新特性
* 自动拆装箱、泛型、可变参数、静态导入、增强for循环、互斥锁、枚举
package com.heima.enumeration; public class Week1 { public static final Week1 MON = new Week1(); // 使用第三种单例设计模式 public static final Week1 TUE = new Week1(); public static final Week1 WED = new Week1(); private Week1() {} // 私有构造，不让其他类创建本类对象 }
package com.heima.enumeration; public class Week2 { public static final Week2 MON = new Week2("周一"); public static final Week2 TUE = new Week2("周二"); public static final Week2 WED = new Week2("周三"); private String name; // 定义内部变量 public Week2(String name) { // 私有有参构造，此时没有声明空参构造 super(); this.name = name; } public String getName() { return name; } }
package com.heima.enumeration; public abstract class Week3 { public static final Week3 MON = new Week3("周一") { // Week3的匿名内部子类，重写 show()方法 public void show() { System.out.println("周一"); } }; public static final Week3 TUE = new Week3("周二"){ public void show() { System.out.println("周二"); } }; public static final Week3 WED = new Week3("周三"){ public void show() { System.out.println("周三"); } }; private String name; public Week3(String name) { // 有参构造 super(); this.name = name; } public String getName() { return name; } public abstract void show(); // 枚举类内存在抽象类 }
package com.heima.enumeration; public class Demo1_Enum { public static void main(String[] args) { // demo1(); // demo2(); // demo3(); } public static void demo3() { Week3 mon = Week3.MON; mon.show(); System.out.println(mon.getName()); } public static void demo2() { Week2 mon = Week2.MON; System.out.println(mon.getName()); } public static void demo1() { Week1 mon = Week1.MON; Week1 tue = Week1.TUE; Week1 wed = Week1.WED; } }
通过enum实现枚举类
* A：案例演示
* 通过enum实现枚举类
package com.heima.enumeration2; public enum Week1 { // 枚举类会自动完善toString,并私有构造 Mon,TUE,WED; }
package com.heima.enumeration2; public enum Week2 { MON("星期一"),TUE("星期二"),WED("星期三"); // 通过有参构造创建对象 private String name; // 定义内部变量 private Week2(String name) { // 有参构造 this.name = name; } public String getName() { return name; } }
package com.heima.enumeration2; public enum Week3 { MON("星期一"){ // 通过匿名类重写抽象方法 @Override public void show() { System.out.println("周一"); } }, TUE("星期二"){ @Override public void show() { System.out.println("周二"); } }, WED("星期三"){ @Override public void show() { System.out.println("周三"); } }; private String name; private Week3(String name) { this.name = name; } public String getName() { return name; } public abstract void show(); // 定义抽象方法 }
package com.heima.enumeration2; public class Demo1_Enum { public static void main(String[] args) { // demo1(); // demo2(); // demo3(); // demo4(); } public static void demo4() { Week3 mon = Week3.TUE; switch (mon) { case MON: { System.out.println("周一"); break; } case TUE: { System.out.println("周二"); break; } default: throw new IllegalArgumentException("Unexpected value: " + mon); } } public static void demo3() { Week3 mon = Week3.MON; mon.show(); System.out.println(mon.getName()); } public static void demo2() { Week2 mon = Week2.MON; System.out.println(mon.getName()); } public static void demo1() { Week1 mon = Week1.Mon; System.out.println(mon); } }
枚举类的注意事项
* A：案例演示
* 定义枚举类要用关键字 enum
* 所有枚举类都是 Enum的子类
* 枚举类的第一行上必须是枚举项，如果整个类中只有枚举项，那么最后一个枚举项后的分号可以省略
* 枚举类也可以有构造器，但必须是 private的，
* 枚举类也可以有抽象方法，但是枚举项必须重写该方法
* 枚举在switch语句中的使用
枚举类的常见方法
* A：枚举类的常见方法
* int ordinal()
* int compareTo(E e)
* String name()
* String toString()
* <T> T valueOf(Class<T> type, String name)
* values()
* B：案例演示
* 枚举类的常见方法
package com.heima.enumeration2; public class Demo2_Enum { public static void main(String[] args) { // demo1(); // demo2(); } public static void demo2() { Week2 mon = Week2.valueOf(Week2.class, "MON"); // 通过字节码文件，获取枚举项 System.out.println(mon); Week2[] arr = Week2.values(); // 返回枚举数组，获取每一个枚举对象 for (Week2 week2 : arr) { System.out.println(week2); } } public static void demo1() { Week2 mon = Week2.MON; Week2 tue = Week2.TUE; Week2 wed = Week2.WED; System.out.println(mon.ordinal()); // 返回枚举项的编号 System.out.println(tue.ordinal()); System.out.println(wed.ordinal()); System.out.println(mon.compareTo(tue)); // 依据枚举项编号进行比较 System.out.println(mon.name()); // 获得枚举的名字 System.out.println(mon.toString()); // 二者的效果相似，在toString重写前返回值一样 } }
JDk7的六个新特性回顾和讲解
* 二进制字面量值 0b001
* 数字字面量可以出现下划线
* switch 语句可以用字符串
* 泛型简化，菱形泛型
* 异常的多个catch合并，每个异常用 | 连接
* try - with - resources 语句
package com.heima.JDK7; public class Demo1_JDK7 { public static void main(String[] args) { System.out.println(0b110); // 二进制字面量 System.out.println(100_200); // 数字字面量可以出现下划线,打印时不会显示下划线 } }
JDK8的新特性
* 接口内可以编写方法的具体内容
* 内部类可以 在没有final定义的情况下，调用外部变量
package com.heima.JDK7; public interface Demo2_JDK8 { public static void main(String[] args) { Demo d = new Demo(); d.print(); Inter.method(); d.run(); } } interface Inter { public default void print() { // 在接口内也能编写方法内容 System.out.println("HelloWorld"); } public static void method() { System.out.println("hello"); } } class Demo implements Inter{ public void run() { int num = 10; class Inner { public void func() { // num = 20; 内部类调用外部类变量，变量自动被final修饰 System.out.println(num); } } Inner i = new Inner(); i.func(); } }