技术标签: java
——Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ——
一、类加载器
我们已经知道一个Java程序是由很多的类,以及这些类的对象组成的,因为类是创建对象的模板,所以当某个Java程序中需要使用某个类,那么JVM就会将该类加载到内存,并为之创建一个Class类的对象。
注意:Java中每一个类或接口都会有一个对应的Class类的对象,该对象用于描述所有类共有的属性和行为。
1.类加载器的作用:负责将.class文件加载到内存,并为之生成对应的Class对象。
2.分类:
<1>Bootstrap ClassLoader 根类加载器
负责Java核心类的加载
<2>Extension ClassLoader 扩展类加载器
负责JRE扩展目录中jar包的加载。
<3>System ClassLoader 系统类加载器
负责JVM启动时加载来自java命令的class文件,以及classpath环境变量所指定的jar包和路径
二、反射
**1.概述**Java的反射机制是一种可以在运行状态中动态的剖析类的结构,获得类中的所有元素,并动态创建类的对象,调用类的成员的一种机制。
反射最强大的功能在于可以动态获取某个类中的所有元素,包括类的名称,父类,实现接口,成员变量,成员方法,构造方法。。
2.Class类介绍
通过查阅API可知,Class类的对象代表运行在Java程序中的类或接口。
Class类没有提供公共的构造方法,Class类的对象由JVM通过调用类加载器的defineClass方法自动创建。
获取某个类的Class类对象的方式有以下三种:
假设已知类的全称:className (包括包名+类名)
<1>类名.class
<2>类的对象变量.getClass()
<3>Class.forName(className)
3.通过反射获取构造方法
public Constructor[] getConstructors():
所有公共构造方法
public Constructor[] getDeclaredConstructors():
所有构造方法
public Constructor<T> getConstructor(Class<?>... parameterTypes)
获取单个构造方法 ; 参数表示的是:你要获取的构造方法的构造参数个数及数据类型的class字节码文件对象
通过构造方法创建对象:
Class c = Class.forName(className);
Constructor con = c.getConstructor();// 返回的是构造方法对象
Object obj = con.newInstance();
获取私有构造方法并创建对象:
Class c = Class.forName(className);
Constructor con = c.getDeclaredConstructor(String.class);
//设置暴力访问标志位true,则不进行访问权限检查
con.setAccessible(true);
Object obj = con.newInstance("hello");
4.通过反射获取成员方法
public Method getMethod(String name, Class<?>... parameterTypes) throws NoSuchMethodException, SecurityException
获取指定名称,参数的公有方法对象
public Method getDeclaredMethod(String name, Class<?>...)
获取指定名称,参数的声明方法对象
public Method[] getMethods() throws SecurityException
获取类中的所有共有方法
public Method[] getDeclaredMethods()
获取所有声明方法
void setAccessible(boolean flag)
设置暴力访问标记
获取类中所有声明的方法:
Method[] methods = cl.getDeclaredMethods();
for(Method method : methods) {
System.out.println(method);
}
获取指定名称和参数列表的方法:
Method method = cl.getMethod("methodName", int.class, double.class, ......);
//调用方法
method.invoke(instance, 12, 22.2,.....);
5.通过反射获取成员变量
获取所有成员:getFields,getDeclaredFields
获取单个成员:getField,getDeclaredField
修改成员的值:set(Object obj,Object value)
5.反射的几个综合应用案例
<1>需求:通过反射剖析一个类的内部结构,获取类中的所有元素。
分析:通过Class类对象的方法获取一个类中的所有元素,并将它们按照定义类的格式打印到控制台上。
代码:
/*
* 通过反射机制获取任意一个类的内部结构
*/
public class ReflectionDemo {
public static void main(String[] args) throws ClassNotFoundException {
// 通过用户输入获取类的名称:注意类的名称包括包名加类名
String name;
{
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个类名(例如:java.lang.Object) : ");
name = sc.nextLine();
}
// 获取类的Class类对象
Class clazz = Class.forName(name);
// 获取父类的Class对象
Class superClass = clazz.getSuperclass();
// 获取类的修饰符
String modifiers = Modifier.toString(clazz.getModifiers());
// 获取接口
Class[] interfaces = clazz.getInterfaces();
String interfacesNames = "";
if(interfaces.length > 0) {
for (int i = 0; i < interfaces.length; i++) {
interfacesNames += interfaces[i].getName();
if(i != interfaces.length-1) {
interfacesNames += ",";
}
}
}
//按定义类的格式输出
if (modifiers.length() > 0) {
System.out.print(modifiers + " ");
}
System.out.print("class " + name);
if (superClass != null && superClass != Object.class) {
System.out.print(" extends " + superClass.getName());
}
if (interfaces != null) {
System.out.println();
System.out.print(" implements " + interfacesNames);
}
System.out.print(" {\n");
//打印所有构造方法
printConstructors(clazz);
System.out.println();
//打印所有成员方法,静态方法
printMethods(clazz);
System.out.println();
//打印所有成员变量,静态变量
printFields(clazz);
System.out.println("}");
}
public static void printConstructors(Class cl) {
Constructor[] constructors = cl.getDeclaredConstructors();
for (Constructor constructor : constructors) {
//获取构造方法修饰符
String modifiers = Modifier.toString(constructor.getModifiers());
//获取构造方法名称
String name = constructor.getName();
//获取构造方法参数列表
Class[] types = constructor.getParameterTypes();
//按格式打印方法
System.out.print("\t");
if(modifiers.length() > 0) {
System.out.print(modifiers + " ");
}
System.out.print(name + "(");
for (int i = 0; i < types.length; i++) {
if(i > 0) {
System.out.print(", ");
}
System.out.print(types[i].getName());
}
System.out.println(");");
}
}
public static void printMethods(Class cl) {
//获取方法
Method[] methods = cl.getDeclaredMethods();
for (Method method : methods) {
//获取方法名
String name = method.getName();
//获取修饰符
String modifiers = Modifier.toString(method.getModifiers());
//获取方法参数列表
Class[] types = method.getParameterTypes();
//按格式打印
System.out.print("\t");
if(modifiers.length() > 0) {
System.out.print(modifiers + " ");
}
System.out.print(name + "(");
for (int i = 0; i < types.length; i++) {
if(i > 0) {
System.out.print(", ");
}
System.out.print(types[i].getName());
}
System.out.println(");");
}
}
public static void printFields(Class cl) {
Field[] fields = cl.getDeclaredFields();
for (Field field : fields) {
//获取变量名
String name = field.getName();
//获取修饰符
String modifiers = Modifier.toString(field.getModifiers());
//获取类型
Class type = field.getType();
//按格式打印
System.out.print("\t");
if(modifiers.length() > 0) {
System.out.print(modifiers + " ");
}
System.out.println(type.getName() + " " + name + ";");
}
}
}
运行结果:
请输入一个类名(例如:java.lang.Object) :
java.util.ArrayList
public class java.util.ArrayList extends java.util.AbstractList
implements java.util.List,java.util.RandomAccess,java.lang.Cloneable,java.io.Serializable {
public java.util.ArrayList(java.util.Collection);
public java.util.ArrayList();
public java.util.ArrayList(int);
public clone();
public add(int, java.lang.Object);
public add(java.lang.Object);
public contains(java.lang.Object);
public get(int);
public indexOf(java.lang.Object);
public isEmpty();
public lastIndexOf(java.lang.Object);
public size();
public subList(int, int);
public toArray();
public toArray([Ljava.lang.Object;);
static access$100(java.util.ArrayList);
static access$200(java.util.ArrayList);
public addAll(int, java.util.Collection);
public addAll(java.util.Collection);
public iterator();
public remove(int);
public remove(java.lang.Object);
private readObject(java.io.ObjectInputStream);
private writeObject(java.io.ObjectOutputStream);
public clear();
public set(int, java.lang.Object);
public ensureCapacity(int);
public trimToSize();
private ensureCapacityInternal(int);
elementData(int);
private grow(int);
private static hugeCapacity(int);
public listIterator();
public listIterator(int);
public removeAll(java.util.Collection);
protected removeRange(int, int);
public retainAll(java.util.Collection);
private outOfBoundsMsg(int);
private rangeCheckForAdd(int);
private rangeCheck(int);
private batchRemove(java.util.Collection, boolean);
private ensureExplicitCapacity(int);
private fastRemove(int);
static subListRangeCheck(int, int, int);
private static final long serialVersionUID;
private static final int DEFAULT_CAPACITY;
private static final [Ljava.lang.Object; EMPTY_ELEMENTDATA;
private transient [Ljava.lang.Object; elementData;
private int size;
private static final int MAX_ARRAY_SIZE;
}
通过上面的示例可以看出反射功能的强大之处,可以用来获取类中的所有元素,包括私有元素。
<2>需求:通过配置文件运行类中的方法。
假设有三个类:Student, Teacher, Worker,这三个类中都有一个love方法,通过配置文件和反射机制在运行时指定运行哪个类的方法。
分析:
1. 需要有配置文件,定义class.txt为配置文件
2.配置文件中有两个键:className 类名, methodName 方法名
3.获取类名
4.通过类名获取类名对应的Class对象
5.通过Class对象创建实例,调用方法
代码:
//配置文件中的内容如下
//className=cn.itcast.test.Worker
//methodName=love
//三个测试用类
public class Student {
public void love() {
System.out.println("学生爱学习");
}
}
public class Teacher {
public void love() {
System.out.println("老师爱教课");
}
}
public class Worker {
public void love() {
System.out.println("工人爱工作");
}
}
//测试类
public class ReflectionDemo {
public static void main(String[] args) {
//通过Properties类获取配置文件中的内容
Properties prop = new Properties();
FileReader reader = new FileReader("class.txt");
prop.load(reader);
reader.close;
//获取数据
String className = prop.getProperty("className");
String methodName = prop.getProperty("methodName");
//通过反射获取Class对象
Class cl = Class.forName(className);
//创建对象
Constructor c = cl.getConstructor();
Object instance = c.newInstance();
//调用方法
Method method = cl.getMethod(methodName, null);
method.invoke(instance, null);
}
}
运行结果: 工人爱工作
<3>通过反射越过泛型检查
需求:向ArrayList对象中添加一个Integer数据
代码:
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
public class ReflectionDemo3 {
public static void main(String[] args) throws NoSuchMethodException,
SecurityException, IllegalAccessException,
IllegalArgumentException, InvocationTargetException {
// 创建一个ArrayList<String>对象
ArrayList<String> list = new ArrayList<String>();
list.add("hello");
//list.add(12); 编译不通过
// 获取ArrayList的Class对象
Class cl = list.getClass();
// 获取add()方法
Method add = cl.getMethod("add", Object.class);
// 调用add方法添加元素
add.invoke(list, 12);
System.out.println(list);
}
}
输出结果:
[hello, 12]
如结果所示,成功将Integer类型数据存入了集合,由此可见,泛型检测机制是在编译时期完成的。
三、动态代理
1.概述
想要理解动态代理,那么首先要理解什么是代理。
代理其实是一种面向对象的设计模式。
从现实生活的角度去考虑,比如说我们要买一管高露洁牙膏,那么按正常思维来说我们肯定是到这种牙膏的出售点去买,而不是到生产厂商那里去买,那么这个牙膏售卖点其实就是一种代理,看下图:
下面用代码来描述这种情况:
public class ProxyDemo {
public static void main(String[] args) {
ProduceFactory pf = new ProduceFactory();
//厂家自己卖
pf.sell();
ProxyShop ps = new ProxyShop(pf);
//代理商替厂家卖
ps.sell();
}
}
interface SellSomething {
void sell();
}
class ProduceFactory implements SellSomething {
@Override
public void sell() {
System.out.println("卖牙膏");
}
}
class ProxyShop implements SellSomething {
//获取生产厂家的对象
ProduceFactory factory;
ProxyShop(ProduceFactory factory) {
this.factory = factory;
}
//代理类来代替生产厂家卖东西
@Override
public void sell() {
factory.sell();
}
}
那么这样做的好处是什么呢?
首先分析代理设计模式中的三个要素:
1.抽象接口:声明了真实对象和代理对象的公共行为
2.代理对象:代理对象内部含有真实对象的引用,从而可以操作真实对象,同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。可以在执行真实对象操作时,附加其他的操作,相当于对真实对象进行封装。
3.真实对象:代理角色所代表的真实对象,是我们最终要引用的对象。
好处:
对外部提供统一的接口方法,而代理类在接口中实现对真实类的附加操作行为,从而可以在不影响外部调用情况下,进行系统扩展。
2.动态代理
在程序运行过程中为某一个接口创建代理对象。
Java中通过Proxy类中的newProxyInstance方法来创建动态代理。
注意:Proxy类只能针对接口做动态代理。
程序实例:为List集合接口创建一个动态代理对象。
代码:
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;
public class ProxyDemo {
public static void main(String[] args) {
//创建实际对象
final List list = new ArrayList();
//创建代理对象对list接口做代理
/*
* newProxyInstance参数的含义:
* ClassLoader : 通过要代理的类的Class对象获取类加载器,以便于代理类获取实际类的内部结构
* Interface[] : 获取代理类的所有接口
* InvocationHandler : 通过调用处理器接口调用接口的方法。
*/
List proxy = (List) Proxy.newProxyInstance(list.getClass()
.getClassLoader(), list.getClass().getInterfaces(),
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method,
Object[] args) throws Throwable {
Object obj = method.invoke(list, args);
return obj;
}
});
proxy.add("I love Java.");
proxy.add(34);
System.out.println(proxy);
}
}
运行结果:
[I love Java., 34]
注:关于反射和动态代理的应用需要在实际项目中去体会。
文章浏览阅读1.6k次。安装配置gi、安装数据库软件、dbca建库见下:http://blog.csdn.net/kadwf123/article/details/784299611、检查集群节点及状态:[root@rac2 ~]# olsnodes -srac1 Activerac2 Activerac3 Activerac4 Active[root@rac2 ~]_12c查看crs状态
文章浏览阅读1.3w次,点赞45次,收藏99次。我个人用的是anaconda3的一个python集成环境,自带jupyter notebook,但在我打开jupyter notebook界面后,却找不到对应的虚拟环境,原来是jupyter notebook只是通用于下载anaconda时自带的环境,其他环境要想使用必须手动下载一些库:1.首先进入到自己创建的虚拟环境(pytorch是虚拟环境的名字)activate pytorch2.在该环境下下载这个库conda install ipykernelconda install nb__jupyter没有pytorch环境
文章浏览阅读5.2k次,点赞19次,收藏28次。选择scoop纯属意外,也是无奈,因为电脑用户被锁了管理员权限,所有exe安装程序都无法安装,只可以用绿色软件,最后被我发现scoop,省去了到处下载XXX绿色版的烦恼,当然scoop里需要管理员权限的软件也跟我无缘了(譬如everything)。推荐添加dorado这个bucket镜像,里面很多中文软件,但是部分国外的软件下载地址在github,可能无法下载。以上两个是官方bucket的国内镜像,所有软件建议优先从这里下载。上面可以看到很多bucket以及软件数。如果官网登陆不了可以试一下以下方式。_scoop-cn
文章浏览阅读4.5k次,点赞2次,收藏3次。首先要有一个color-picker组件 <el-color-picker v-model="headcolor"></el-color-picker>在data里面data() { return {headcolor: ’ #278add ’ //这里可以选择一个默认的颜色} }然后在你想要改变颜色的地方用v-bind绑定就好了,例如:这里的:sty..._vue el-color-picker
文章浏览阅读640次。基于芯片日益增长的问题,所以内核开发者们引入了新的方法,就是在内核中只保留函数,而数据则不包含,由用户(应用程序员)自己把数据按照规定的格式编写,并放在约定的地方,为了不占用过多的内存,还要求数据以根精简的方式编写。boot启动时,传参给内核,告诉内核设备树文件和kernel的位置,内核启动时根据地址去找到设备树文件,再利用专用的编译器去反编译dtb文件,将dtb还原成数据结构,以供驱动的函数去调用。firmware是三星的一个固件的设备信息,因为找不到固件,所以内核启动不成功。_exynos 4412 刷机
文章浏览阅读2w次,点赞24次,收藏42次。Linux系统配置jdkLinux学习教程,Linux入门教程(超详细)_linux配置jdk
文章浏览阅读3.3k次,点赞5次,收藏19次。xlabel('\delta');ylabel('AUC');具体符号的对照表参照下图:_matlab微米怎么输入
文章浏览阅读119次。顺序读写指的是按照文件中数据的顺序进行读取或写入。对于文本文件,可以使用fgets、fputs、fscanf、fprintf等函数进行顺序读写。在C语言中,对文件的操作通常涉及文件的打开、读写以及关闭。文件的打开使用fopen函数,而关闭则使用fclose函数。在C语言中,可以使用fread和fwrite函数进行二进制读写。 Biaoge 于2024-03-09 23:51发布 阅读量:7 ️文章类型:【 C语言程序设计 】在C语言中,用于打开文件的函数是____,用于关闭文件的函数是____。
文章浏览阅读3.4k次,点赞2次,收藏13次。跟随鼠标移动的粒子以grid(SOP)为partical(SOP)的资源模板,调整后连接【Geo组合+point spirit(MAT)】,在连接【feedback组合】适当调整。影响粒子动态的节点【metaball(SOP)+force(SOP)】添加mouse in(CHOP)鼠标位置到metaball的坐标,实现鼠标影响。..._touchdesigner怎么让一个模型跟着鼠标移动
文章浏览阅读178次。项目运行环境配置:Jdk1.8 + Tomcat7.0 + Mysql + HBuilderX(Webstorm也行)+ Eclispe(IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持)。项目技术:Springboot + mybatis + Maven +mysql5.7或8.0+html+css+js等等组成,B/S模式 + Maven管理等等。环境需要1.运行环境:最好是java jdk 1.8,我们在这个平台上运行的。其他版本理论上也可以。_基于java技术的停车场管理系统实现与设计
文章浏览阅读3.5k次。前言对于MediaPlayer播放器的源码分析内容相对来说比较多,会从Java-&amp;gt;Jni-&amp;gt;C/C++慢慢分析,后面会慢慢更新。另外,博客只作为自己学习记录的一种方式,对于其他的不过多的评论。MediaPlayerDemopublic class MainActivity extends AppCompatActivity implements SurfaceHolder.Cal..._android多媒体播放源码分析 时序图
文章浏览阅读2.4k次,点赞41次,收藏13次。java 数据结构与算法 ——快速排序法_快速排序法