Java23
关于反射—reflect：
耦合度：多个模块之间的关联或者依赖关系；
而反射就可以降低模块之间的耦合度；
反射用于解析类，解析找到字节码对象以产生实例对象的过程；
字节码对象—也就是 class对象
反射的缺点:—（也是反射的强大之处）
1、打破封装原则；
2、跳过泛型的类型检测；
Class-----代表类的类------代表字节码文件的类；
Field-----代表属性的类；
Method ---- 代表方法的类；
Construct----代表构造方法的类
Annoctatoion—代表包的类
Package–代表包的类，
获取字节码对象的方式：
第一种
获取字节码对象
public static void main(String[] args){
// 通过类名.class;
//获取String的字节码对象；
Class<String> str =String.class;
System.out.println(str);
//获取List接口的字节码对象；
Class<List> ls = List.class;
System.out.println(ls);
//获取基本类型的字节码对象
Class in = int.class;
}
第二种方式
public static void main(String[] args){
//对象.getClass;
String str = "abc";
Class<String> st = (Class<String>)str.getClass;
System.out.println(st);
Integer in = 12;
Class<Integer> in1=(Class<Integer>)in.Class();
System.out.println(in1);
}
第三种方法
public static void main(String[] args){
//类和对象都获取不到的时候
//Class.forName(字符串形式的全路径名称);--即可获取对应的字节码对象；
Class cl = Class.forName("java.util.Date");
System.out.println(cl);
}
public static void main(String[] args){
//先获取String的字节码对象
Class<String>= str = String.class;
//获取实例对象
//newInstance()----就是默认在调用类的无参构造；
String st = str.newInstance();
//通过字节码对象调用String类的有参构造
Construction c = str.getConstruction(char[].class);//传入构造方法的参数类型的字节码对象；
// 获取到的有参构造，调用Instance，传入实际参数，创建实例对象；
String s = (String)c.newInstance(new char[]{'1','2','3'});
System..out.println(s);
//获取构造方法
Constructor c1 = str.getConstructor(String.class);
String s1 = (String) c1.newInstance("asd");
System.out.println(s1);
通过Integer的全路径名获取Integer的实例对象并赋值
Class<Integer>in1 = (Class<Integer>);
Class.forName("java.lang.Integer");
Integer inn = (Integer)in1.newInstance(12);
System.out.println(inn);
}
public static void main(String[] args){
Class<String> clz = String.class;
//获取默认构造方法的方式
clz.getDeclaredConstructor(char[].class,boolean.class);
//暴力破解--可以操作特殊的构造方法；
c.setAccessible(true);
//传参
String str = (String)c.newInstance(new char[]{'1'},true);
System.out.println(str);
//获取类中的所有构造方法；
/*Constructor[] sc =clz.getDeclaredCinstructors();
for(Constructor Constructor:cs){
System.out.println(Constructor);*/
}
}
public static void main(String args[]){
//String字节码对象
//获取
Class<Sting> clz = String.class;
//获取指定的属性--hash
Field f = clz.getDeclaredField("hash");
//暴力破解
f.setAccessible(true);
//字符串对象----属性；
String str = "asd";
//给对象的属性赋值---给Str对象的hash属性赋值为456；
f.set(srt,456);
//取值--获取str队形hash属性的值；
System.println(f.get(str));
}
public static void main(String[] args){
Class<String> clz = String.class;
Method m = clz.getDeclaredMetod("charAt",int.class);
String s = "adad";
//通过 .invoke调用方法；
char c = (char)m.invoke(s,3);
System.out.println(c);
}
关于注解
可以自定义注解，如下：
@interface First{
//默认被public static final修饰
int i=10;
//声明属性 ,不赋值的方式
double d();
// 支持的属性类型--基本数据类型，String，class
// annotation、enum、一维数组
}
关于元注解---用于控制、限制注解的使用情况；
@Target---控制注解可以在什么位置使用
@Ratation
关於单例设计模式
简单举例三个
直接生产本类对象
class TaskManager{
// 构造方法私有化
// 饥饿式实现方式
private TaskManager (){
}
//创建对象
private static final TaskManager tm = new TaskManager();
//给外界获取的方法
public static TaskManager getInstance(){
// 把唯一 一个对象进行返回；
return tm;
}
}
需要调用对象时才生成对应的对象，但是会存在多线程并发安全的问题；
class TaskManager{
// 构造方法私有化
// 懒汉式实现方式
private TaskManager (){
}
//创建对象
private static TaskManager tm = null;
//给外界获取的方法
public static TaskManager getInstance(){
//判断对象是否为null；
if(tm==null){
tm = new TaskManager();
}
return tm;
}
}
//枚举实现方式，优点是可以防止反射破坏
enum TaskManager{
tm;
}
关于JVM参数
栈：用于计算的 是被线程单独使用
堆：存储的是对象 是被所有线程共享的
方法区：原名永久代 方法区挪到堆里 存储的是类的所有信息 被
所有线程共享
本地方法栈：用于计算的本地方法 被线程单独使用
PC计数器：用于存储计算机/程序的指令以及调度 被线程单独使用
-X 参数—标准参数
-Xxxx 参数—非标准参数
-XXxxx 参数—扩展参数
-Xss128K—指定的是栈内存的大小
-Xmx—对的最大内存大小
-XX:+PrintGCDetails—指明GC的执行的详细细节