最后
面试是跳槽涨薪最直接有效的方式，马上金九银十来了，各位做好面试造飞机，工作拧螺丝的准备了吗？
掌握了这些知识点，面试时在候选人中又可以夺目不少，暴击9999点。机会都是留给有准备的人，只有充足的准备，才可能让自己可以在候选人中脱颖而出。
//字符串的例子
clazz = String.class;
clazz = “javaTest”.getClass();
clazz = Class.forName(“java.lang.String”);
System.out.println();
}
}
复制代码
Class类的常用方法
方法名
功能说明
static Class forName(String name)
返回指定类名 name 的 Class 对象
Object newInstance()
调用缺省构造函数，返回该Class对象的一个实例
Object newInstance(Object []args)
调用当前格式构造函数，返回该Class对象的一个实例
getName()
返回此Class对象所表示的实体（类、接口、数组类、基本类型或void）名称
Class getSuperClass()
返回当前Class对象的父类的Class对象
Class [] getInterfaces()
获取当前Class对象的接口
ClassLoader getClassLoader()
返回该类的类加载器
Class getSuperclass()
返回表示此Class所表示的实体的超类的Class
Class类的newInstance（）方法
复制代码
public void testNewInstance() throws ClassNotFoundException, InstantiationException, IllegalAccessException{
String className=“com.atguigu.java.fanshe.Person”;
Class clazz = Class.forName(className);
//利用Class对象的newInstance方法创建一个类的实例
Object obj = clazz.newInstance();
System.out.println(obj);
}
//结果是：com.atguigu.java.fanshe.Person@2866bb78
复制代码
可以看出确实是创建了一个Person实例
但是Person类有两个构造方法，到底是调用的哪一个构造方法呢
实际调用的是类的无参数的构造器。所以在我们在定义一个类的时候，定义一个有参数的构造器，作用是对属性进行初始化，还要写一个无参数的构造器，作用就是反射时候用。
一般地、一个类若声明一个带参的构造器，同时要声明一个无参数的构造器
2.ClassLoader
类装载器是用来把类(class)装载进 JVM 的。JVM 规范定义了两种类型的类装载器：启动类装载器(bootstrap)和用户自定义装载器(user-defined class loader)。 JVM在运行时会产生3个类加载器组成的初始化加载器层次结构 ，如下图所示：
复制代码
public class ReflectionTest {
@Test
public void testClassLoader() throws ClassNotFoundException, FileNotFoundException{
//1. 获取一个系统的类加载器(可以获取，当前这个类PeflectTest就是它加载的)
ClassLoader classLoader = ClassLoader.getSystemClassLoader();
System.out.println(classLoader);
//2. 获取系统类加载器的父类加载器（扩展类加载器，可以获取）.
classLoader = classLoader.getParent();
System.out.println(classLoader);
//3. 获取扩展类加载器的父类加载器（引导类加载器，不可获取）.
classLoader = classLoader.getParent();
System.out.println(classLoader);
//4. 测试当前类由哪个类加载器进行加载（系统类加载器）:
classLoader = Class.forName(“com.atguigu.java.fanshe.ReflectionTest”)
.getClassLoader();
System.out.println(classLoader);
//5. 测试 JDK 提供的 Object 类由哪个类加载器负责加载（引导类）
classLoader = Class.forName(“java.lang.Object”)
.getClassLoader();
System.out.println(classLoader);
}
}
//结果：
//sun.misc.Launcher A p p C l a s s L o a d e r @ 5 f f d f b 42 / / s u n . m i s c . L a u n c h e r AppClassLoader@5ffdfb42 //sun.misc.Launcher AppClassLoader@5ffdfb42//sun.misc.LauncherExtClassLoader@1b7adb4a
//null
//sun.misc.Launcher$AppClassLoader@5ffdfb42
//null
复制代码
使用类加载器获取当前类目录下的文件
首先，系统类加载器可以加载当前项目src目录下面的所有类，如果文件也放在src下面，也可以用类加载器来加载
调用 getResourceAsStream 获取类路径下的文件对应的输入流.
复制代码
、public class ReflectionTest {
@Test
public void testClassLoader() throws FileNotFoundException{
//src目录下，直接加载
InputStream in1 = null;
in1 = this.getClass().getClassLoader().getResourceAsStream(“test1.txt”);
//放在内部文件夹，要写全路径
InputStream in2 = null;
in2 = this.getClass().getClassLoader().getResourceAsStream(“com/atguigu/java/fanshe/test2.txt”);
}
}
复制代码
3.反射
反射概述
Reflection（反射）是Java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的內部信息，并能直接操作任意对象的内部属性及方法。
Java反射机制主要提供了以下功能：
在运行时构造任意一个类的对象
在运行时获取任意一个类所具有的成员变量和方法
在运行时调用任意一个对象的方法（属性）
生成动态代理
Class 是一个类; 一个描述类的类.
封装了描述方法的 Method,
描述字段的 Filed,
描述构造器的 Constructor 等属性.
3.1如何描述方法-Method
复制代码
public class ReflectionTest {
@Test
public void testMethod() throws Exception{
Class clazz = Class.forName(“com.atguigu.java.fanshe.Person”);
//
//1.获取方法
// 1.1 获取取clazz对应类中的所有方法–方法数组（一）
// 不能获取private方法,且获取从父类继承来的所有方法
Method[] methods = clazz.getMethods();
for(Method method:methods){
System.out.print(" "+method.getName());
}
System.out.println();
//
// 1.2.获取所有方法，包括私有方法 --方法数组（二）
// 所有声明的方法，都可以获取到，且只获取当前类的方法
methods = clazz.getDeclaredMethods();
for(Method method:methods){
System.out.print(" "+method.getName());
}
System.out.println();
//
// 1.3.获取指定的方法
// 需要参数名称和参数列表，无参则不需要写
// 对于方法public void setName(String name) { }
Method method = clazz.getDeclaredMethod(“setName”, String.class);
System.out.println(method);
// 而对于方法public void setAge(int age) { }
method = clazz.getDeclaredMethod(“setAge”, Integer.class);
System.out.println(method);
// 这样写是获取不到的，如果方法的参数类型是int型
// 如果方法用于反射，那么要么int类型写成Integer： public void setAge(Integer age) { }
// 要么获取方法的参数写成int.class
//
//2.执行方法
// invoke第一个参数表示执行哪个对象的方法，剩下的参数是执行方法时需要传入的参数
Object obje = clazz.newInstance();
method.invoke(obje,2);
//如果一个方法是私有方法，第三步是可以获取到的，但是这一步却不能执行
//私有方法的执行，必须在调用invoke之前加上一句method.setAccessible（true）;
}
}
复制代码
主要用到的两个方法
复制代码
/**
* @param name the name of the method
* @param parameterTypes the list of parameters
* @return the {@code Method} object that matches the specified
*/
public Method getMethod(String name, Class<?>… parameterTypes){
}
/**
-
@param obj the object the underlying method is invoked from
-
@param args the arguments used for the method call
-
@return the result of dispatching the method represented by
*/
public Object invoke(Object obj, Object… args){
}
复制代码
自定义工具方法
自定义一个方法
把类对象和类方法名作为参数，执行方法
把全类名和方法名作为参数，执行方法
比如Person里有一个方法
public void test(String name,Integer age){
System.out.println(“调用成功”);
}
那么我们自定义一个方法
1. 把类对象和类方法名作为参数，执行方法
复制代码
/**
*
* @param obj: 方法执行的那个对象.
* @param methodName: 类的一个方法的方法名. 该方法也可能是私有方法.
* @param args: 调用该方法需要传入的参数
* @return: 调用方法后的返回值
*
*/
public Object invoke(Object obj, String methodName, Object … args) throws Exception{
//1. 获取 Method 对象
// 因为getMethod的参数为Class列表类型，所以要把参数args转化为对应的Class类型。
Class [] parameterTypes = new Class[args.length];
for(int i = 0; i < args.length; i++){
parameterTypes[i] = args[i].getClass();
System.out.println(parameterTypes[i]);
}
Method method = obj.getClass().getDeclaredMethod(methodName, parameterTypes);
//如果使用getDeclaredMethod，就不能获取父类方法，如果使用getMethod，就不能获取私有方法
//
//2. 执行 Method 方法
//3. 返回方法的返回值
return method.invoke(obj, args);
}
复制代码
调用：
@Test
public void testInvoke() throws Exception{
Object obj = new Person();
invoke(obj, “test”, “wang”, 1);
}
这样就通过对象名，方法名，方法参数执行了该方法
2.把全类名和方法名作为参数，执行方法
复制代码
/**
* @param className: 某个类的全类名
* @param methodName: 类的一个方法的方法名. 该方法也可能是私有方法.
* @param args: 调用该方法需要传入的参数
* @return: 调用方法后的返回值
*/
public Object invoke(String className, String methodName, Object … args){
Object obj = null;
try {
obj = Class.forName(className).newInstance();
//调用上一个方法
return invoke(obj, methodName, args);
}catch(Exception e) {
e.printStackTrace();
}
return null;
}
复制代码
调用
@Test
public void testInvoke() throws Exception{
invoke(“com.atguigu.java.fanshe.Person”,
“test”, “zhagn”, 12);
}
使用系统方法（前提是此类有一个无参的构造器（查看API））
@Test
public void testInvoke() throws Exception{
Object result =
invoke(“java.text.SimpleDateFormat”, “format”, new Date());
System.out.println(result);
}
这种反射实现的主要功能是可配置和低耦合。只需要类名和方法名，而不需要一个类对象就可以执行一个方法。如果我们把全类名和方法名放在一个配置文件中，就可以根据调用配置文件来执行方法
如何获取父类定义的（私有）方法
前面说一般使用getDeclaredMethod获取方法（因为此方法可以获取类的私有方法，但是不能获取父类方法）
如何获取父类方法呢，上一个例子format方法其实就是父类的方法（获取的时候用到的是getMethod）
首先我们要知道，如何获取类的父亲：
比如有一个类，继承自Person
使用
复制代码
public class ReflectionTest {
@Test
public void testGetSuperClass() throws Exception{
String className = “com.atguigu.java.fanshe.Student”;
Class clazz = Class.forName(className);
Class superClazz = clazz.getSuperclass();
System.out.println(superClazz);
}
}
//结果是 “ class com.atguigu.java.fanshe.Person ”
复制代码
此时如果Student中有一个方法是私有方法method1(int age); Person中有一个私有方法method2();
怎么调用
定义一个方法，不但能访问当前类的私有方法，还要能父类的私有方法
复制代码
/**
*
* @param obj: 某个类的一个对象
* @param methodName: 类的一个方法的方法名.
* 该方法也可能是私有方法, 还可能是该方法在父类中定义的(私有)方法
* @param args: 调用该方法需要传入的参数
* @return: 调用方法后的返回值
*/
public Object invoke2(Object obj, String methodName,
Object … args){
//1. 获取 Method 对象
Class [] parameterTypes = new Class[args.length];
for(int i = 0; i < args.length; i++){
parameterTypes[i] = args[i].getClass();
}
try {
Method method = getMethod(obj.getClass(), methodName, parameterTypes);
method.setAccessible(true);
//2. 执行 Method 方法
//3. 返回方法的返回值
return method.invoke(obj, args);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
-
获取 clazz 的 methodName 方法. 该方法可能是私有方法, 还可能在父类中(私有方法)
-
如果在该类中找不到此方法，就向他的父类找，一直到Object类为止
* 这个方法的另一个作用是根据一个类名，一个方法名，追踪到并获得此方法
* @param clazz
* @param methodName
* @param parameterTypes
* @return
*/
public Method getMethod(Class clazz, String methodName,
Class … parameterTypes){
for(;clazz != Object.class; clazz = clazz.getSuperclass()){
try {
Method method = clazz.getDeclaredMethod(methodName, parameterTypes);
return method;
} catch (Exception e) {}
}
return null;
}
复制代码
3.2 如何描述字段-Field
复制代码
@Test
public void testField() throws Exception{
String className = “com.atguigu.java.fanshe.Person”;
Class clazz = Class.forName(className);
//1.获取字段
// 1.1 获取所有字段 – 字段数组
// 可以获取公用和私有的所有字段，但不能获取父类字段
Field[] fields = clazz.getDeclaredFields();
for(Field field: fields){
System.out.print(" "+ field.getName());
}
System.out.println();
// 1.2获取指定字段
Field field = clazz.getDeclaredField(“name”);
System.out.println(field.getName());
Person person = new Person(“ABC”,12);
//2.使用字段
// 2.1获取指定对象的指定字段的值
Object val = field.get(person);
System.out.println(val);
// 2.2设置指定对象的指定对象Field值
field.set(person, “DEF”);
System.out.println(person.getName());
// 2.3如果字段是私有的，不管是读值还是写值，都必须先调用setAccessible（true）方法
// 比如Person类中，字段name字段是公用的，age是私有的
field = clazz.getDeclaredField(“age”);
field.setAccessible(true);
System.out.println(field.get(person));
}
复制代码
但是如果需要访问父类中的（私有）字段：
复制代码
/**
* //创建 className 对应类的对象, 并为其 fieldName 赋值为 val
* //Student继承自Person,age是Person类的私有字段/
public void testClassField() throws Exception{
String className = “com.atguigu.java.fanshe.Student”;
String fieldName = “age”; //可能为私有, 可能在其父类中.
Object val = 20;
Object obj = null;
//1.创建className 对应类的对象
Class clazz = Class.forName(className);
//2.创建fieldName 对象字段的对象
Field field = getField(clazz, fieldName);
//3.为此对象赋值
obj = clazz.newInstance();
setFieldValue(obj, field, val);
//4.获取此对象的值
Object value = getFieldValue(obj,field);
}
public Object getFieldValue(Object obj, Field field) throws Exception{
field.setAccessible(true);
return field.get(obj);
}
public void setFieldValue(Object obj, Field field, Object val) throws Exception {
field.setAccessible(true);
field.set(obj, val);
}
public Field getField(Class clazz, String fieldName) throws Exception {
Field field = null;
for(Class clazz2 = clazz; clazz2 != Object.class;clazz2 = clazz2.getSuperclass()){
field = clazz2.getDeclaredField(fieldName);
}
return field;
}
复制代码
3.3如何描述构造器-Constructor
复制代码
@Test
public void testConstructor() throws Exception{
String className = “com.atguigu.java.fanshe.Person”;
Class clazz = (Class) Class.forName(className);
//1. 获取 Constructor 对象
// 1.1 获取全部
Constructor [] constructors =
(Constructor[]) Class.forName(className).getConstructors();
for(Constructor constructor: constructors){
System.out.println(constructor);
}
// 1.2获取某一个，需要参数列表
Constructor constructor = clazz.getConstructor(String.class, int.class);
System.out.println(constructor);
//2. 调用构造器的 newInstance() 方法创建对象
Object obj = constructor.newInstance(“zhagn”, 1);
}
复制代码
3.4 如何描述注解 – Annotation
定义一个Annotation
复制代码
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(value={ElementType.METHOD})
public @interface AgeValidator {
public int min();
public int max();
}
复制代码
此注解只能用在方法上
@AgeValidator(min=18,max=35)
public void setAge(int age) {
this.age = age;
}
那么我们在给Person类对象的age赋值时，是感觉不到注解的存在的
@Test
public void testAnnotation() throws Exception{
Person person = new Person();
person.setAge(10);
}
总结
虽然面试套路众多，但对于技术面试来说，主要还是考察一个人的技术能力和沟通能力。不同类型的面试官根据自身的理解问的问题也不尽相同，没有规律可循。
上面提到的关于这些JAVA基础、三大框架、项目经验、并发编程、JVM及调优、网络、设计模式、spring+mybatis源码解读、Mysql调优、分布式监控、消息队列、分布式存储等等面试题笔记及资料
有些面试官喜欢问自己擅长的问题，比如在实际编程中遇到的或者他自己一直在琢磨的这方面的问题，还有些面试官，尤其是大厂的比如 BAT 的面试官喜欢问面试者认为自己擅长的，然后通过提问的方式深挖细节，刨根到底。
notation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(value={ElementType.METHOD})
public @interface AgeValidator {
public int min();
public int max();
}
复制代码
此注解只能用在方法上
@AgeValidator(min=18,max=35)
public void setAge(int age) {
this.age = age;
}
那么我们在给Person类对象的age赋值时，是感觉不到注解的存在的
@Test
public void testAnnotation() throws Exception{
Person person = new Person();
person.setAge(10);
}
总结
虽然面试套路众多，但对于技术面试来说，主要还是考察一个人的技术能力和沟通能力。不同类型的面试官根据自身的理解问的问题也不尽相同，没有规律可循。
[外链图片转存中…(img-66C6AZFQ-1715077061068)]
[外链图片转存中…(img-iavoOYik-1715077061069)]
上面提到的关于这些JAVA基础、三大框架、项目经验、并发编程、JVM及调优、网络、设计模式、spring+mybatis源码解读、Mysql调优、分布式监控、消息队列、分布式存储等等面试题笔记及资料
有些面试官喜欢问自己擅长的问题，比如在实际编程中遇到的或者他自己一直在琢磨的这方面的问题，还有些面试官，尤其是大厂的比如 BAT 的面试官喜欢问面试者认为自己擅长的，然后通过提问的方式深挖细节，刨根到底。
8325
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
