V2AS问路
Java 基础加强 02
阅读原文时间：2023年07月13日阅读：2

基础加强·反射 和 枚举

* 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

* 榨汁机（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这个集合中添加 字符串元素

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

* 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 valueOf(Class 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

* 二进制字面量值 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

* 接口内可以编写方法的具体内容
* 内部类可以 在没有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

手机扫一扫

移动阅读更方便

阿里云服务器
腾讯云服务器
七牛云服务器

你可能感兴趣的文章

Sql Server海量数据插入
SpringBoot对接OpenAI
判定对象是否存活的算法----GC_ROOT算法

4

[初学C#] 第二习题 : 快递跟踪信息查询

5

快速了解C#接口(Interface)

6

C# MySqlHelp类 "DbModel.MySql"数据库操作类

7

搭建Minio分布式服务

8

C# - XMLHelper ：一个操作XML的简单类库

9

.NET 7 新特性全面解析

10

[Qt开发探幽（二）]浅谈关于元对象，宏和Q_ENUM