package ReflectDemo;
import java.awt.List;
/*
* 反射
* 1.了解
数据库
集群:一堆完成同一功能的服务器搭建的架构。
耦合:两个模块之间相互关联
Service处理数据
1.Dao d=new MySQLDao(); d.add() ->Dao d=new OracleDao() d.add();
2.读取sql.properties文件,根据读取到的内容来确定使用哪一个类,如何将读取到的字符串映射成对应的类?-------反射
Dao操作数据库的接口,定义所有需要操作数据库的方法。
1.MysqlDao ,OracleDao
配置文件:2.sql.properties dao=MySQLDao();
2.反射:在获取这个类的字节码的基础上来解剖这个类。
Class, 代表字节码的类,代表类的类
//Package, 代表包的类
Field, 代表属性的类
Method, 代表方法的类
Constructor代表构造方法的类
//Annotation 代表注解的类
3.获取Class对象
3.1通过类名.class的方式来获取指定类的字节码
3.2通过对象.getClass()来获取对象对应的实际类的字节码
3.3通过Class.forName(类的全路径名);获取指定类的字节码
*/
public class ReflectDemo01 {
public static void main(String[] args) throws ClassNotFoundException {
//Class是一个代表类的类,因此每一个Class对象实际上要对应一个类
//-------------------3.1通过类名.class的方式来获取指定类的字节码-----------------------
//A引用类型 1.类 2接口 3.数组
//1.clz代表String类的字节码
Class<String> clz=String.class;
System.out.println(clz); //输出class java.lang.String
//2.clz2代表list接口的字节码
Class<List> clz2=List.class;
System.out.println(clz2); //输出class java.awt.List
//3.clz3代表int[] 数组的字节码
Class<int[]> clz3= int[].class;
System.out.println(clz3); //输出class [I
//B基本类型
//double的字节码
Class clz4=Double.class;
System.out.println(clz4); //输出class java.lang.Double
//------------------3.2通过对象.getClass()来获取对象对应的实际类的字节码 ---------------------------------
//clz5代表String类的字节码
Object o="abc";
Class<Object> clz5=(Class<Object>)o.getClass();
System.out.println(clz5); //输出class java.lang.String
//--------------------3.3通过Class.forName(类的全路径名);获取指定类的字节码 -------------------------------------
Class<String> clz6=(Class<String>) Class.forName("java.lang.String");
System.out.println(clz6); //输出class java.lang.String
}
}
package ReflectDemo;
import java.io.Serializable;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ReflectDemo02 {
public static void main(String[] args) throws Exception{
// (将读取到的字符串映射成对应的类)
//------------------无参产生对象.newInstance()-------------------
//1.获取到了Object类的字节码
Class<Object> clz=(Class<Object>) Class.forName("java.lang.Object");
//产生Object对象 .newInstance()
Object o=clz.newInstance();
System.out.println(o); //输出java.lang.Object@55f96302
//2.获取String对象
Class<String> clz2=(Class<String>) Class.forName("java.lang.String");
//要求这个类必须提供无参构造 .newInstance()
String str=clz2.newInstance();
System.out.println(str); //输出空
//------------------4.有参产生对象 Constructor代表构造方法的类-------------------------------
//1.获取public构造方法
//.getConstructor(参数类)获取public构造方法
//.newInstance(参数) 执行构造方法
//2.获取私有构造方法
//.getDeclaredConstructor(参数类)
//.setAccessible(true); 暴力破解
//.newInstance(参数) 执行构造方法
//3.获取所有构造方法
//.getDeclaredConstructors()
//3.获取有参构造的Integer对象
Class<Integer> clz3=Integer.class;
//Integer in=clz3.newInstance(); 错误不允许用.newInstance()无参构造
//获取类中的构造方法,参数类型为Integer(int)
Constructor<Integer> c=clz3.getConstructor(int.class);
//执行构造方法,创建对象类的对象
Integer in=c.newInstance(5);
/*
* Constructor<Integer> c=clz3.getConstructor(int.class);
Integer in=c.newInstance(5);
等价于
Integer in=new Integer(5);
*/
System.out.println(in); //输出5
//4.1获取有参构造的String对象
Class<String> clz4=String.class;
Constructor<String> c2=clz4.getConstructor(String.class);
//执行构造方法,创建对象类的对象
String str2=c2.newInstance("abc");
System.out.println(str2); //输出abc
//4.2.getConstructor()只能获取public的构造方法
//Constructor<String> c3=clz4.getConstructor(char[].class,boolean.class); 出错
//System.out.println(c3);
//4.3.getDeclaredConstructor()获取这个类的任意的构造方法,不区分权限修饰符
Constructor<String> c4=clz4.getDeclaredConstructor(char[].class, boolean.class);
//.setAccessible(true)暴力破解/拆除,会打破封装特性
c4.setAccessible(true);
System.out.println(c4.newInstance(new char[] {'a','d','s'} ,true)); //输出ads
//5.获取所有的构造方法
Class<String> clz5=String.class;
Constructor[] cs=clz5.getDeclaredConstructors();
for(Constructor cst:cs) {
System.out.println(cst);
}
//输出
/*
* public java.lang.String(byte[],int,int)
public java.lang.String(byte[],java.nio.charset.Charset)
public java.lang.String(byte[],java.lang.String) throws java.io.UnsupportedEncodingException
public java.lang.String(byte[],int,int,java.nio.charset.Charset)
public java.lang.String(byte[],int,int,java.lang.String) throws java.io.UnsupportedEncodingException
java.lang.String(char[],boolean)
public java.lang.String(java.lang.StringBuilder)
public java.lang.String(java.lang.StringBuffer)
public java.lang.String(byte[])
public java.lang.String(int[],int,int)
public java.lang.String()
public java.lang.String(char[])
public java.lang.String(java.lang.String)
public java.lang.String(char[],int,int)
public java.lang.String(byte[],int)
public java.lang.String(byte[],int,int,int)
*/
//----------------------5.获取类中方法Method代表方法的类--------------
//----------Method .getDeclaredMethod()----------
//----------[setAccessible(true)暴力破解私有]---
//----------invoke()执行----------
//6.1获取类中指定的方法 public charAt(int)
Method m=clz5.getDeclaredMethod("charAt", int.class);
String str4="sadadsa";
//执行方法
char c5=(char) m.invoke(str4, 5);
System.out.println(c5); //输出s
//获取字符串的长度
Method m1=clz5.getDeclaredMethod("length");
int len=(int) m1.invoke(str4);
System.out.println(len); //输出7
//6.2获取类中所有的方法 包含私有
Method m2=clz5.getDeclaredMethod("indexOfSupplementary",int.class,int.class);
//暴力破解/拆除,会打破封装特性
m2.setAccessible(true);
int i=(int) m2.invoke(str4, 1,5);
System.out.println(i); //输出-1
//------------------6.获取类中的属性Field-代表属性的类--------------------
//-------------Field .getDeclaredField(属性)--------------------------------
//-------------[setAccessible(true)暴力破解私有]-------------------------
//--------------set设置属性,get获取属性--------------------------------
Class<String> clz6=String.class;
Field f=clz6.getDeclaredField("hash");
System.out.println(f); //输出private int java.lang.String.hash
f.setAccessible(true);
f.set(str, 248); //设置属性
System.out.println(f.get(str));//获取属性 //输出248
//----------------7. getEnumConstants()获取枚举常量------------------------------------
//获取枚举中所有的枚举常量
Class<Level> clz7=Level.class;
Level[] is=clz7.getEnumConstants(); //如果这个类不是枚举,返回null
for(Level lv:is) {
System.out.println(lv); //输出ABCD
}
// 如果这个类不是枚举,则返回null
System.out.println(clz.getEnumConstants());//输出null
//--------------8. 获取所在的包 Package .getPackage()---------------------
Package p = clz7.getPackage();
System.out.println(p); //输出package ReflectDemo
//---------------9. 获取类的全路径名 getName()------------------------------
System.out.println(clz7.getName()); //输出ReflectDemo.Level
//--------------10. 只获取类名 .getSimpleName()-----------------------------
System.out.println(clz7.getSimpleName());//输出Level
// 如果这个类不是枚举,则返回null
// System.out.println(clz.getEnumConstants());
// --------------11.获取这个类实现的接口 .getInterfaces()-------------------------
// Class<String> clz6=String.class;
Class[] cs2=clz6.getInterfaces();
for(Class sd:cs2) {
System.out.println(sd); //输出interface java.io.Serializable interface java.lang.Comparable interface java.lang.CharSequence
}
//--------------12.获取这个类的父类 .getSuperclass()-------------------------
System.out.println(clz6.getSuperclass()); //输出class java.lang.Object
//-----------13.判断是否是匿名内部类 isAnonymousClass()-----------------------
A a=new A() {
};
System.out.println(a.getClass().isAnonymousClass()); //输出true
//-----------14.判断是否是方法内部类 isLocalClass()------------------------------
class B{ }
System.out.println(B.class.isLocalClass()); //输出true
//-----------15.判断是否是成员内部类 .isMemberClass()----------------------------
System.out.println(B.class.isMemberClass()); //输出false
System.out.println(String.class.isMemberClass()); //输出false
//------------16. 判断是否是一个基本类型 .isPrimitive()--------------------
Class<Object> clz10 = Object.class;
System.out.println(clz.isPrimitive()); //输出false
System.out.println(short.class.isPrimitive());//输出true
//------------17. 判断参数是否继承了当前的类 .isAssignableFrom()------------------
System.out.println(Serializable.class.isAssignableFrom(String.class)); //输出true
Class<Object> clz9=Object.class;
System.out.println(clz9.isAssignableFrom(Object.class)); //输出true
//----------- 18.判断是否是数组 .isArray()-----------------------------
Class<String[]> clz8=String[].class;
System.out.println(clz8.isArray()); //输入true
//------------19.判断是否是接口 .isInterface()---------------------------
System.out.println(clz8.isInterface()); //输出false
//------------20.判断对象是否是指定类型的实例 .isInstance()---------------------
Object z="abc";
System.out.println(clz8.isInstance(z)); //输出false
}
}
enum Level{
A,B,C,D;
}
class A{
}
package ReflectDemo;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ReflectDemo03 {
public static void main(String[] args) throws Exception {
Class<String> clz=String.class;
//------------1.获取属性的声明类型 .getType()-----------------
Field f=clz.getDeclaredField("hash");
System.out.println(f.getType()); //输出int
//-----------2.判断是的是一个枚举常量.isEnumConstant()------------------
System.out.println(f.isEnumConstant());//输出false
//----------3.获取这个方法抛出的异常.getExceptionTypes()--------------
Method m=clz.getDeclaredMethod("getBytes", String.class);
Class[] es=m.getExceptionTypes();
for(Class e:es) {
System.out.println(e); //输出class java.io.UnsupportedEncodingException
}
//-------------4.获取方法名 .getName()---------------------------------------
System.out.println(m.getName()); //输出getBytes
//-----------5.获取方法参数的类型 .getParameterTypes()---------------------
Class[] ps=m.getParameterTypes();
for(Class e:ps) {
System.out.println(e); //输出class java.lang.String
}
//------------6.获取返回值类型 .getReturnType()-----------------------
System.out.println(m.getReturnType()); //输出class [B
//-------------7.判断是否有可变参数 .isVarArgs()----------------------
System.out.println(m.isVarArgs()); //输出false
//数据库的没写完 看一下------------------
}
}
package Note;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
/*
* 注解:
* 给程序看的解释,在JAVA中注解的父类是Annotation
* 1.
* 1.1用@interface定义一个注解
* 1.2如果在注解中直接定义一个属性,那么这个属性默认是一个静态常量public static final
* 1.3注解中的属性 加() 注解中的属性只能是基本类型,枚举,String,Class,其他注解类型,以及它们定义的一维数组
* 1.4default指定默认值
* 1.5.如果注解中的属性是一维数组,并且在赋值的时候,一维数组中只有一个值,可以直接将这个值赋值给属性 一维数组多个值赋值 { , }
* 1.6如果注解中只有一个属性并且名字是Value,那么在使用这个注解的时候可以省略属性不写
*
* 2.元注解:修饰注解的注解
* 2.1@Target限定注解的使用范围
* 2.2@Retention 限制注解的生命周期 --------听一下--------------234--
* 2.3@Documented 限定这个注解在使用的时候产生到文档中
* 2.4@Inherited 限制此注释可以作用在子类上
*
*
*/
//1.5如果注解中的属性是一维数组,并且在赋值的时候,一维数组中只有一个值,可以直接将这个值赋值给属性 一维数组多个值赋值 { , }
@Time(year=2018,month=07,time= {2,5})
//1.6如果注解中只有一个属性并且名字是Value,那么在使用这个注解的时候可以省略属性不写
@SAnno("ded")
public class NoteDemo {
@SAnno("ded")
public void m1(@SAnno("ded") int i) {};
}
//1.1用@interface定义一个注解
@interface Time{
//1.2如果在注解中直接定义一个属性,那么这个属性默认是一个静态常量
//public static final int year=18
//int year=18 ;
//1.3注解中的属性 加()
//注解中的属性只能是基本类型,枚举,String,Class,其他注解类型,以及它们定义的一维数组
int year();
int[] month();
double[] time();
int day()default 28; //1.4.default指定默认值
//boolean flag(); 对
//Object o(); 1.3出错,注解中的属性只能是基本类型,枚举,String,Class,其他注解类型,以及它们定义的一维数组
//String str();
}
//2.1@Target 限定注解的使用范围
//注解在类,属性,方法,参数上使用
@Target({ElementType.TYPE,ElementType.FIELD,ElementType.METHOD, ElementType.PARAMETER})
//2.3@Documented 限定这个注解在使用的时候产生到文档中
@Documented
@interface SAnno{
String value();//1.6如果注解中只有一个属性并且名字是Value,那么在使用这个注解的时候可以省略属性不写
}
package JVM;
/*
* JVM参数
*
标准参数:-d,-ea
非标准参数: -X
扩展参数:-XX
1.栈内存
每一个线程都有一个独立的栈内存,因此栈内存的大小影响线程的个数
JVM限定了栈内存的大小不能超过2G或者物理内存的1/3(取两者的较小值)
* 例电脑内存4G 最多1/3=1.3G 电脑内存16G最多2G
*
*-Xss128K 表示限定栈内存的大小为128K ,右键Run as -> Run configurations->Arguments->VM arguments-> 输入-Xss128K
*
*2.堆内存
*-Xmn 表示限定新生代的大小
*-Xms 表示限定堆内存的初始大小
*-Xmx 表示限定堆内存的最大值
*-XX:+PrintGCDetails 打印GC运行细节
*-Xmn5M -Xms10M -Xmx10M -XX:+PrintGCDetails
*
*注意:对象在创建之后先试图放入新生代,如果新生代存不开,则试图放入老生代。
*
*
*
*
*
*3.常见的回收方式
*Copying 赋值
*Mark-sweeping标记整理法 //最好,另外两种方法的总和
*Mark-cleaning标记清理法
*
*/
public class JVMDemo01 {
static int count=0;
public static void main(String[] args) {
//限定栈内存,右键Run as -> Run configurations->Arguments->VM arguments-> 输入-Xss128K
//add(10000);
//输出到893,会出现893 java.lang.StackOverflowError栈溢出
//右键Run as -> Run configurations->Arguments->VM arguments-> 输入-Xmn5M -Xms10M -Xmx10M -XX:+PrintGCDetails听一下
byte[] bs=new byte[1024*1024*8]; //8M=8*1024k=8*1024*1024b
//出现java.lang.OutOfMemoryError: Java heap space 堆内存溢出
}
//递归求和
public static int add(int n) {
System.out.println(count++);
if(n==1)return 1;
return n+add(--n);
}
}