java各类杂识(内部类、反射等)

各类杂识

内部类

成员内部类

将类作为一个成员属性定义在类内部

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);