Java 基础加强 02

基础加强·反射 和 枚举

类的加载概述和加载时机

* 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，都是同一个字节码文件
    }
}

reflect

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();
    }

}

forName

通过反射获取带参构造方法并使用

* 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);
    }
}

Constructor

通过反射获取成员变量并使用

* 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);
    }
}

Field

通过反射获取方法并使用

* 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); // 传入对象和参数

    }
}

Method

通过反射越过泛型检查

* 在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);

    }
}

Test1

练习

* 通过反射写一个通用的设置某个对象的某个属性为指定值

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); // 修改值
    }
}

Tool

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 + "]";
    }

}

Test2

练习

* 写一个 Properties格式的配置文件，配置类的完整名称
* 写一个程序，读取这个配置文件，获得类的完整名称并加载这个类，用反射的方式运行 run()方法

package com.heima.test;

public class DemoClass {
    public void run() {
        System.out.println("Welcome to China");
    }
}

DemoClass

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中的方法
    }
}

Test3

动态代理的概述和实现

* 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();
}

User

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("日志记录");
    }

}

UserImp

package com.heima.invocation;

public interface Student {

    public void login();
    public void submit();

}

Student

package com.heima.invocation;

public class StudentImp implements Student{

    @Override
    public void login() {
        System.out.println("登录");
    }

    @Override
    public void submit() {
        System.out.println("提交");
    }

}

StudenImp

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;
    }

}

MyInvocationHandler

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();
    }
}

Test

模板设计模式

* 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++;
        }
    }

}

Template

自己实现枚举类

* 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() {} // 私有构造，不让其他类创建本类对象

}

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;
    }

}

Week2

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(); // 枚举类内存在抽象类
}

Week3

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

通过enum实现枚举类

* A：案例演示
　　* 通过enum实现枚举类

package com.heima.enumeration2;

public enum Week1 { // 枚举类会自动完善toString,并私有构造
    Mon,TUE,WED;
}

Week1

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;
    }

}

Week2

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(); // 定义抽象方法
}

Week3

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);
    }
}

Enum

枚举类的注意事项

* 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重写前返回值一样
    }
}

Enum

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); // 数字字面量可以出现下划线,打印时不会显示下划线

    }
}

JDK7

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();
    }
}

JDK8