编程语言
首页 > 编程语言> > java 高级篇 的补充

java 高级篇 的补充

作者:互联网

反射

class类

反射就是Reflection,Java的反射是指程序在运行期可以拿到一个对象的所有信息

反射是为了解决在运行期,对某个实例一无所知的情况下,如何调用其方法

除了int等基本类型外,Java的其他类型全部都是class(包括interface

只有JVM能创建Class实例,我们自己的Java程序是无法创建Class实例的

JVM为每个加载的class创建了对应的Class实例,并在实例中保存了该class的所有信息,包括类名、包名、父类、实现的接口、所有方法、字段等,因此,如果获取了某个Class实例,我们就可以通过这个Class实例获取到该实例对应的class的所有信息

这种通过Class实例获取class信息的方法称为反射(Reflection)

Class cls1 = String.class;//类.class

String s = "Hello";
Class cls2 = s.getClass();//对象.getClass()

Class cls3 = Class.forName("java.lang.String");
//Class.forName("包名")


boolean sameClass = cls1 == cls2; // true
//Class实例在JVM中是唯一的,所以,上述方法获取的Class实例是同一个实例

只能调用public的无参数构造方法。带参数的构造方法,或者非public的构造方法都无法通过Class.newInstance()被调用

public static void main(String[] args) throws InstantiationException, IllegalAccessException {
        // 获取String的Class实例:
        Class cls = String.class;
// 创建一个String实例:
        String s = (String) cls.newInstance();
        s = "fgj";
        System.out.println(s);
    }

动态加载

JVM在执行Java程序的时候,并不是一次性把所有用到的class全部加载到内存,而是第一次需要用到class时才加载

JVM为每个加载的classinterface创建了对应的Class实例来保存classinterface的所有信息;

获取一个class对应的Class实例后,就可以获取该class的所有信息;

通过Class实例获取class信息的方法称为反射(Reflection);

JVM总是动态加载class,可以在运行期根据条件来控制加载class

访问字段

任意的一个Object实例,只要我们获取了它的Class,就可以获取它的一切信息

public static void main(String[] args) throws NoSuchFieldException {
        Class<Student> stdClass = Student.class;
        // 获取public字段"score":
        System.out.println(stdClass.getField("score"));
        // 获取继承的public字段"name":
        System.out.println(stdClass.getField("name"));
        // 获取private字段"grade":
        System.out.println(stdClass.getDeclaredField("grade"));
    }
}

class Student extends Person{
    public int score;
    private int grade;
}
class Person{
    public String name;
}

获取字段值

public static void main(String[] args) throws Exception {
        Object p = new Person("Xiao Ming");
        Class c = p.getClass();
        Field f = c.getDeclaredField("name");
        Object value = f.get(p);
        System.out.println(value); // "Xiao Ming"
    }
}

class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }
}

设置字段值

public static void main(String[] args) throws Exception {
        Person p = new Person("Xiao Ming");
        System.out.println(p.getName()); // "Xiao Ming"
        Class c = p.getClass();
        Field f = c.getDeclaredField("name");
        f.setAccessible(true);
        f.set(p, "Xiao Hong");
        System.out.println(p.getName()); // "Xiao Hong"
    }
}

class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }
}

Java的反射API提供的Field类封装了字段的所有信息:

通过Class实例的方法可以获取Field实例:getField()getFields()getDeclaredField()getDeclaredFields()

通过Field实例可以获取字段信息:getName()getType()getModifiers()

通过Field实例可以读取或设置某个对象的字段,如果存在访问限制,要首先调用setAccessible(true)来访问非public字段。

通过反射读写字段是一种非常规方法,它会破坏对象的封装。

调用方法

public static void main(String[] args) throws Exception {
        Class stdClass = Student.class;
        // 获取public方法getScore,参数为String:
        System.out.println(stdClass.getMethod("getScore", String.class));
        // 获取继承的public方法getName,无参数:
        System.out.println(stdClass.getMethod("getName"));
        // 获取private方法getGrade,参数为int:
        System.out.println(stdClass.getDeclaredMethod("getGrade", int.class));
    }
}

class Student extends Person {
    public int getScore(String type) {
        return 99;
    }
    private int getGrade(int year) {
        return 1;
    }
}

class Person {
    public String getName() {
        return "Person";
    }
}

调用静态方法

public static void main(String[] args) throws Exception {
        // 获取Integer.parseInt(String)方法,参数为String:
        Method m = Integer.class.getMethod("parseInt", String.class);
        // 调用该静态方法并获取结果:
        Integer n = (Integer) m.invoke(null, "12345");
        // 打印调用结果:
        System.out.println(n);
    }
}

调用非public方法

public static void main(String[] args) throws Exception {
        Person p = new Person();
        Method m = p.getClass().getDeclaredMethod("setName", String.class);
        m.setAccessible(true);
        m.invoke(p, "Bob");
        System.out.println(p.name);
    }
}

class Person {
    String name;
    private void setName(String name) {
        this.name = name;
    }
}

Java的反射API提供的Method对象封装了方法的所有信息:

通过Class实例的方法可以获取Method实例:getMethod(),getMethods(),getDeclaredMethod(),getDeclaredMethods();

通过Method实例可以获取方法信息:getName(),getReturnType(),getParameterTypes(),getModifiers();

通过Method实例可以调用某个对象的方法:Object invoke(Object instance, Object... parameters);

通过设置setAccessible(true)来访问非public方法;

通过反射调用方法时,仍然遵循多态原则。

调用构造方法

public static void main(String[] args) throws Exception {
    // 获取构造方法Integer(int):
    Constructor cons1 = Integer.class.getConstructor(int.class);
    // 调用构造方法:
    Integer n1 = (Integer) cons1.newInstance(123);
    System.out.println(n1);

    // 获取构造方法Integer(String)
    Constructor cons2 = Integer.class.getConstructor(String.class);
    Integer n2 = (Integer) cons2.newInstance("456");
    System.out.println(n2);
}

Constructor对象封装了构造方法的所有信息;

通过Class实例的方法可以获取Constructor实例:getConstructor()getConstructors()getDeclaredConstructor()getDeclaredConstructors()

通过Constructor实例可以创建一个实例对象:newInstance(Object... parameters); 通过设置setAccessible(true)来访问非public构造方法。

获取继承关系

public static void main(String[] args) throws Exception {
        Class i = Integer.class;
        Class n = i.getSuperclass();
        System.out.println(n);
        Class o = n.getSuperclass();
        System.out.println(o);
        System.out.println(o.getSuperclass());
    }
}

获取interface

public static void main(String[] args) throws Exception {
        Class s = Integer.class;
        Class[] is = s.getInterfaces();
        for (Class i : is) {
            System.out.println(i);
        }
    }
}

通过Class对象可以获取继承关系:

通过Class对象的isAssignableFrom()方法可以判断一个向上转型是否可以实现

动态代理

所有interface类型的变量总是通过某个实例向上转型并赋值给接口类型变量

public static void main(String[] args) {
        InvocationHandler handler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println(method);
                if (method.getName().equals("morning")) {
                    System.out.println("Good morning, " + args[0]);
                }
                return null;
            }
        };
        Hello hello = (Hello) Proxy.newProxyInstance(
                Hello.class.getClassLoader(), // 传入ClassLoader
                new Class[] { Hello.class }, // 传入要实现的接口
                handler); // 传入处理调用方法的InvocationHandler
        hello.morning("Bob");
    }
}

interface Hello {
    void morning(String name);
}

Java标准库提供了动态代理功能,允许在运行期动态创建一个接口的实例;

动态代理是通过Proxy创建代理对象,然后将接口方法“代理”给InvocationHandler完成的。


注解

使用注解

Java程序的一种特殊“注释”——注解

注解是放在Java源码的类、方法、字段、参数前的一种特殊“注释

Java的注解可以分为三类:

第一类是由编译器使用的注解,例如:

这类注解不会被编译进入.class文件,它们在编译后就被编译器扔掉了。

第二类是由工具处理.class文件使用的注解,比如有些工具会在加载class的时候,对class做动态修改,实现一些特殊的功能。这类注解会被编译进入.class文件,但加载结束后并不会存在于内存中。这类注解只被一些底层库使用,一般我们不必自己处理。

第三类是在程序运行期能够读取的注解,它们在加载后一直存在于JVM中,这也是最常用的注解。例如,一个配置了@PostConstruct的方法会在调用构造方法后自动被调用(这是Java代码读取该注解实现的功能,JVM并不会识别该注解)。

注解(Annotation)是Java语言用于工具处理的标注:

注解可以配置参数,没有指定配置的参数使用默认值;

如果参数名称是value,且只有一个参数,那么可以省略参数名称。

定义注解

@interface Report {
    int type() default 0;
    String level() default "info";
    String value() default "";
}

注解的参数类似无参数方法,可以用default设定一个默认值(强烈推荐)

元注解

@Target

使用@Target可以定义Annotation能够被应用于源码的哪些位置

@Target(ElementType.METHOD)
public @interface Report {
    int type() default 0;
    String level() default "info";
    String value() default "";
}

@Retention

@Retention定义了Annotation的生命周期:

@Retention(RetentionPolicy.RUNTIME)
public @interface Report {
    int type() default 0;
    String level() default "info";
    String value() default "";
}

@Repeatable

使用@Repeatable这个元注解可以定义Annotation是否可重复

@Inherited

@Inherited定义子类是否可继承父类定义的Annotation

@Inherited
@Target(ElementType.TYPE)
public @interface Report {
    int type() default 0;
    String level() default "info";
    String value() default "";
}

小结

Java使用@interface定义注解:

可定义多个参数和默认值,核心参数使用value名称;

必须设置@Target来指定Annotation可以应用的范围;

应当设置@Retention(RetentionPolicy.RUNTIME)便于运行期读取该Annotation

处理注解

注解本身对代码逻辑没有任何影响

注解如何使用,完全由程序自己决定

小结

可以在运行期通过反射读取RUNTIME类型的注解,注意千万不要漏写@Retention(RetentionPolicy.RUNTIME),否则运行期无法读取到该注解。

可以通过程序处理注解来实现相应的功能:

泛型

泛型是一种“代码模板”,可以用一套代码套用各种类型

向上转型

ArrayList实现了List接口,它可以向上转型为List

特别注意:不能把ArrayList<Integer>向上转型为ArrayList<Number>List<Number>

小结

泛型就是编写模板代码来适应任意类型;

泛型的好处是使用时不必对类型进行强制转换,它通过编译器对类型进行检查;

注意泛型的继承关系:可以把ArrayList<Integer>向上转型为List<Integer>T不能变!),但不能把ArrayList<Integer>向上转型为ArrayList<Number>T不能变成父类)。

擦拭法

泛型是一种类似”模板代码“的技术,不同语言的泛型实现方式不一定相同。

Java语言的泛型实现方式是擦拭法

Java的泛型是采用擦拭法实现的;

擦拭法决定了泛型<T>

泛型方法要防止重复定义方法,例如:public boolean equals(T obj)

子类可以获取父类的泛型类型<T>

extends通配符

使用extends通配符表示可以读,不能写。

使用类似<T extends Number>定义泛型类时表示:

super通配符

对比extends和super通配符

我们再回顾一下extends通配符。作为方法参数,<? extends T>类型和<? super T>类型的区别在于:

一个是允许读不允许写,另一个是允许写不允许读。使用类似<? super Integer>通配符作为方法参数时表示:

即使用super通配符表示只能写不能读。

使用extendssuper通配符要遵循PECS原则。

无限定通配符<?>很少使用,可以用<T>替换,同时它是所有<T>类型的超类。

标签:java,String,补充,高级,class,public,实例,注解,Class
来源: https://www.cnblogs.com/instore/p/16349418.html