JavaSE13

最新推荐文章于 2026-05-16 18:14:22 发布

原创最新推荐文章于 2026-05-16 18:14:22 发布 · 185 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#java

java 同时被 2 个专栏收录

32 篇文章

订阅专栏

JAVASE

14 篇文章

订阅专栏

本文深入探讨了Java SE 13的关键更新和改进，包括语言特性、API增强和性能优化。通过实例解析，展示了Java 13如何提升开发效率和程序性能，为开发者带来更流畅的编程体验。

package day13;

import java.util.Scanner;

/**
 * 动态加载类到内存中
 * @author 臻冉
 *
 */
public class ClassForNameReflect {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		//在这里类名是全名，包名+类名
		System.out.println("请输入类名");
		String className = scanner.nextLine();
		/*
		 * 利用反射API动态加载类，用Class类提供forName(String className)
		 * 返回一个Class类实例
		 * 当类名错误的时候，会抛出没有找到类的异常
		 */
		try {
			Class cls = Class.forName(className);//动态加载类到内存中
			System.out.println(cls);
			//类只加载一次，对象有3个
			Koo k = new Koo();
			Koo k2 = new Koo();
			Koo k3 = new Koo();
			System.out.println(k==k2);
			/*
			 * 利用反射API动态创建对象
			 * 在Class类中提供了newInstance()来创建对象的实例化，返回一个Object
			 */
			Object obj = cls.newInstance();//动态创建实例化对象
			System.out.println(obj);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

package day13;

import java.util.Scanner;

/**
 * 类只加载一次，即便多次调用forname
 * @author 臻冉
 *
 */
public class ClassForNameReflect02 {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入类名");
		String className = scanner.nextLine();
		//动态加载类
		try {
			Class cls = Class.forName(className);
			Class cls2 = Class.forName(className);
			Class cls3 = Class.forName(className);
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}
}

package day13;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Scanner;

/**
 * 利用class类型对象的方法才能获取到对象中的属性
 * Object  Class cls = obj.getClass()
 * Class.forName();
 * @author 臻冉
 *
 */
public class ClassForNameReflect03 {
	public static void main(String[] args) {
		//让用户输入一个类名和属性名
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入类名");
		String className = scanner.nextLine();
		//动态加载类
		try {
			Class cls = Class.forName(className);//降低了耦合度，灵活性增大
			//动态查找类的所有属性
			Field[] field = cls.getDeclaredFields();
			for(Field f:field){
				System.out.println(f);
			}
			//动态查找类中的指定属性
			Field felName = cls.getDeclaredField("name");
			System.out.println("指定类中的属性："+felName);
			//动态获取类中的所有方法
			Method[] methods = cls.getDeclaredMethods();
			for(Method m:methods){
				System.out.println(m);
			}
			//动态获取类中的指定方法
			Method method = cls.getDeclaredMethod("test2", String.class,int.class);
			System.out.println(method);
			//利用反射API创建对象
			Object obj = cls.newInstance();//重要
			/**
			 * 利用反射API可以访问不可见成员，不论私有属性或方法，都可以利用反射API进行调用，
			 * 在调用之前使用setAccessible(true)
			 * setAccessible(true)执行以后可以打开原有的私有访问权限，还可以打开任何不可见属性，方法的访问权限
			 */
			felName.setAccessible(true);//通过这句话，可以访问到私有属性的值
			
			/*
			 * 动态获取对象属性值
			 * 在Object对象上获取felName属性的值，如果Obj对象上没有这个属性的值
			 * 则抛出异常
			 */
			
			Object obj2 =felName.get(obj);//不知道什么对象就用Object来代替
			System.out.println("name的属性值是："+obj2);
			
			/*
			 * 属性名是用户运行期间输入的，输入那个属性名这段程序就会输出那个属性的值
			 * 也意味着程序和属性之前是松耦合（低耦合）的关系
			 */
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

package day13;

import java.lang.reflect.Method;
import java.util.Scanner;

/**
 * getDeclareMethod和getMethod区别：
 * getDeclareMethod：只查询当前类Class中的方法；
 * 
 * getMethod：查询当前类Class中的方法和父类中继承的方法
 * 
 * @author 臻冉
 *
 */
public class ClassForNameReflect04 {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入类名");
		String className = scanner.next();
			
			try {
				Class cls = Class.forName(className);
				//获取当前类中的所有方法
				Method[] methods = cls.getDeclaredMethods();
				for(Method m:methods){
					System.out.println(m);
				}
				//获取当前类和父类中的所有方法
				 
			} catch (Exception e) {
				e.printStackTrace();
			}
	}
}

package day13;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * 1.java提供了一套API
 * 2.提供了检车一个对象内部结构的手段
 * 3.反射API可以
 * 		动态加载类
 * 		动态创建对象
 *  	动态访问属性
 *  	动态调用方法
 * @author 臻冉
 *
 */
public class DemoReflect {
	public static void main(String[] args) {
		test("ABC");
//		test('A');
		//test(1);
		/*List<String> list = new ArrayList<String>();
		Iterator<String> it = list.iterator();
		Class c = it.getClass();
		System.out.println(c);*/
	}

	public static void test(Object obj) {
		//通过反射可以检查类型内部结构，动态获取obj的类型
		//Object类提供了getClass()返回一个Class类
		Class cls = obj.getClass();
		//System.out.println(cls);
		/*
		 * 检查对象的类型中声明了哪些属性
		 * Declared:声明的（定义)
		 * Fields:字段，属性
		 */
		//获取对象中的所有属性
		Field[] field = cls.getDeclaredFields();
		for(Field f:field){
			//System.out.println(f);
		}
		
		/*
		 * 获取对象中的指定属性
		 * Class类提供了getDeclaredField(String name)
		 * name:对象中的属性
		 */
		try {
			Field fel = cls.getDeclaredField("hash");
			//System.out.println(fel);
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		/*
		 * 获取对象中的所有方法
		 * Method方法来自reflect包，代表Class中声明的方法信息
		 */
		Method[] methods = cls.getDeclaredMethods();
		for(Method m:methods){
			System.out.println(m);
		}
		
		/*
		 * 获取对象中指定的方法
		 * getDeclaredMethod(String name, paremterTypes types);
		 * name:方法名字
		 * types方法中的参数类型，多个并用“，”隔开
		 */
		
		try {
			Method mt = cls.getDeclaredMethod("indexOf", Integer.class);
			System.out.println("指定的方法是："+mt);
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		/*
		 * 获取对象中的所有构造方法
		 * Constructor
		 */
		Constructor[] con = cls.getDeclaredConstructors();
		for(Constructor c:con){
			System.out.println("对象中的构造方法："+c);
		}
		
		//获取对象中的指定构造方法
		try{
			Constructor co = cls.getDeclaredConstructor(byte[].class,String.class);
			System.out.println(co);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

package day13;

import java.lang.reflect.Method;
import java.util.Scanner;

/**
 * 利用反射API动态执行对象的方法及其返回值
 * @author 臻冉
 *
 */
public class lnvokeMetod {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入类名：");
		String className = scanner.nextLine();
		System.out.println("请输入方法名");
		String methodName = scanner.next();
		System.out.println(2);
		//动态加载类
		try {
			//动态加载类
			Class cls = Class.forName(className);
			//在类cls中找到需要执行的methodName,如果名字错误，则抛出找不到的异常
			Method method = cls.getDeclaredMethod("test2", String.class,int.class);
			System.out.println(method);
			//通过反射创建对象实例化
			Object obj = cls.newInstance();
			//setAccessible(true)执行以后可以打开原有私有的访问权限，还可以打开任何不可见属性，方法的访问权限
			method.setAccessible(true);
			
			//method方法必须在obj中，否则会抛出异常
			Object obj2 = method.invoke(obj,"测试", 8);//获取方法返回值
			/*
			 * obj2输出的经过反射得到的方法返回值，如果此方法没有返回值，则返回null
			 * 如果有返回值，则返回对应的返回值
			 * 
			 */
			System.out.println(obj2);
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		
	}
}