各类杂识
内部类
成员内部类
将类作为一个成员属性定义在类内部
public class Student{
public class Inter{}
}
在成员内部类中的方法中可以访问外部类成员(成员内部类成员),使用类名.this.成员(this.成员)
public class Student {
private int age=20;
public class Inter{
private int age=15;
public void play(){
int age=30;
//访问局部属性
System.out.println(age);
//访问内部类属性
System.out.println(this.age);
//在成员内部类中访问外部类成员
System.out.println(Student.this.age);
}
}
}
局部内部类
在成员内部类的局部类中访问内部类成员、外部类成员、内部类的局部类的成员,使用外部类名.内部类名.this.成员、外部类名.this.成员、this.成员
public class Student {
private int age=20;
public class Inter{
private int age=15;
public void play(){
//局部类无法访问局部属性
int age=30;
//访问局部属性
System.out.println(age);
//访问内部类属性
System.out.println(this.age);
//在成员内部类中访问外部类成员
System.out.println(Student.this.age);
//定义局部内部类
class Inter1{
private int age=5;
public void play(){
int age = 10;
//访问局部类内方法的属性
System.out.println(age);
//访问局部类属性
System.out.println(this.age);
//访问Student属性
System.out.println(Student.this.age);
//访问内部类的属性
System.out.println(Student.Inter.this.age);
}
}
Inter1 i1 = new Inter1();
i1.play();
}
}
}
静态内部类
静态内部类的创建对象
Student.Inter i = new Studemt.Inter();
其他和成员内部类差别不大
匿名内部类
用于只需要适用一次的时候,一般用于参数传入。直接new类名创建(实现)子类,需要写方法体,没有类名
play(new Student(){})
回调函数
泛型类、方法、属性
定义泛型属性需要将类也定义成泛型类,但是定义泛型方法可以不将类定义为泛型类
泛型类的泛型在类名后面定义,泛型方法在方法返回值之前定义
public static <T> void sort1(List<T> list, Comparator<? super T> c) {
return;
}
public static <T> void sort2(List<T> list, Comparator<? extends T> c) {
return;
}
反射
类还未定义,但是通过Class的forName(类的位置)方法来获取类的结构以及创建对象和设置值
获取类结构的三种方法
类名.class
对象名.getClass()
Class.forName(类的完整名)
//1、类名.class
Class<Student> studentClass = Student.class;
//2、对象名.getClass()
Student stu = new Student();
Class<? extends Student> stuClass2 = stu.getClass();
//3、Class.forName()
Class stuClass = Class.forName("com.zte.testClass.Student");
获取包名
类反射.getPackage(),返回的是Package类型
stuClass.getPackage();
//获取包名
Package pack = stuClass.getPackage();
获取类的修饰符
先获取修饰符的码,在使用Modifier类解码
Modifier.toString(类反射.getModifier())
Modifier.toString(stuClass.getModifiers());
//获取修饰符
String modifier = Modifier.toString(stuClass.getModifiers());
获取类模板的类型
无法直接获取类的类型,只能通过判断不是interface和八种基本类型来判断是class
stuClass.isInterface()?:"interface":(stuClass.isPrimitive()?"":"class")
//获取类型
String type = stuClass.isInterface() ? "interface":(stuClass.isPrimitive()?"":"class");
获取类名
类反射.getSimpleName()
stuClass.getSimpleName();
//获取类名
String simpleName = stuClass.getSimpleName();
获取父类
类反射.getSuperclass(),返回的是父类的类反射
stuClass.getSuperclass();
//获取父类名
String superClass = stuClass.getSuperclass().getName().equals("java.lang.Object")?"":"extends "+stuClass.getSuperclass().getSimpleName();
获取父接口
类反射.getInterfaces(),返回的是父接口的类反射数组
stuClass.getInterfaces();
//获取接口
Class[] interfaces = stuClass.getInterfaces();
String Inter = "";
if(interfaces!=null&&interfaces.length>0){
Inter += "Implements ";
for (Class inter : interfaces) {
Inter+= inter.getSimpleName()+",";
}
Inter = Inter.substring(0,Inter.length()-1);
}
获取属性
类反射.getDeclaredFields(),返回的是属性数组
//获取属性
Field[] fields = stuClass.getDeclaredFields();
if(fields!=null&&fields.length>0){
for (Field field : fields) {
System.out.println("\t"+Modifier.toString(field.getModifiers())+" "+field.getType().getSimpleName()+" "+field.getName()+";");
}
}
获取方法
类反射.getDeclaredMethods(),返回的是方法类型的数组
//获取方法
stuClass.getDeclaredMethods();
Method[] declaredMethods = stuClass.getDeclaredMethods();
if(declaredMethods!=null&&declaredMethods.length>0){
for (Method method : declaredMethods) {
List<Class<?>> classes = Arrays.asList(method.getParameterTypes());
String methodParameter = "";
if(classes!=null&&classes.size()>0){
for (int i = 0; i < classes.size(); i++) {
methodParameter += classes.get(i).getSimpleName()+" arg"+i+",";
}
methodParameter = methodParameter.substring(0,methodParameter.length()-1);
}
System.out.println("\t"+Modifier.toString(method.getModifiers())+" "+method.getReturnType().getSimpleName()+" "+method.getName()+"("+methodParameter+"){}");
}
}
获取构造方法
类反射.getDeclaredConstructors(),返回的是Constructor类型的数组
stuClass.getDeclaredConstructors();
//获取构造方法
Constructor[] declaredConstructors = stuClass.getDeclaredConstructors();
if(declaredConstructors!=null&&declaredConstructors.length>0){
for (Constructor declaredConstructor : declaredConstructors) {
String constructor = "\tpublic ";
constructor += declaredConstructor.getClass().getSimpleName()+"(";
TypeVariable[] typeParameters = declaredConstructor.getParameterTypes();
String constructorsType = "";
if(typeParameters!=null&&typeParameters.length>0){
for (int i = 0; i < typeParameters.length; i++) {
constructorsType += typeParameters[i].getClass().getSimpleName()+"arg"+i+",";
}
constructorsType = constructorsType.substring(0,constructorsType.length()-1);
}
System.out.println(constructor+constructorsType+"){}");
}
}
根据类反射创建对象
类反射.newInstance(),返回一个Object引用的对象
stuClass.newInstance();
//创建对象
Object o = stuClass.newInstance();
根据反射设置属性
现根据类反射获取类属性,之后通过类属性.set(对象,要设置的值)设置对象的属性值,如果属性为私有的,应当先通过setAccessible(true)设置成属性可访问
stuClass.getDeclaredField(属性名字符串);
//对属性进行复制
Field idField = stuClass.getDeclaredField("id");
idField.setAccessible(true);
idField.set(o,"1005");
根据反射调用方法
先通过类反射.getDeclaredmethod(方法名字符串,参数类型)来得到方法类型,通过方法类型的invoke方法传入值,得到方法的返回值
stuClass.getDeclaredMethod(方法名,参数类型);
//调用方法
Method setState = stuClass.getDeclaredMethod("setState", int.class);
//调用方法,返回结果
Object resout = setState.invoke(o, 50);