最后
由于篇幅有限,这里就不一一罗列了,20道常见面试题(含答案)+21条MySQL性能调优经验小编已整理成Word文档或PDF文档
还有更多面试复习笔记分享如下
Class clz = MyClass.class;
Annotation[] annotations = clz.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotation.toString());
}
OperType operType = clz.getAnnotation(OperType.class);
System.out.println(operType);
OperType[] operTypes = clz.getAnnotationsByType(OperType.class);
for (OperType type : operTypes) {
System.out.println(type.toString());
}
}
}
// 输出结果为
@com.nobody.OperTypes(value=[@com.nobody.OperType(value=[add]), @com.nobody.OperType(value=[update])])
null
@com.nobody.OperType(value=[add])
@com.nobody.OperType(value=[update])
在Java8中,ElementType枚举新增了两个枚举成员,分别为TYPE_PARAMETER和TYPE_USE,TYPE_PARAMETER标识注解可以作用于类型参数,TYPE_USE标识注解可以作用于标注任意类型(除了Class)。
===================================================================
我们先了解下什么是静态语言和动态语言。动态语言是指在运行时可以改变其自身结构的语言。例如新的函数,对象,甚至代码可以被引进,已有的函数可以被删除或者结构上的一些变化。简单说即是在运行时代码可以根据某些条件改变自身结构。动态语言主要有C#,Object-C,JavaScript,PHP,Python等。静态语言是指运行时结构不可改变的语言,例如Java,C,C++等。
Java不是动态语言,但是它可以称为准动态语言,因为Java可以利用反射机制获得类似动态语言的特性,Java的动态性让它在编程时更加灵活。
反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息,并能直接操作任意对象的内部属性以及方法等。类在被加载完之后,会在堆内存的方法区中生成一个Class类型的对象,一个类只有一个Class对象,这个对象包含了类的结构信息。我们可以通过这个对象看到类的结构。
比如我们可以通过Class clz = Class.forName("java.lang.String");
获得String类的Class对象。我们知道每个类都隐式继承Object类,Object类有个getClass()
方法也能获取Class对象。
Java反射机制提供的功能
-
在运行时判断任意一个对象所属的类
-
在运行时构造任意一个类的对象
-
在运行时判断任意一个类具有的成员变量和方法
-
在运行时获取泛型信息
-
在运行时调用任意一个对象的成员变量和方法
-
在运行时获取注解
-
生成动态代理
-
…
Java反射机制的优缺点
-
优点:实现动态创建对象和编译,有更加的灵活性。
-
缺点:对性能有影响。使用反射其实是一种解释操作,即告诉JVM我们想要做什么,然后它满足我们的要求,所以总是慢于直接执行相同的操作。
Java反射相关的主要API
-
java.lang.Class:代表一个类
-
java.lang.reflect.Method:代表类的方法
-
java.lang.reflect.Field:代表类的成员变量
-
java.lang.reflect.Constructor:代表类的构造器
我们知道在运行时通过反射可以准确获取到注解信息,其实以上类(Class,Method,Field,Constructor等)都直接或间接实现了AnnotatedElement接口,并实现了它定义的方法,AnnotatedElement接口的作用主要用于表示正在JVM中运行的程序中已使用注解的元素,通过该接口提供的方法可以获取到注解信息。
============================================================================
在Java反射中,最重要的是Class这个类了。Class本身也是一个类。当程序想要使用某个类时,如果此类还未被加载到内存中,首先会将类的class文件字节码加载到内存中,并将这些静态数据转换为方法区的运行时数据结构,然后生成一个Class类型的对象(Class对象只能由系统创建),一个类只有一个Class对象,这个对象包含了类的结构信息。我们可以通过这个对象看到类的结构。每个类的实例都会记得自己是由哪个Class实例所生成的。
通过Class对象可以知道某个类的属性,方法,构造器,注解,以及实现了哪些接口等信息。注意,只有class,interface,enum,annotation,primitive type,void,[] 等才有Class对象。
package com.nobody;
import java.lang.annotation.ElementType;
import java.util.Map;
public class TestClass {
public static void main(String[] args) {
// 类
Class myClassClass = MyClass.class;
// 接口
Class
// 枚举
Class elementTypeClass = ElementType.class;
// 注解
Class overrideClass = Override.class;
// 原生类型
Class integerClass = Integer.class;
// 空类型
Class voidClass = void.class;
// 一维数组
Class<String[]> aClass = String[].class;
// 二维数组
Class<String[][]> aClass1 = String[][].class;
// Class类也有Class对象
Class classClass = Class.class;
System.out.println(myClassClass);
System.out.println(mapClass);
System.out.println(elementTypeClass);
System.out.println(overrideClass);
System.out.println(integerClass);
System.out.println(voidClass);
System.out.println(aClass);
System.out.println(aClass1);
System.out.println(classClass);
}
}
// 输出结果
class com.nobody.MyClass
interface java.util.Map
class java.lang.annotation.ElementType
interface java.lang.Override
class java.lang.Integer
void
class [Ljava.lang.String;
class [[Ljava.lang.String;
class java.lang.Class
获取Class对象的方法
-
如果知道具体的类,可通过类的class属性获取,这种方法最安全可靠并且性能最高。
Class clz = User.class;
-
通过类的实例的getClass()方法获取。
Class clz = user.getClass();
-
如果知道一个类的全限定类名,并且在类路径下,可通过Class.forName()方法获取,但是可能会抛出ClassNotFoundException。
Class clz = Class.forName("com.nobody.User");
-
内置的基本数据类型可以直接通过类名.Type获取。
Class<Integer> clz = Integer.TYPE;
-
通过类加载器ClassLoader获取
Class类的常用方法
-
public static Class<?> forName(String className):创建一个指定全限定类名的Class对象
-
public T newInstance():调用Class对象所代表的类的无参构造方法,创建一个实例
-
public String getName():返回Class对象所代表的类的全限定名称。
-
public String getSimpleName():返回Class对象所代表的类的简单名称。
-
public native Class<? super T> getSuperclass():返回Class对象所代表的类的父类的Class对象,这是一个本地方法
-
public Class<?>[] getInterfaces():返回Class对象的接口
-
public Field[] getFields():返回Class对象所代表的实体的public属性Field对象数组
-
public Field[] getDeclaredFields():返回Class对象所代表的实体的所有属性Field对象数组
-
public Field getDeclaredField(String name):获取指定属性名的Field对象
-
public Method[] getDeclaredMethods():返回Class对象所代表的实体的所有Method对象数组
-
public Method getDeclaredMethod(String name, Class<?>… parameterTypes):返回指定名称和参数类型的Method对象
-
myClassClass.getDeclaredConstructors();:返回所有Constructor对象的数组
-
public ClassLoader getClassLoader():返回当前类的类加载器
在反射中经常会使用到Method的invoke方法,即public Object invoke(Object obj, Object... args)
,我们简单说明下:
-
第一个Object对应原方法的返回值,若原方法没有返回值,则返回null。
-
第二个Object对象对应调用方法的实例,若原方法为静态方法,则参数obj可为null。
-
第二个Object对应若原方法形参列表,若参数为空,则参数args为null。
-
若原方法声明为private修饰,则调用invoke方法前,需要显示调用方法对象的method.setAccessible(true)方法,才可访问private方法。
=================================================================
泛型是JDK 1.5的一项新特性,它的本质是参数化类型(Parameterized Type)的应用,也就是说所操作的数据类型被指定为一个参数,在用到的时候再指定具体的类型。这种参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型接口和泛型方法。
在Java中,采用泛型擦除的机制来引入泛型,泛型能编译器使用javac时确保数据的安全性和免去强制类型转换问题,泛型提供了编译时类型安全检测机制,该机制允许程序员在编译时检测到非法的类型。并且一旦编译完成,所有和泛型有关的类型会被全部擦除。
Java新增了ParameterizedType
,GenericArrayType
,TypeVariable
和WildcardType
等几种类型,能让我们通过反射操作这些类型。
-
ParameterizedType:表示一种参数化类型,比如Collection
-
GenericArrayType:表示种元素类型是参数化类型或者类型变量的数组类型
-
TypeVariable:是各种类型变量的公共父接口
-
WildcardType:代表种通配符类型表达式
package com.nobody;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Map;
public class TestReflectGenerics {
public Map<String, Person> test(Map<String, Integer> map, Person person) {
return null;
}
public static void main(String[] args) throws NoSuchMethodException {
// 获取test方法对象
Method test = TestReflectGenerics.class.getDeclaredMethod(“test”, Map.class, Person.class);
// 获取方法test的参数类型
Type[] genericParameterTypes = test.getGenericParameterTypes();
for (Type genericParameterType : genericParameterTypes) {
System.out.println(“方法参数类型:” + genericParameterType);
// 如果参数类型等于参数化类型
if (genericParameterType instanceof ParameterizedType) {
// 获得真实参数类型
Type[] actualTypeArguments =
((ParameterizedType) genericParameterType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
System.out.println(" " + actualTypeArgument);
}
}
}
// 获取方法test的返回值类型
Type genericReturnType = test.getGenericReturnType();
System.out.println(“返回值类型:” + genericReturnType);
// 如果参数类型等于参数化类型
if (genericReturnType instanceof ParameterizedType) {
// 获得真实参数类型
Type[] actualTypeArguments =
((ParameterizedType) genericReturnType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
System.out.println(" " + actualTypeArgument);
}
}
}
}
class Person {}
// 输出结果
方法参数类型:java.util.Map<java.lang.String, java.lang.Integer>
class java.lang.String
class java.lang.Integer
方法参数类型:class com.nobody.Person
返回值类型:java.util.Map<java.lang.String, com.nobody.Person>
class java.lang.String
class com.nobody.Person
=================================================================
在Java运行时,通过反射获取代码中的注解是比较常用的手段了,获取到了注解之后,就能知道注解的所有信息了,然后根据信息进行相应的操作。下面通过一个例子,获取类和属性的注解,解析映射为数据库中的表信息。
package com.nobody;
import java.lang.annotation.*;
public class AnalysisAnnotation {
public static void main(String[] args) throws Exception {
Class<?> aClass = Class.forName(“com.nobody.Book”);
// 获取类的指定注解,并且获取注解的值
Table annotation = aClass.getAnnotation(Table.class);
String value = annotation.value();
System.out.println(“Book类映射的数据库表名:” + value);
java.lang.reflect.Field bookName = aClass.getDeclaredField(“bookName”);
TableField annotation1 = bookName.getAnnotation(TableField.class);
System.out.println(“bookName属性映射的数据库字段属性 - 列名:” + annotation1.colName() + “,类型:”
- annotation1.type() + “,长度:” + annotation1.length());
java.lang.reflect.Field price = aClass.getDeclaredField(“price”);
TableField annotation2 = price.getAnnotation(TableField.class);
System.out.println(“price属性映射的数据库字段属性 - 列名:” + annotation2.colName() + “,类型:”
- annotation2.type() + “,长度:” + annotation2.length());
}
}
// 作用于类的注解,用于解析表数据
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Table {
// 表名
String value();
}
// 作用于字段,用于解析表列
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface TableField {
// 列名
String colName();
// 列类型
String type();
// 长度
int length();
}
@Table(“t_book”)
class Book {
@TableField(colName = “name”, type = “varchar”, length = 15)
String bookName;
@TableField(colName = “price”, type = “int”, length = 10)
int price;
}
// 输出结果
Book类映射的数据库表名:t_book
bookName属性映射的数据库字段属性 - 列名:name,类型:varchar,长度:15
price属性映射的数据库字段属性 - 列名:price,类型:int,长度:10
===============================================================
前面我们说过,反射对性能有一定影响。因为反射是一种解释操作,它总是慢于直接执行相同的操作。而且Method,Field,Constructor都有setAccessible()方法,它的作用是开启或禁用访问安全检查。如果我们程序代码中用到了反射,而且此代码被频繁调用,为了提高反射效率,则最好禁用访问安全检查,即设置为true。
package com.nobody;
import java.lang.reflect.Method;
public class TestReflectSpeed {
// 10亿次
private static int times = 1000000000;
public static void main(String[] args) throws Exception {
test01();
test02();
test03();
}
public static void test01() {
Teacher t = new Teacher();
long start = System.currentTimeMillis();
for (int i = 0; i < times; i++) {
t.getName();
}
long end = System.currentTimeMillis();
System.out.println(“普通方式执行10亿次消耗:” + (end - start) + “ms”);
}
public static void test02() throws Exception {
Teacher teacher = new Teacher();
Class<?> aClass = Class.forName(“com.nobody.Teacher”);
Method getName = aClass.getDeclaredMethod(“getName”);
long start = System.currentTimeMillis();
for (int i = 0; i < times; i++) {
getName.invoke(teacher);
最后
针对最近很多人都在面试,我这边也整理了相当多的面试专题资料,也有其他大厂的面经。希望可以帮助到大家。
最新整理面试题
上述的面试题答案都整理成文档笔记。也还整理了一些面试资料&最新2021收集的一些大厂的面试真题
最新整理电子书
最新整理大厂面试文档
以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持。
od getName = aClass.getDeclaredMethod(“getName”);
long start = System.currentTimeMillis();
for (int i = 0; i < times; i++) {
getName.invoke(teacher);
最后
针对最近很多人都在面试,我这边也整理了相当多的面试专题资料,也有其他大厂的面经。希望可以帮助到大家。
最新整理面试题
[外链图片转存中…(img-uMZWL1Ti-1715245859290)]
上述的面试题答案都整理成文档笔记。也还整理了一些面试资料&最新2021收集的一些大厂的面试真题
最新整理电子书
[外链图片转存中…(img-dbqzh5BA-1715245859291)]
最新整理大厂面试文档
[外链图片转存中…(img-4iISdFZr-1715245859291)]
以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持。