投稿
  1. 极客之音首页
  2. 前端开发

java中的反射以及泛型

小半 • • 前端开发 • 阅读 228

导读：本篇文章讲解 java中的反射以及泛型，希望对大家有帮助，欢迎收藏，转发！站点地址：www.bmabk.com

java中的反射

一、反射是什么，有什么用？

  反射—-在程序运行的过程中，我们可以得到某个类的对象，可以调用某个类中的任何一个变量/方法，这种动态获取信息的过程就是反射。
  当我们在没有见过某个类的情况下，仅凭一个完整的类名【包名+类名】，就可以获取到整个类的所有信息。
  反射的使用场景：
        1jdbc加载数据库驱动
        2.Servlet的web.xml配置
        3.Spring框架.

二、实例对象与反射对象的相互转换？

实例对象——就是我们通过类创建的对象
反射对象——通过反射机制得到的类对象
例如：反射就是一面镜子，镜子前面的你就是实例对象，通过镜子得到的镜子里面的你就是反射对象。
反射对象是一个Class类型的对象
Class—类的类名，创建出来的Class类的对象就反射对象。
public  final  class  Class<T>
1.通过实例对象得到反射对象
        1.通过实例对象的getClass()得到，当前实例对象对应的反射对象
        2.通过Class类的forname(类名【包名+类名】)
2.通过反射对象得到实例对象
        反射对象的newInstance()方法，可以得到实例对象
例如：

package com.wangxing.test1;

public class fansheClass {
	@SuppressWarnings("rawtypes")
	public static void main(String[] args) throws Exception {
		//.通过实例对象得到反射对象
		testClass test1=new testClass();
		//1.通过实例对象的getClass()得到，当前实例对象对应的反射对象
		Class<testClass> testC=(Class<testClass>) test1.getClass();
		Class.forName("com.wangxing.test1.testClass");
		//2.通过反射对象得到实例对象
		testClass  test2= testC.newInstance();
		System.out.println(testC);
		System.out.print(test2);
	}
}

得到一个类的实例对象的方式:
1.new     2.静态方法      3.反射

三、通过反射对象的得到类的完整结构

 Constructor<?>[ ]  getContructors()得到构造方法
Field[ ]  getDeclaredFields( )得到成员变量
Methond[ ]  getDeclaredMethods()得到成员方法
Class<?>[]    getInterfaces() 得到接口。 
Class<? super T>    getSuperclass() 得到父类。
Package    getPackage() 得到包对象。
int    getModifiers() Java语言修饰符
Modifier的toString(int mod)
String    getName() 得到类名称
例如：

package com.wangxing.test1;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class Man {
	public static <Constructo> void main(String args[]) throws Exception {
		// 得到反射对象
		Class class1 = Class.forName("com.wangxing.test1.testClass");
		Package pack = class1.getPackage();
		String packname = pack.getName();
		System.out.println("package" + "\t" + packname + ";");
		// 得到类的修饰符
		String Classstr = Modifier.toString(class1.getModifiers());
		// 得到父类名称
		String superName = getname(class1.getSuperclass().getName());
		// 得到类名称
		String str = class1.getName();
		String classname = getname(str);
		// 得到接口对象
		Class InterClass = class1.getInterfaces()[0];
		String Intername = getname(InterClass.getName());
		System.out.println(Classstr + " " + "calss" + " " + classname + " " + "extends" + " " + superName + " "
				+ "implements" + " " + Intername + "{");
		// 得到成员变量对象
		Field[] Fields = class1.getDeclaredFields();
		for (Field filed : Fields) {
			// 得到成员变量的修饰符
			String filedxiushi = Modifier.toString(filed.getModifiers());
			// 得到成员变量的种类
			String bltype = getname(filed.getType().getName());
			// 得到成员变量名称
			String blname = filed.getName();
			System.out.println("\t" + filedxiushi + " " + bltype + " " + blname + ";");
		}
		// 得到构造方法
		Constructor gouzao = class1.getConstructors()[0];
		String gouzaoxiushi = Modifier.toString(gouzao.getModifiers());
		String gouzaoname = getname(gouzao.getName());
		System.out.println("\t" + gouzaoxiushi + " " + gouzaoname + "(){}");
		//得到实例方法
		Method method=class1.getDeclaredMethods()[0];
		String methodxiushi=Modifier.toString(method.getModifiers()); 
		String methndReturn=getname(method.getReturnType().getName());
		String methodname=getname(class1.getName());
		System.out.println("\t"+methodxiushi+" "+methndReturn+" "+methodname+"(){");
		System.out.println("\t"+"\t"+"return null;");
		System.out.println("\t"+"}");
		System.out.println("}");
	}

	private static String getname(String str) {
		return str.substring((str.lastIndexOf(".") + 1));
	}
}
package com.wangxing.test1;

public class testClass extends Object implements interfaceTest{
	private int num;
	private String name;
	//常见构造方法
	public testClass(){}
	//实例方法
	public static String shilivoid(){
		
		return null;
	}
}

java中的反射以及泛型

 java中的泛型

 一、什么是泛型—广泛的数据类型

将某一个类/类/接口/方法/变量的数据类型像使用参数一样传递给类/接口/方法/变量。
数据的参数化，任意化。

二、为什么需要泛型？

第一天  类中的x，y变量需要int
public  class  Test1{
        private  int  x;
        private  int   y;
}
第二天  类中的x,y变量需要double，我们创建一个新类修改了一下x,y变量数据类型
public  class  Test2{
        private  double  x;
        private  double y;
}
第三天  类中的x,y变量需要String ,我们创建一个新类修改了一下x,y变量数据类型
public  class  Test3{
        private  String x;
        private  String y;
}
第四天  类中的x,y变量需要char ,我们创建一个新类修改了一下x,y变量数据类型
    ……
当我们需要很多个业务逻辑相似，但是数据类型不同的java类时，我们又不想创建出多个业务逻辑相似，但是数据类型不同的java类。
我们就会想能不能用一个类把业务逻辑相似，但是数据类型不同的多个java类，统一一下
要解决这个统一问题我们就会首先处理数据类型的统一，要处理数据类型的统一，我们就会想到java.lang.Object类。
public class ObjectTest {
    private  Object  x;
    private  Object  y;

    public Object getX() {
        return x;
    }
    public void setX(Object x) {
        this.x = x;
    }
    public Object getY() {
        return y;
    }
    public void setY(Object y) {
        this.y = y;
    }
    }
    
    ObjectTest  o=new ObjectTest();
    //o.setX(180);
    //o.setY(36);
    //将x,y变量改成String
    o.setX(“一百八十”);
    o.setY(“三十六”);
    System.out.println(o.getX()+”,”+o.getY());
    //类型转换
    // java.lang.ClassCastException
    int sum=(Integer)(o.getX())+(Integer)(o.getY());
    System.out.println(sum);
虽然我们可以使用Object来统一数据类型，但是在使用的时候需要进行强制类型转换.
    如果转换不当会出现类型转换异常java.lang.ClassCastException。
这时我们就会想我们能不能把数据类型，象参数一样传递给我们需要使用的java类，这要我们既可以统一类型，可以避免强制类型转换。
这时泛型就被研究出来，解决上面的问题。

三、如何创建一个泛型类/泛型接口？

 在创建类的时候为类名后面添加一个“<>”,给”<>”中添加单个的大写字母，用来接收具体的某个数据类型。
    ”<>”中的单个的大写字母可以出现多个，中间使用”,”分割。
    类中需要数据类型的部分可以使用单个的大写字母来代替，这是我们我们创建类的时候就可以传递具体的数据类型给单个的大写字母，类中需要数据类型的部分全部都会变成我们传递具体的数据类型。
例如：

package com.wangxing.test3;

public class Test<X,Y> {
	private X a;
	private Y b;
	public X getA() {
		return a;
	}
	public void setA(X a) {
		this.a = a;
	}
	public Y getB() {
		return b;
	}
	public void setB(Y b) {
		this.b = b;
	}
	
}

package com.wangxing.test3;

public class Main {
	public static void main(String[] args) {
		Test<Integer,String>  test1=new Test<Integer,String>();
		test1.setA(168);
		test1.setB("fxt");
		int a=test1.getA();
		String b=test1.getB();
	}
}

四 、泛型类/泛型接口如何使用？

我们一般很少创建与泛型有关的元素，我们会经常使用jdk提供的开发包中的泛型类/接口。
1.使用泛型类创建对象的时候需要传递具体的数据类型。
    Test1  t1=new Test1(); //不合法的，会产生警告信息
     Test1<Integer,String>  t1=new Test1<Integer,String>(); //正确的
2.基本数据类型在被作为泛型的数据类型时，是不被允许的，可以使用应基本类型对应的封装类型代替
     Test1<int,String>  t1=new Test1<int,String>(); //错误
     Test1<Integer,String>  t1=new Test1<Integer,String>();//正确
3.当我们创建泛型对象的时候，没有传递指定的数据类型默认是Object类型。并伴随有警告信息出现。
public static void main(String[] args) {
        Student stu1=new Student(1001,”zhangsan”);
        Student stu2=new Student(1002,”lisi”);
        Student stu3=new Student(1003,”wangwu”);
        List  stulist=new ArrayList();
        stulist.add(stu1);
        stulist.add(stu2);
        stulist.add(stu3);
        for(Object  obj:stulist){
            Student  stu=(Student)obj;
            System.out.println(stu.getStuid()+”,”+stu.getStuname());
        }
}
之前学习过的类，他们其实是泛型类
java.util Class ArrayList<E>
java.util Class HashMap<K,V>
java.util Class Hashtable<K,V>
之前学习过的接口，他其实是泛型接口
java.util Interface Map<K,V>
public interface List<E>
public interface Collection<E>

 注解

注释—标注解释说明代码的含义用的文字
注解—标注解释说明功能的代码
1.@Override  判断方法重写是否正确
2.@SuppressWarnings  抑制警告信息。
    有参数—产生警告的原因
    位置:当前代码的上面 ，只抑制当前代码上的警告信息
         方法代码的上面 ，只抑制当前方法中的同类型的警告信息 
         类的上面 ，只抑制当前类中的同类型的警告信息 
   @SuppressWarnings({ “unused”, “rawtypes” })
3. @Deprecated  标识变量/方法/类/接口，已过时。
    已过时的元素尽量避免使用，因为有潜在的错误

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/79825.html

赞 (0)
小半的头像小半
0 0

相关推荐

极客之音——专业性很强的中文编程技术网站，欢迎收藏到浏览器，订阅我们！