类加载器
类的加载
当程序要使用某个类时，则系统会通过加载、连接、初始化三步来实现对这个类进行初始化
- 加载
- 就是指将class文件读入内存，并为之创建一个Class对象(也叫字节码对象)
- 任何类被使用时系统都会建立一个Class对象
- 连接
- 验证 是否有正确的内部结构（属性，方法）
- 准备 负责为类的静态成员分配内存，并设置默认初始化值
- 解析 将类的二进制数据中的符号引用替换为直接引用（int a = 1,内存中 a 会直接变成 1）
- 初始化
- 创建完成
类初始化时机(类何时被加载进内存)
-
创建类的实例
- new Demo();
-
类的静态变量、或者为静态变量赋值
- static int a;
- Demo.a = 5;
- System.out.println(Demo.a);
-
类的静态方法
- public static void test(){}
- Demo.test();
-
初始化某个类的子类
- class Student extends Person{}
- new Student();时Person也会被加载进内存
类加载器的组成
-
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包和类路径
-
现在知道我们的常用类是谁加载完成的吗？
反射
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制
要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象
Class类
阅读API的Class类得知，Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的
-
获取Class对象的三种方式
-
方式一 : 通过Object类中的getObject() 方法
Person p = new Person();
Class c = p.getClass();
- 方式二 : 通过 类名.class 获取到字节码文件对象（任意数据类型都具备一个class静态属性,看上去要比第一种方式简单）
Class c = Person.class;
- 方式三 : 通过Class类中的方法（将类名作为字符串传递给Class类中的静态方法forName即可）
Class c = Class.forName(全类名);// 全类名(包名+类名)
- 代码演示
/*
* 获取.class字节码文件对象的方式
* 1：通过Object类中的getObject()方法
* 2: 通过 类名.class 获取到字节码文件对象
* 3: 反射中的方法,
* public static Class<?> forName(String className) throws ClassNotFoundException
* 返回与带有给定字符串名的类或接口相关联的 Class 对象
*/
public class ReflectDemo {
public static void main(String[] args) throws ClassNotFoundException {
// 1： 通过Object类中的getObject()方法
// Person p1 = new Person();
// Class c1 = p1.getClass();
// System.out.println("c1 = "+ c1);
// 2: 通过 类名.class 获取到字节码文件对象
// Class c2 = Person.class;
// System.out.println("c2 = "+ c2);
// 3: 反射中的方法
Class c3 = Class.forName("com.qf.gz.Person");// 包名.类名
System.out.println("c3 = " + c3);
}
}
- Person类
public class Person {
//成员变量
public String name;
public int age;
private String address;
//构造方法
public Person() {
System.out.println("空参数构造方法");
}
public Person(String name) {
this.name = name;
System.out.println("带有String的构造方法");
}
//私有的构造方法
private Person(String name, int age){
this.name = name;
this.age = age;
System.out.println("带有String，int的构造方法");
}
public Person(String name, int age, String address){
this.name = name;
this.age = age;
this.address = address;
System.out.println("带有String, int, String的构造方法");
}
//成员方法
//没有返回值没有参数的方法
public void method1(){
System.out.println("没有返回值没有参数的方法");
}
//没有返回值，有参数的方法
public void method2(String name){
System.out.println("没有返回值，有参数的方法 name= "+ name);
}
//有返回值，没有参数
public int method3(){
System.out.println("有返回值，没有参数的方法");
return 123;
}
//有返回值，有参数的方法
public String method4(String name){
System.out.println("有返回值，有参数的方法");
return "哈哈" + name;
}
//私有方法
private void method5(){
System.out.println("私有方法");
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", address=" + address+ "]";
}
}
通过反射获取构造方法并使用
在反射机制中，把类中的成员（构造方法、成员方法、成员变量）都封装成了对应的类进行表示。其中，构造方法使用类Constructor表示。可通过Class类中提供的方法获取构造方法
-
返回一个构造方法
- public Constructor getConstructor(Class<?>… parameterTypes) 获取public修饰, 指定参数类型所对应的构造方法
- public Constructor getDeclaredConstructor(Class<?>… parameterTypes) 获取指定参数类型所对应的构造方法(包含私有的)
-
返回多个构造方法
- public Constructor<?>[] getConstructors() 获取所有的public 修饰的构造方法
- public Constructor<?>[] getDeclaredConstructors() 获取所有的构造方法(包含私有的)
-
获取构造方法的代码演示
public class ReflectDemo {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException {
//获取Class对象
Class c = Class.forName("com.qf.gz.Person");//包名.类名
//获取所有的构造方法
//Constructor[] cons = c.getConstructors();
Constructor[] cons = c.getDeclaredConstructors();
for (Constructor con : cons) {
System.out.println(con);
}
System.out.println("------------------------");
//获取一个构造方法
//public Person()
Constructor con1 = c.getConstructor(null);
System.out.println(con1);
//public Person(String name)
Constructor con2 = c.getConstructor(String.class);
System.out.println(con2);
//private Person(String name, int age)
Constructor con3 = c.getDeclaredConstructor(String.class, int.class);
System.out.println(con3);
//public Person(String name, int age, String address)
Constructor con4 = c.getDeclaredConstructor(String.class, int.class, String.class);
System.out.println(con4);
}
}
通过反射方式，获取构造方法，创建对象
获取构造方法，步骤如下
- 获取到Class对象
- 获取指定的构造方法
- 通过构造方法类Constructor中的方法，创建对象 public T newInstance(Object… initargs)
- 代码演示
public class ConstructorDemo {
public static void main(String[] args) throws Exception {
//1,获取到Class对象
Class c = Class.forName("com.qf.gz.Person");//包名.类名
//2,获取指定的构造方法
//public Person()
//Constructor con = c.getConstructor(null);
//public Person(String name, int age, String address)
Constructor con = c.getConstructor(String.class, int.class, String.class);
//3,通过构造方法类中Constructor的方法，创建对象
//Object obj = con.newInstance(null);
Object obj = con.newInstance("小明", 22, "哈尔滨");
//显示
System.out.println(obj);
}
}
通过反射方式，获取私有构造方法，创建对象
AccessibleObject 类是 Field、Method 和 Constructor 对象的父类。它提供了将反射的对象标记为在使用时取消默认 Java 语言访问控制检查的能力
对于公共成员、默认（打包）访问成员、受保护成员和私有成员，在分别使用 Field、Method 或 Constructor 对象来设置或获取字段、调用方法，或者创建和初始化类的新实例的时候，会执行访问检查。常用方法如下
-
public void setAccessible(boolean flag) throws SecurityException
- 参数值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查。参数值为 false 则指示反射的对象应该实施 Java 语言访问检查
-
获取私有构造方法，步骤如下
- 获取到Class对象
- 获取指定的构造方法
- 暴力访问, 通过setAccessible(boolean flag)方法
- 通过构造方法类Constructor中的方法，创建对象 public T newInstance(Object… initargs)
-
代码演示
public class ConstructorDemo2 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
//1,获取到Class对象
Class c = Class.forName("com.qf.gz.Person");//包名.类名
//2,获取指定的构造方法
//private Person(String name, int age)
Constructor con = c.getDeclaredConstructor(String.class, int.class);
//3,暴力反射
con.setAccessible(true);//取消 Java 语言访问检查
//4,通过构造方法类中的功能，创建对象
Object obj = con.newInstance("小明", 23);
System.out.println(obj);
}
}
通过反射获取成员变量并使用
在反射机制中，把类中的成员变量使用类Field表示。可通过Class类中提供的方法获取成员变量
-
返回一个成员变量
- public Field getField(String name) 获取指定的 public修饰的变量
- public Field getDeclaredField(String name) 获取指定的任意变量
-
返回多个成员变量
- public Field[] getFields() 获取所有public 修饰的变量
- public Field[] getDeclaredFields() 获取所有的 变量 (包含私有)
-
获取成员变量的代码演示
public class FieldDemo {
public static void main(String[] args) throws Exception{
//获取Class对象
Class c = Class.forName("com.qf.gz.Person");
//获取成员变量
//多个变量
//Field[] fields = c.getFields();
Field[] fields = c.getDeclaredFields();
for (Field field : fields) {
System.out.println(field);
}
System.out.println("-----------------");
//一个变量
//public int age;
Field ageField = c.getField("age");
System.out.println(ageField);
//private String address
Field addressField = c.getDeclaredField("address");
System.out.println(addressField);
}
}
通过反射，创建对象，获取指定的成员变量，进行赋值与获取值操作
-
获取成员变量，步骤如下
- 获取Class对象
- 获取构造方法
- 通过构造方法，创建对象
- 获取指定的成员变量（私有成员变量，通过setAccessible(boolean flag)方法暴力访问）
- 通过方法，给指定对象的指定成员变量赋值或者获取值
- public void set(Object obj, Object value)在指定对象obj中，将此 Field 对象表示的成员变量设置为指定的新值
- public Object get(Object obj) 返回指定对象obj中，此 Field 对象表示的成员变量的值
-
代码演示
public class FieldDemo2 {
public static void main(String[] args) throws Exception {
//1,获取Class对象
Class c = Class.forName("com.qf.gz.Person");
//2，获取构造方法
//public Person(String name)
Constructor con = c.getConstructor(String.class);
//3，通过构造方法，创建对象
Object obj = con.newInstance("小明");
//4，获取指定的成员变量
//public String name;
Field nameField = c.getField("name");
//public int age;
Field ageField = c.getField("age");
//private String address;
Field addressField = c.getDeclaredField("address");
addressField.setAccessible(true); //取消 Java 语言访问检查
//5，通过方法，给指定对象的指定成员变量赋值或者获取值
System.out.println("name = "+ nameField.get(obj));
System.out.println("age = "+ ageField.get(obj));
System.out.println("address = "+ addressField.get(obj));
//赋值
ageField.set(obj, 23);
addressField.set(obj, "铂金广场");
System.out.println("------------------------");
System.out.println("name = "+ nameField.get(obj));
System.out.println("age = "+ ageField.get(obj));
System.out.println("address = "+ addressField.get(obj));
}
}
通过反射获取成员方法并使用
在反射机制中，把类中的成员方法使用类Method表示。可通过Class类中提供的方法获取成员方法
-
返回获取一个方法
- public Method getMethod(String name, Class<?>… parameterTypes)获取public 修饰的方法
- public Method getDeclaredMethod(String name, Class<?>… parameterTypes)获取任意的方法，包含私有的
- 参数1: name 要查找的方法名称； 参数2： parameterTypes 该方法的参数类型
-
返回获取多个方法
- public Method[] getMethods() 获取本类与父类中所有public 修饰的方法
- public Method[] getDeclaredMethods() 获取本类中所有的方法(包含私有的)
-
获取成员方法的代码演示
public class MethodDemo {
public static void main(String[] args) throws Exception {
//获取Class对象
Class c = Class.forName("com.qf.gz.Person");
//获取多个方法
//Method[] methods = c.getMethods();
Method[] methods = c.getDeclaredMethods();
for (Method method : methods) {
System.out.println(method);
}
System.out.println("-----------------------");
//获取一个方法：
//public void method1()
Method method = c.getMethod("method1", null);
System.out.println(method);
//public String method4(String name){
method = c.getMethod("method4", String.class);
System.out.println(method);
//私有方法
//private void method5()
method = c.getDeclaredMethod("method5", null);
System.out.println(method);
}
}
通过反射，创建对象，调用指定的方法
-
获取成员方法，步骤如下
- 获取Class对象
- 获取构造方法
- 通过构造方法，创建对象
- 获取指定的方法
- 执行找到的方法
- public Object invoke(Object obj, Object… args)执行指定对象obj中，当前Method对象所代表的方法，方法要传入的参数通过args指定
-
代码演示
public class MethodDemo2 {
public static void main(String[] args) throws Exception {
//1， 获取Class对象
Class c = Class.forName("com.qf.gz.Person");
//2,获取构造方法
//public Person(String name, int age, String address){
Constructor con = c.getConstructor(String.class, int.class, String.class);
//3，通过构造方法，创建对象
Object obj = con.newInstance("小明", 23, "哈尔滨");
//4，获取指定的方法
//public void method1() 没有返回值没有参数的方法
//Method m1 = c.getMethod("method1", null);
//public String method4(String name)
Method m4 = c.getMethod("method4", String.class);
//5，执行找到的方法
//m1.invoke(obj, null);
Object result = m4.invoke(obj, "hehe");
System.out.println("result = " + result);
}
}
通过反射，创建对象，调用指定的private 方法
-
获取私有成员方法，步骤如下
- 获取Class对象
- 获取构造方法
- 通过构造方法，创建对象
- 获取指定的方法
- 开启暴力访问
- 执行找到的方法
- public Object invoke(Object obj, Object… args)执行指定对象obj中，当前Method对象所代表的方法，方法要传入的参数通过args指定
-
代码演示
public class MethodDemo3 {
public static void main(String[] args) throws Exception {
//1， 获取Class对象
Class c = Class.forName("com.qf.gz.Person");
//2,获取构造方法
//public Person(String name, int age, String address){
Constructor con = c.getConstructor(String.class, int.class, String.class);
//3，通过构造方法，创建对象
Object obj = con.newInstance("小明", 23, "哈尔滨");
//4，获取指定的方法
//private void method5(){
Method m5 = c.getDeclaredMethod("method5", null);
//5,开启暴力访问
m5.setAccessible(true);
//6，执行找到的方法
m5.invoke(obj, null);
}
}
反射练习
泛型擦除
思考，将已存在的ArrayList集合中添加一个字符串数据，如何实现呢？
我来告诉大家，其实程序编译后产生的.class文件中是没有泛型约束的，这种现象我们称为泛型的擦除。那么，我们可以通过反射技术，来完成向有泛型约束的集合中，添加任意类型的元素
- 代码如下
public class ReflectTest {
public static void main(String[] args) throws Exception {
ArrayList<Integer> list = new ArrayList<Integer>();
//添加元素到集合
list.add(new Integer(30));
list.add(new Integer("12345"));
list.add(123);
//list.add("哈哈");//因为有泛型类型的约束
System.out.println(list);
//通过反射技术，实现添加任意类型的元素
//1, 获取字节码文件对象
//Class c = list.getClass();
//Class c = ArrayList.class;
Class c = Class.forName("java.util.ArrayList");
//2, 找到add()方法
// public boolean add(E e)
Method addMethod = c.getMethod("add", Object.class);
//3， 执行add()方法
addMethod.invoke(list, "哈哈");// list.add("哈哈");
System.out.println(list);
}
}
反射配置文件
通过反射配置文件，运行配置文件中指定类的对应方法
读取Peoperties.txt文件中的数据，通过反射技术，来完成Person对象的创建 config.properties文件内容如下
className=com.qf.gz.Person
methodName=demo
- 读取配置文件，调用指定类中的对应方法
public class ReflectTest2 {
public static void main(String[] args) throws Exception {
// 通过Properties集合从文件中读取数据
Properties prop = new Properties();
// 读取文件中的数据到集合中
prop.load(new FileInputStream("config.properties"));
// 获取键所对应的值
String className = prop.getProperty("className");
System.out.println(className);
// 1，获取Person.class 字节码文件对象
Class c = Class.forName(className);
// 2，获取构造方法
// public Person(String name, int age, String address)
Constructor con = c.getConstructor(String.class, int.class, String.class);
// 3,创建对象
Object obj = con.newInstance("小明", 20, "中国");
System.out.println(obj);
// 4，获取指定的方法
// private void method5(){}
String methodName = prop.getProperty("methodName");
Method m5 = c.getDeclaredMethod(methodName, null);
// 5,开启暴力访问
m5.setAccessible(true);
// 6，执行找到的方法
m5.invoke(obj, null);
}
}
Json
-
JavaScript Object Notation
-
Json的好处
- 数据格式比较简单，易于读写，格式都是压缩的，占用带宽小
- JSON轻量级，不管是编写，传输，还是解析都更加高效
- 众多的语言支持，如javascript，python，C，C++等主流语言都支持
- 因为JSON格式能直接为服务器端代码使用，大大简化了服务器端和客户端的代码开发量，且完成任务不变，并且易于维护
-
是什么Json
- JSON 指的是 JavaScript 对象表示法（JavaScript Object Notation）
- JSON 是轻量级的文本数据交换格式
- JSON 具有自我描述性，更易理解
- JSON是一种传递对象的语法，对象可以是name/value对，数组和其他对象
-
数据演示
- {“skillz”: {“web”:[ {“name”: “html”， “years”: “5” }， {“name”: “css”， “years”: “3” }],”database”:[ {“name”: “sql”， “years”: “7” }]}}
-
花括弧，方括弧，冒号和逗号
- 花括弧表示一个“容器”
- 方括号装载数组
- 名称和值用冒号隔开
- 数组元素通过逗号隔开
-
代码演示
public static void t8() {
String json = "[{\"name\":\"mu\",\"kind\":\"bai\"},{\"name\":\"gong\",\"kind\":\"hei\"}]";
Gson gson = new Gson();
Type type = new TypeToken<List<Dog>>() {
}.getType();
List<Dog> list = gson.fromJson(json, type);
System.out.println(list);
}
public static void t7() {
ArrayList<Dog> list = new ArrayList<Dog>();
Dog d = new Dog();
d.setKind("hei");
d.setName("gong");
Dog d2 = new Dog();
d2.setKind("bai");
d2.setName("mu");
list.add(d2);
list.add(d);
Gson gson = new Gson();
String json = gson.toJson(list);
System.out.println(json);
}
public static void t6() {
Gson gson = new Gson();
String json = "{\"id\":1,\"name\":\"qq\",\"age\":11,\"dogs\":[{\"name\":\"mu\",\"kind\":\"bai\"},{\"name\":\"gong\",\"kind\":\"hei\"}]}";
Person p = gson.fromJson(json, Person.class);
System.out.println(p.getDogs());
}
public static void t5() {
Person p = new Person();
p.setAge(11);
p.setId(1);
p.setName("qq");
Cat cat = new Cat();
cat.setAge(10);
cat.setName("bosimao");
p.setCat(cat);
ArrayList<Dog> list = new ArrayList<Dog>();
Dog d = new Dog();
d.setKind("hei");
d.setName("gong");
Dog d2 = new Dog();
d2.setKind("bai");
d2.setName("mu");
list.add(d2);
list.add(d);
p.setDogs(list);
Gson gson = new Gson();
String json = gson.toJson(p);
System.out.println(json);
}
public static void t4() {
Gson gson = new Gson();
String json = "{\"id\":1,\"name\":\"qq\",\"age\":11,\"cat\":{\"age\":10,\"name\":\"bosimao\"}}";
Person p = gson.fromJson(json, Person.class);
System.out.println(p.getCat().getName());
}
public static void t3() {
Person p = new Person();
p.setAge(11);
p.setId(1);
p.setName("qq");
Cat cat = new Cat();
cat.setAge(10);
cat.setName("bosimao");
p.setCat(cat);
Gson gson = new Gson();
String json = gson.toJson(p);
System.out.println(json);
}
public static void t2() {
Gson gson = new Gson();
String json = "{\"id\":1,\"name\":\"qq\",\"age\":11}";
Person p = gson.fromJson(json, Person.class);
System.out.println(p.getName());
}
public static void t1() {
Person p = new Person();
p.setAge(11);
p.setId(1);
p.setName("qq");
Gson gson = new Gson();
String json = gson.toJson(p);
System.out.println(json);
}
88
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
