Java基础：基础加强巩固

//创建对象

Object person1 = constructor1.newInstance();

System.out.println(person1);

Object o = personClass.newInstance();

System.out.println(o);

//constructor1.setAccessible(true);

}

}

• Method：方法对象

• 执行方法：

• Object invoke(Object obj, Object… args)

• 获取方法名称：

• String getName:获取方法名

package cn.itcast.reflect;

import cn.itcast.domain.Person;

import java.lang.reflect.Constructor;

import java.lang.reflect.Method;

public class ReflectDemo4 {

/**

Class对象功能：

• 获取功能：

3. 获取成员方法们：

• Method[] getMethods()

• Method getMethod(String name, 类<?>… parameterTypes)

• Method[] getDeclaredMethods()

• Method getDeclaredMethod(String name, 类<?>… parameterTypes)

4. 获取类名

• String getName()

*/

public static void main(String[] args) throws Exception {

//0.获取Person的Class对象

Class personClass = Person.class;

/*

3. 获取成员方法们：

• Method[] getMethods()

• Method getMethod(String name, 类<?>… parameterTypes)

• Method[] getDeclaredMethods()

• Method getDeclaredMethod(String name, 类<?>… parameterTypes)

*/

//获取指定名称的方法

Method eat_method = personClass.getMethod(“eat”);

Person p = new Person();

//执行方法

eat_method.invoke§;

// 获取带参数的方法,传递函数名以及指定参数的class

Method eat_method2 = personClass.getMethod(“eat”, String.class);

//执行方法

eat_method2.invoke(p,“饭”);

System.out.println(“-----------------”);

//获取所有public修饰的方法

Method[] methods = personClass.getMethods();

for (Method method : methods) {

System.out.println(method);

String name = method.getName();

System.out.println(name);

//method.setAccessible(true);

}

//获取类名

String className = personClass.getName();

System.out.println(className);//cn.itcast.domain.Person

}

}

• 案例：

• 需求：写一个"框架"，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法

• 实现：

1. 配置文件

2. 反射

• 步骤：

1. 将需要创建的对象的全类名和需要执行的方法定义在配置文件中

2. 在程序中加载读取配置文件

3. 使用反射技术来加载类文件进内存

4. 创建对象

5. 执行方法

• 实现

配置文件pro.properties

后续如果要更改，只需要更改配置文件，即可执行对应文件

className=cn.itcast.domain.Student

methodName=sleep

className=cn.itcast.domain.Person

methodName=eat

Person类Person.class

package cn.itcast.domain;

public class Person {

private String name;

private int age;

public String a;

protected String b;

String c;

private String d;

public Person() {

}

public Person(String name, int age) {

this.name = name;

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

@Override

public String toString() {

return “Person{” +

“name='” + name + ‘’’ +

“, age=” + age +

“, a='” + a + ‘’’ +

“, b='” + b + ‘’’ +

“, c='” + c + ‘’’ +

“, d='” + d + ‘’’ +

‘}’;

}

public void eat() {

System.out.println(“eat…”);

}

public void eat(String food) {

System.out.println(“eat…” + food);

}

}

Studelt类Student.java

package cn.itcast.domain;

public class Student {

public void sleep(){

System.out.println(“sleep…”);

}

}

实现类ReflectText.java

package cn.itcast.reflect;

import cn.itcast.domain.Person;

import cn.itcast.domain.Student;

import java.io.IOException;

import java.io.InputStream;

import java.lang.reflect.Method;

import java.util.Properties;

/**

• 框架类

*/

public class ReflectTest {

public static void main(String[] args) throws Exception {

//可以创建任意类的对象，可以执行任意方法

/*

前提：不能改变该类的任何代码。可以创建任意类的对象，可以执行任意方法

*/

/* Person p = new Person();

p.eat();*/

/*

Student stu = new Student();

stu.sleep();*/

//1.加载配置文件

//1.1创建Properties对象

Properties pro = new Properties();

//1.2加载配置文件，转换为一个集合

//1.2.1获取class目录下的配置文件

ClassLoader classLoader = ReflectTest.class.getClassLoader();

InputStream is = classLoader.getResourceAsStream(“pro.properties”);

pro.load(is);

//2.获取配置文件中定义的数据

String className = pro.getProperty(“className”);

String methodName = pro.getProperty(“methodName”);

//3.加载该类进内存

Class cls = Class.forName(className);

//4.创建对象

Object obj = cls.newInstance();

//5.获取方法对象

Method method = cls.getMethod(methodName);

//6.执行方法

method.invoke(obj);

}

}

3. 注解

=================================================================

• 概念：说明程序的。给计算机看的

• 注释：用文字描述程序的。给程序员看的

• 定义：注解（Annotation），也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。

• 概念描述：

• JDK1.5之后的新特性

• 说明程序的

• 使用注解：@注解名称

• 作用分类：

①编写文档：通过代码里标识的注解生成文档【生成文档doc文档】

②代码分析：通过代码里标识的注解对代码进行分析【使用反射】

③编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查【Override】

• JDK中预定义的一些注解

• @Override ：检测被该注解标注的方法是否是继承自父类(接口)的

• @Deprecated：该注解标注的内容，表示已过时

• @SuppressWarnings：压制警告

• 一般传递参数all @SuppressWarnings(“all”)

• 自定义注解

• 格式：

元注解

public @interface 注解名称{

属性列表;

}

• 本质：注解本质上就是一个接口，该接口默认继承Annotation接口

public interface MyAnno extends java.lang.annotation.Annotation {}

• 属性：接口中的抽象方法

• 要求：

1. 属性的返回值类型有下列取值

• 基本数据类型

• String

• 枚举

• 注解

• 以上类型的数组

package cn.itcast.annotation;

//import com.sun.corba.se.spi.orbutil.threadpool.Work;

public @interface MyAnno {

int value();

Person per();

MyAnno2 anno2();

String[] strs();

/String name() default “张三”;/

/*String show2();

Person per();

MyAnno2 anno2();

String[] strs();*/

}

2. 定义了属性，在使用时需要给属性赋值

3. 如果定义属性时，使用default关键字给属性默认初始化值，则使用注解时，可以不进行属性的赋值。

4. 如果只有一个属性需要赋值，并且属性的名称是value，则value可以省略，直接定义值即可。

5. 数组赋值时，值使用{}包裹。如果数组中只有一个值，则{}可以省略

package cn.itcast.annotation;

@MyAnno(value = 12, per = Person.P1, anno2 = @MyAnno2, strs = “bbb”)

@MyAnno3

public class Worker {

@MyAnno3

public String name = “aaa”;

@MyAnno3

public void show() {

}

}

• 元注解：用于描述注解的注解

• @Target：描述注解能够作用的位置

• ElementType取值：

• TYPE：可以作用于类上

• METHOD：可以作用于方法上

• FIELD：可以作用于成员变量上

• @Retention：描述注解被保留的阶段

• @Retention(RetentionPolicy.RUNTIME)：当前被描述的注解，会保留到class字节码文件中，并被JVM读取到

• @Documented：描述注解是否被抽取到api文档中

package cn.itcast.annotation;

import java.lang.annotation.*;

/**

元注解：用于描述注解的注解

• @Target：描述注解能够作用的位置

• @Retention：描述注解被保留的阶段

• @Documented：描述注解是否被抽取到api文档中

• @Inherited：描述注解是否被子类继承

*/

@Target({ElementType.TYPE,ElementType.METHOD,ElementType.FIELD})

@Retention(RetentionPolicy.RUNTIME)

@Documented

@Inherited

public @interface MyAnno3 {

}

• 在程序使用(解析)注解：获取注解中定义的属性值

1. 获取注解定义的位置的对象 （Class，Method,Field）

//1.解析注解

//1.1获取该类的字节码文件对象

Class reflectTestClass = ReflectTest.class;

2. 获取指定的注解

• getAnnotation(Class)

//其实就是在内存中生成了一个该注解接口的子类实现对象

public class ProImpl implements Pro{

public String className(){

return “cn.itcast.annotation.Demo1”;

}

public String methodName(){

return “show”;

}

}

3. 调用注解中的抽象方法获取配置的属性值

package cn.itcast.annotation;

import java.io.InputStream;

import java.lang.reflect.Method;

import java.util.Properties;

/**

• 框架类

*/

@Pro(className = “cn.itcast.annotation.Demo1”,methodName = “show”)

public class ReflectTest {

public static void main(String[] args) throws Exception {

/*

前提：不能改变该类的任何代码。可以创建任意类的对象，可以执行任意方法

*/

//1.解析注解

//1.1获取该类的字节码文件对象

Class reflectTestClass = ReflectTest.class;

//2.获取上边的注解对象

Pro an = reflectTestClass.getAnnotation(Pro.class);

//3.调用注解对象中定义的抽象方法，获取返回值

String className = an.className();

String methodName = an.methodName();

System.out.println(className);

System.out.println(methodName);

//3.加载该类进内存

Class cls = Class.forName(className);

//4.创建对象

Object obj = cls.newInstance();

//5.获取方法对象

Method method = cls.getMethod(methodName);

//6.执行方法

method.invoke(obj);

}

}

• 案例：简单的测试框架

1. Calculator.java

package cn.itcast.annotation.demo;

/**

• 小明定义的计算器类

*/

public class Calculator {

//加法

@Check

public void add(){

String str = null;

str.toString();

System.out.println(“1 + 0 =” + (1 + 0));

}

//减法

@Check

public void sub(){

System.out.println(“1 - 0 =” + (1 - 0));

}

//乘法

@Check

public void mul(){

System.out.println(“1 * 0 =” + (1 * 0));

}

//除法

@Check

public void div(){

System.out.println(“1 / 0 =” + (1 / 0));

}

public void show(){

System.out.println(“永无bug…”);

}

}

2. Check注解

package cn.itcast.annotation.demo;

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.METHOD)

public @interface Check {

}

3. TestCheck.java

package cn.itcast.annotation.demo;

import java.io.BufferedWriter;

import java.io.FileWriter;

import java.io.IOException;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

/**

• 简单的测试框架

• 当主方法执行后，会自动自行被检测的所有方法(加了Check注解的方法)，判断方法是否有异常，记录到文件中

*/

public class TestCheck {

public static void main(String[] args) throws IOException {

//1.创建计算器对象

Calculator c = new Calculator();

//2.获取字节码文件对象

Class cls = c.getClass();

//3.获取所有方法

Method[] methods = cls.getMethods();

int number = 0;//出现异常的次数

BufferedWriter bw = new BufferedWriter(new FileWriter(“bug.txt”));

for (Method method : methods) {

//4.判断方法上是否有Check注解

if(method.isAnnotationPresent(Check.class)){

//5.有，执行

try {

method.invoke©;

} catch (Exception e) {

总结

这个月马上就又要过去了，还在找工作的小伙伴要做好准备了，小编整理了大厂java程序员面试涉及到的绝大部分面试题及答案，希望能帮助到大家

@Target(ElementType.METHOD)

public @interface Check {

}

3. TestCheck.java

package cn.itcast.annotation.demo;

import java.io.BufferedWriter;

import java.io.FileWriter;

import java.io.IOException;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

/**

• 简单的测试框架

• 当主方法执行后，会自动自行被检测的所有方法(加了Check注解的方法)，判断方法是否有异常，记录到文件中

*/

public class TestCheck {

public static void main(String[] args) throws IOException {

//1.创建计算器对象

Calculator c = new Calculator();

//2.获取字节码文件对象

Class cls = c.getClass();

//3.获取所有方法

Method[] methods = cls.getMethods();

int number = 0;//出现异常的次数

BufferedWriter bw = new BufferedWriter(new FileWriter(“bug.txt”));

for (Method method : methods) {

//4.判断方法上是否有Check注解

if(method.isAnnotationPresent(Check.class)){

//5.有，执行

try {

method.invoke©;

} catch (Exception e) {

总结

这个月马上就又要过去了，还在找工作的小伙伴要做好准备了，小编整理了大厂java程序员面试涉及到的绝大部分面试题及答案，希望能帮助到大家

[外链图片转存中…(img-bE3uJ66Y-1714353960980)]

[外链图片转存中…(img-0cBc4zNZ-1714353960981)]

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录