Java学习(高新)16-枚举，反射

最新推荐文章于 2024-06-30 02:06:09 发布

nuddlesW

最新推荐文章于 2024-06-30 02:06:09 发布

阅读量743

点赞数 1

文章标签： java 语言

本文链接：https://blog.csdn.net/nuddlesW/article/details/42172365

版权

1.枚举：

关键字 enum
枚举就是要让某个类型的变量的取值只能为若干固定值之中的一个。
是一个特殊的类，其中的每一个元素都是该类的一个对象。

注意 : 因为不能New 枚举的实力，所以枚举不能继承其他类，也不能被其他类继承。

为什么要有枚举？
问题：要定义星期几或性别的变量，该怎么定义？假设用1-7分别表示星期一到星期日，但有人可能会写成int weekday = 0;或即使使用常量方式也无法阻止意外。
枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个，否则，编译器就会报错。枚举可以让编译器在编译时就可以控制源程序中填写的非法值，普通变量的方式在开发阶段无法实现这一目标。

用普通类如何实现枚举功能，定义一个Weekday的类来模拟枚举功能。
1、私有的构造方法。
2、每个元素分别用一个公有的静态成员变量表示。

可以有若干公有方法或抽象方法。采用抽象方法定义nextDay就将大量的if.else语句转移成了一个个独立的类

交通灯：

<span style="font-family:Microsoft YaHei;font-size:14px;">package cn.itheima.day1;

public class EnumTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Weekday weekday1 = Weekday.MON;
//		一旦声明枚举，第一件事把枚举内所有成员全部构建好
		Weekday weekday2 = Weekday.TUE;
//		Weekday weekday2 = weekday1.nextDay();
		
		System.out.println(weekday1.name());
		System.out.println(weekday2.ordinal());
		System.out.println(Weekday.valueOf("SUN"));
		TrafficLamp lamp1 = TrafficLamp.RED;
		TrafficLamp lamp2 = lamp1.nextLamp();
		System.out.println(lamp2);
	}
	public enum Weekday{
		SUN(2),MON(1),TUE,WED,THI,FRI,SAT;
		Weekday(){System.out.println("first");}
		Weekday(int x){System.out.println("second");}
		
	}
	public enum TrafficLamp{
		RED(30){
			public TrafficLamp nextLamp(){
				return GREEN;
			}
		},
		GREEN(30){
			public TrafficLamp nextLamp(){
				return YELLO;
			}
		},
		YELLO(3){
			public TrafficLamp nextLamp(){
				return RED;
			}
		};
//		匿名类的应用
		private int time;
		public abstract TrafficLamp nextLamp();
		
		private TrafficLamp(int time){
			this.time = time;
		}
	}
}

</span>

2.反射

就是反射就是把Java类中的各种成分映射成相应的java类

反射是在运行状态中，对于任意一个类（class文件），都能够知道这个类的所有属性和方法；对于任意一个对象，都只能都调用它的任意一个
方法和属性，这种动态获取的信息一级动态调用对象的方法的功能呢个称为java 的反射机制。

反射其实就是动态加载一个指定的类，并获取该类中的所有的内容。而且将字节码文件封装成对象，
并将字节码文件中的内容都封装成对象，这样便于操作这些成员。就是把JAVA类中的各种成分反射成为相应的JAVA类
简单说：反射技术可以对一个类进行解剖。
如果想要对指定名称的字节码文件进行加载
反射的好处：大大的增强了程序的扩展性。

反射的基本步骤：
1、获得Class对象，就是获取到指定的名称的字节码文件对象。
2、实例化对象，获得类的属性、方法或构造函数。
3、访问属性、调用方法、调用构造函数创建对象。

a.得到类的字节码文件相同，这三种方式。
1.Class cls1=类名.class 相对简单，还是需要明确类名
2.cls1.getclass();必须要明确具体的类，并创建对象
3.class.forName("完整的类名（带包名）");
9个预定义的Class实例对象。
Integer.class包装类的字节码
Integer.TYPE Integer中基本类型的字节码
int.class==Integer.TYPE
数组
class.isPrimitive();
class.isArray();

只要在源程序中出现的类型，都有各自的Class实例对象，例如 int[] void 等等

b.创建类的对象
String name="com.dsa.类名";
寻找该名称类文件，并加载进内存，并非产生class对象
Class clazz=Class.forName(name);
产生该类的对象
Object obj=clazz.newInstance();
得到某一个指定构造方法
Constructor constructor= Class.forName("").getConstructor(String.class);
创建实例对象
Object obj=constructor.newInstance("abc");

c.Constructor 构造方法：代表某个类中的一个构造方法。

得到某个类中所有的构造方法
Constructor constructors[]= Class.forName("").getConstructors();;
得到某一个构造方法
Constructor constructor= Class.forName("").getConstructor(StringBuffer.class);
Constructor constructor= Class.getConstructor(StringBuffer.class);
创建实例对象
String str=(String) constructor.newInstance(new StringBUffer("abc"));
调用获得的方法时要用到上面相同类型的实例对象
Class.newInstance()方法：
String obj=（String）Class.forName("java.lang.String").newInstance();
先得到默认的构造方法，然后用该构造方法创建实例对象。

d.成员变量 Filed类代表某个类中的一个成员变量
对一个类进行反射。
ReflectPoint pt1=new ReflectPoint(3,5);
Filed filedy=pt1.getclsss().getFiled("Y");//只代表哪个对象
Filed filedy=pt1.getclsss().getDeclaredField("x")//获取对象不管是私有还是被保护的
filedy.setAccessible(true);//设置可以访问，暴力反射
filedy.get(pt1)//取出Y的值

将字段中的b全变成a
Field[] fields=obj.getClass().getFields();//获取全部对象
for(Field field :fields){
if(field.getType()==String.class){//如果是字符串
String oldValue = (String)field.get(obj);//获取字符串内容
String newValue = oldValue.replace('b','a');将字符串内容替换
field.set(obj,newValue);将新值赋给对象

f.Method类成员方法的反射。

获取成员方法
反射形式：
Method methodCharAt = String.class.getMethod("charAt"--方法名,int.class--这是参数类型，如果是空参函数则是 null);
Object obj=clazz.newInstance();
methodCharAt.invoke(str1,1);


数组的反射
Class clazz=obj.getClass();
if(clazz.isArray()){
int len=array.getLength(obj);
for(int i=0;i<len;I==){
sopArray.get(obj,i))
}

}


e.反射来获取泛型信息

通过指定对应的Class对象，程序可以获得该类里面所有的Field，不管该Field使用private 方法public。获得Field对象后都可以使用getType()来获取其类型。
Class<?> type = f.getType();//获得字段的类型
但此方法只对普通Field有效,若该Field有泛型修饰,则不能准确得到该Field的泛型参数,如Map<String,Integer>;
为了获得指定Field的泛型类型，我们采用：
Type gType = f.getGenericType();得到泛型类型
然后将Type对象强转为ParameterizedType,其表示增加泛型后的类型
Type getRawType()//返回被泛型限制的类型;
Type[] getActualTypeArguments()//返回泛型参数类型;

利用反射来获取泛型的类型（泛型信息）
步骤：
获取当前类
获取目标字段
获取包含泛型类型的类型 getGenericType()
强转至子类ParameterizedType 因为Type没有任何对应的方法
获得泛型真正的类型 getActualTypeArguments()

综合应用：

<span style="font-family:Microsoft YaHei;font-size:14px;">package cn.itheima.day1;

import java.lang.reflect.*;

public class ReflectTest {

	 * @param args
	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		String str1 = "abc";
		Class cls1 = str1.getClass();
		Class cls2= String.class;
		Class cls3 = Class.forName("java.lang.String");
		System.out.println(cls1.isPrimitive());
//		判断String是不是基础类型
		System.out.println(int.class.isPrimitive());
		System.out.println(int.class == Integer.class);
		System.out.println(int[].class.isArray());
		System.out.println(int [].class.isPrimitive());
		
		Constructor cons = String.class.getConstructor(StringBuilder.class);
//		获取参数为StringBuilder的构造方法
		String str4 = (String) cons.newInstance(new StringBuilder("abc"));
//		注意要（String）
		System.out.println(str4);
//		构造函数的反射。
		
		ReflectPoint point = new ReflectPoint(5,7);
		Field fieldX = point.getClass().getDeclaredField("x");
//		获取字段
		Field fieldY = point.getClass().getField("y");
		System.out.println(fieldY.get(point));
		fieldX.setAccessible(true);
//		暴力反射
		System.out.println(fieldX.get(point));
		
		replaceValue(point);

		Method methodCharAt = String.class.getMethod("charAt", int.class);
//		获取方法名为"charAt",参数为int类型的方法
		System.out.println(methodCharAt.invoke(str1,2));
//		调用方法
		System.out.println(methodCharAt.invoke(str1, new Object[]{2}));
		
		
		String startClass = args[0];
		System.out.println(startClass);
		Method mainMethod = Class.forName(startClass).getMethod("main", String[].class);
		mainMethod.invoke(null,(Object)new String[]{"1","2"});
//		静态不用实例对象，所有是null
		
		
		int [] a1 = new int[]{1,2,3};
		int [] a2 = new int[4];
		int[][] a3 = new int[2][3];
		String [] a4 = new String[]{"a","b","c"};
		System.out.println(a1.getClass() == a2.getClass());//true
//		System.out.println(a1.getClass() == a4.getClass());
//		System.out.println(a1.getClass() == a3.getClass());
//		可以看出一维数组同类型用的字节码Class是一样的
//		基本类型不是Object,所以基本类型的一维数组不能转换成Object[]
		System.out.println(a1.getClass().getName());
		System.out.println(a1.getClass().getSuperclass().getName());
		System.out.println(a4.getClass().getSuperclass().getName());
		
		System.out.println(Arrays.asList(a1));
//		[[I@fa7e74],因为 a1 是一维数组不能转变成Object[];
		System.out.println(Arrays.asList(a4));	
//		[a, b, c]
	}

	private static void replaceValue(ReflectPoint point)
			throws IllegalAccessException {
		Field[] field = point.getClass().getDeclaredFields();
		for (Field f : field) {
			if (f.getType() == String.class) {
//				f.getType(),此方法可以获得实例对象的成员的类型
				String oldValue = (String) f.get(point);
				String newValue = oldValue.replace("b", "a");
				f.set(point, newValue);
				// 用set方法可以重新设置成员的值
			}
		}
		System.out.println(point);
	}

}
</span>

4. 反射的作用——>实现框架的功能
一、概述
1、框架：通过反射调用Java类的一种方式。
如房地产商造房子用户住，门窗和空调等等内部都是由用户自己安装，房子就是框架，用户需使用此框架，安好门窗等放入到房地产商提供的框架中。
框架和工具类的区别：工具类被用户类调用，而框架是调用用户提供的类。
2、框架机器要解决的核心问题：
我们在写框架（造房子的过程）的时候，调用的类（安装的门窗等）还未出现，那么，框架无法知道要被调用的类名，所以在程序中无法直接new其某个类的实例对象，而要用反射来做。
3、简单框架程序的步骤：
1）右击项目File命名一个配置文件如：config.properties,然后写入配置信息。如键值对：className=java.util.ArrayList，等号右边的配置键，右边是值。
2）代码实现，加载此文件：
①将文件读取到读取流中，要写出配置文件的绝对路径。
如：InputStream is=new FileInputStream(“配置文件”);
②用Properties类的load()方法将流中的数据存入集合。
③关闭流：关闭的是读取流，因为流中的数据已经加载进内存。
3）通过getProperty()方法获取className，即配置的值，也就是某个类名。
4）用反射的方式，创建对象newInstance()。
5）执行程序主体功能

二、类加载器
1、简述：类加载器是将.class的文件加载进内存，也可将普通文件中的信息加载进内存。
2、文件的加载问题：
1）eclipse会将源程序中的所有.java文件编译成.class文件，然后放到classPath指定的目录中去。并且会将非.java文件原封不动的复制到.class指定的目录中去。在运行的时候，执行的是.class文件。
2）将配置文件放到.class文件目录中一同打包，类加载器就会一同加载。
3、资源文件的加载：是使用类加载器。
1）由类加载器ClassLoader来加载进内存，即用getClassLoader()方法获取类加载器，然后用类加载器的getResourceAsStream(String name)方法，将配置文件（资源文件）加载进内存。利用类加载器来加载配置文件，需把配置文件放置的包名一起写上。这种方式只有读取功能。
2）Class类也提供getResourceAsStream方法来加载资源文件，其实它内部就是调用了ClassLoader的方法。这时，配置文件是相对类文件的当前目录的，也就是说用这种方法，配置文件前面可以省略包名。
如：类名.class.getResourceAsStream(“资源文件名”)
4、配置文件的路径问题：
1）用绝对路径，通过getRealPath()方法运算出来具体的目录，而不是内部编码出来的。
一般先得到用户自定义的总目录，在加上自己内部的路径。可以通过getRealPath()方法获取文件路径。对配置文件修改是需要要储存到配置文件中，那么就要得到它的绝对路径才行，因此，配置文件要放到程序的内部。
2）name的路径问题：
①如果配置文件和classPath目录没关系，就必须写上绝对路径，
②如果配置文件和classPath目录有关系，即在classPath目录中或在其子目录中（一般是资源文件夹resource），那么就得写相对路径，因为它自己了解自己属于哪个包，是相对于当前包而言的。
示例：

<span style="font-family:Microsoft YaHei;font-size:14px;">package cn.itheima.day1;
import java.io.*;
public class ReflectTest2 {

	 * @param args
	public static void main(String[] args)throws Exception {
		// TODO Auto-generated method stub
		File file = new File("d:\\config.properties");
		System.out.println(file.isDirectory());
		System.out.println(file.exists());
		System.out.println(file.getAbsolutePath());
		System.out.println(file.getPath());
		System.out.println(file.getParent());
//		InputStream ips = new FileInputStream(file);
		
		InputStream ips =  ReflectTest2.class.getClassLoader().getResourceAsStream("cn/itheima/day1/config.properties");
//		此处一定要深刻理解，在myeclipse中默认classpath就是工作站目录，在cn前不加/是因为这个方法一启动就默认到classpath中开始找
//		如果是InputStream ips =  ReflectTest2.class.getResourceAsStream("config.properties");则只要写相对目前文件的路径，方法封装
		Properties	props = new Properties();
		props.load(ips);
		ips.close();
		String className = props.getProperty("className");
		Collection collections = (Collection)Class.forName(className).newInstance();
		//Collection collections = new HashSet();
		ReflectPoint pt1 = new ReflectPoint(3,3);
		ReflectPoint pt2 = new ReflectPoint(5,5);
		ReflectPoint pt3 = new ReflectPoint(3,3);	
		collections.add(pt1);
		collections.add(pt2);
		collections.add(pt3);
		collections.add(pt1);	
		//pt1.y = 7;		
		//collections.remove(pt1);
		
		System.out.println(collections.size());
	}
}
</span>

补充知识点：

对HashCode的分析
覆写hashCode()方法的意义：只有存入的是具有hashCode算法的集合的，覆写hashCode()方法才有价值。
1、哈希算法的由来：
若在一个集合中查找是否含有某个对象，通常是一个个的去比较，找到后还要进行equals的比较，对象特别多时，效率很低。有这么一种HashCode算法，有一个集合，把这个集合分成若干个区域，每个存进来的对象，可以算出一个hashCode值，根据算出来的值，就放到相应的区域中去。当要查找某一个对象，只要算出这个对象的hashCode值，看属于第几个区域，然后到相应的区域中去寻找，看是否有与此对象相等的对象。这样查找的性能就提高了。
示意图：

2、要想HashCode方法有价值的话，前提是对象存入的是hash算法这种类型的集合当中才有价值。如果不存入是hashCode算法的集合中，则不用复写此方法。
3、如果没有复写hashCode方法，对象的hashCode值是按照内存地址进行计算的。这样即使两个对象的内容是想等的，但是存入集合中的内存地址值不同，导致hashCode值也不同，被存入的区域也不同。所以两个内容相等的对象，就可以存入集合中。
所以就有这样的说法：如果两个对象equals相等的话，你应该让他们的hashCode也相等。如果对象存入的不是根据hash算法的集合中，就不需要复写hashCode方法。
4、当一个对象存储进HashSet集合中以后，就不能修改这个对象中的那些参与计算哈希值的字段了，否则对象修改后的哈希值与最初存储进HashSet集合中的哈希值就不同了。在这种情况下，调用contains方法或者remove方法来寻找或者删除这个对象的引用，就会找不到这个对象。从而导致无法从HashSet集合中单独删除当前对象，从而造成内存泄露。（程序中某一些对象不再被使用，以为被删掉了，但是没有，还一直在占用内存中，当这样的对象慢慢增加时，就会造成内存泄露。）
补充：
内存泄露：某些对象不再使用了，占用着内存空间，并未被释放，就会导致内存泄露；也就是说当程序不断增加对象，修改对象，删除对象，日积月累，内存就会用光了，就导致内存溢出。