类的加载概述和加载时机
类的加载
*当程序要使用某个类时,如果该类还没被加载到内存中,则系统会通过加载,连接,初始化三步来实现对这个类进行初始化
*加载
*就是指将class文件读入内存,并为之创建class对象。任何类被使用时系统都会建立一个class对象
*连接
*验证 是否有正确的内部结构,并和其他类协调一致
*准备 负责为类的静态成员分配内存,并设置默认初始化值
*解析 将类的二进制数据中的符号引用替换为直接引用
*初始化
加载时机
*创建类的实例
*访问类的静态变量,或者为静态变量赋值
*使用反射方式来强制创建某个类或接口对应的java.lang.class对象
*初始化某个类的子类
*直接使用java.exe命令来运行某个主类
类加载器和分类
类加载器
*负责将.class文件加载到内存中,并为之生成对应的class对象。虽然我们不需要关心类加载机制,但是了解这个机制我们就能更好的理解程序的运行
类加载器的分类
*Bootstrap ClassLoader 根类加载器
*Extension ClassLoader 扩展类加载器
*System ClassLoader 系统类加载器
类加载器的作用
*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类型的对象
三种方式
*object类的getClass()方法没判断两个对象是否是同一个字节码文件
*静态属性class,锁对象
*Clas类中静态方法forNamme(),读取配置文件
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
import tan.jung.bean.Person; public class demo1_Reflcet { public static void main(String[] args) throws ClassNotFoundException { Class clazz1=Class.forName("tan.jung.bean.Person"); Class clazz2 =Person.class; Person p =new Person(); Class clazz3=p.getClass(); System.out.println(clazz1 == clazz2); System.out.println(clazz2 == clazz3); } }
forName配置
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
import java.io.BufferedReader; import java.io.FileNotFoundException; import java.io.FileReader; public class demo2_Reflect { public static void main(String[] args) throws Exception { //没有反射 //Juice j1=new Juice(); //购买榨汁机 //j1.run(new Apple()); //向榨汁机放入苹果 //j1.run(new Orange()); //Fruit f =new Orange //反射和配置 BufferedReader br1=new BufferedReader(new FileReader("cofing.prt")); Class clazz=Class.forName(br1.readLine()); Fruit f=(Fruit) clazz.newInstance(); //父类引用指向子类对象,水果引用指向了苹果对象 Juice j=new Juice(); j.run(f); } } 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 Juice{ // public void run(Apple a){ // a.squeeze(); // } // // public void run(Orange o){ // o.squeeze(); // } public void run(Fruit f){ f.squeeze(); } }
通过反射获取带参构造方法并使用
*Constructor
*Class类的newInstance()方法是使用该类无参的构造函数创建对象,如果一个类没有无参的构造函数,就不能这样创建了,可以调用Class类的getConstructor(String.class,int.class)方法获取一个指定的构造函数然后再调用Constructor类的newInstance(“张三”,20)方法创建对象
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
import java.lang.reflect.Constructor; import tan.jung.bean.Person; public class demo3_Constructor { public static void main(String[] args) throws Exception { Class clazz =Class.forName("tan.jung.bean.Person"); //Person p =(Person) clazz.newInstance(); //通过无参创建对象 Constructor c =clazz.getConstructor(String.class,int.class);//获取有参构造 Person p=(Person) c.newInstance("张三",23); //通过有参构造创建对象 System.out.println(p); } }
通过反射获取成员变量并使用
*Field
*Class.getField(String)方法介意获取类中的指定字段(可见的),如果是私有的可以用getDeclaedField(“name”)放啊获取,通过set(obj,“李四”)方法可以设置指定对象上该字段的值,如果是私有的需要先调用setAccessible(true)设置访问权限,用获取的指定的字段套用get(obj)可以获取指定对象中该字段的值
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
import java.lang.reflect.Constructor; import java.lang.reflect.Field; import tan.jung.bean.Person; public class demo4_Fiexd { public static void main(String[] args) throws Exception { Class clazz =Class.forName("tan.jung.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,object...)可以调用该方法,Class.getMethod(“eat”)invoke(obj)Class.getMethod(“eat”.int.class)invoke(obj,10)
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
import java.lang.reflect.Constructor; import java.lang.reflect.Method; import tan.jung.bean.Person; public class demo5_method { public static void main(String[] args) throws Exception { Class clazz =Class.forName("tan.jung.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); //获取有参的eat方法 m2.invoke(p, 10); } }
动态代理的概述和实现
概述
代理:本来应该自己做的事情,请人被人来做,被请的人就是代理对象
动态代理:在程序运行过程中产生的这个对象,而程序运行过程中产生的对象其实就是我们刚才反射讲解的内容,过意,动态代理其实就是通过反射来生成一个代理
在Java中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口,通过使用这个类和接口就可以生成动态代理对象。JDK提供的代理只能针对接口做代理,我们有更强大的代理 cglib,Proxy类中的方法创建动态代理类对象
public static object newProxyInstance(ClassLoader) loader,Class< ? > [ ] interfaces,InvocationHandler h )
最终会调用InvocationHandler的方法
InvocationHandler object invoke(object proxy ,Method method,object[ ] args)
import java.lang.reflect.Proxy; public class Test { public static void main(String[] args) { /*userImp ui=new userImp(); ui.add(); ui.delete(); System.out.println("------------");*/ /*My m =new My(ui); user u=(user)Proxy.newProxyInstance(ui.getClass().getClassLoader(), ui.getClass().getInterfaces(), m); u.add(); u.delete();*/ StudentImp si=new StudentImp(); si.login(); si.submit(); System.out.println("------------"); My m =new My(si); Student u=(Student)Proxy.newProxyInstance(si.getClass().getClassLoader(), si.getClass().getInterfaces(), m); u.login(); u.submit(); } } //第二个包 public interface Student { public void login(); public void submit(); } //第三个包 public class StudentImp implements Student { @Override public void login() { System.out.println("登录"); } @Override public void submit() { System.out.println("提交"); } }
设计模式
概述
模板方法木事就是定义一个算法的骨架,而将具体的算法延迟刀子类中来实现
优点和缺点
优点:使用模板方法木事,在定义算法骨架的同时,可以很灵活的实现具体的算法,猫族用户灵活多变的需求
缺点:如果算法骨架有修改的话,则需要修改抽象类
装饰
单例
简单工厂
工厂方法
适配器
模板
JDK5的新特性
枚举概述
是指将变量的值——列出来,变量的值只限于列出来的值的范围内。
回想单列设计模式:单例类是一个类直邮一个实例
那么多列类就是一个类有多个实例,但不是无限个数的实例,而是有限个数的实例。这才能是枚举类
自动拆装箱
泛型
可变参数
静态导入
增强for循环
互拆锁
枚举
枚举的注意事项
定义枚举类要用关键字enum
所有枚举类都是Enum的子类
枚举类的第一行上必须是枚举项,最后一个枚举项后的分号是尅省略的,但是如果枚举类其他的东西,这个分号就不能省略。建议不要省略
枚举类可以有构造器,单必须是private的,它默认的也是private的
枚举类也可以有抽象方法,但是枚举类必须重写该方法
枚举类在
switch语句中的使用
枚举的常见方法
int ordinal()
int compareTo(E o)
String name()
String toString()
<T> T valueOf (Class <T> type,String name)
values()
此方法虽然在JDK文档中查找不到,但每个枚举类都具有该方法,它遍历枚举类的所有枚举值非常方便
JKD7新特性
二进制字面量0b001
数字字面量可以出现下划线
switch 语句可以用字符串
泛型简化,菱形泛型
异常的多个catch合并,每个异常用或 |
try-with-resources 语句
JDK8新特性
接口中可以定义有方法体的方法,如果是非静态,必须用default修饰
如果是静态的就不用了