Java--泛型、反射、注解

1.泛型

1.泛型---广泛的数据类型

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

2.为什么需要泛型

例如：

第一天  类中的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类，这要我们既可以统一类型，可以避免强制类型转换。这时泛型就被研究出来，解决上面的问题。

 3.如何创建一个泛型/泛型接口

1.在创建类的时候后面添加一个"< >",给"< >"中添加单个的大写字母，用来接收具体的某个数据类型

2."< >"中的单个的大写字母可以出现多个,中间使用","分隔，

3.类中需要数据类型的部分可以使用单个的大写字母来代替，这时我们创建类的时候就可以传递具体的数据类型给单个的大写字母，类中需要数据类型的部分全部都会变成我们传递具体的数据类型

例如:

package com.wangxing.Test1;

public class Test1 <I,S>{
	private I x;
	private S y;
	public I getX() {
		return x;
	}
	public void setX(I x) {
		this.x = x;
	}
	public S getY() {
		return y;
	}
	public void setY(S y) {
		this.y = y;
	}
}

package com.wangxing.test1;

public class TestMain {

	public static void main(String[] args) {
		Test1 <Integer,String> ts=new Test1 <Integer,String>();
		ts.setX(23);
		int x=ts.getX();
		ts.setY("张三");
		String y=ts.getY();
	}
}

4.泛型类/泛型接口如何使用

我们一般很少创建与泛型有关的元素，我们经常会使用jdk提供的开发包中的泛型类/泛型接口

1.使用泛型创建对象的时候需要传递具体的数据类型

      Test1 <Integer,String> ts=new Test1 <Integer,String>();

2.基本数据类型在被作为泛型的数据类型时，是不被允许的，可以使用基本类型对应的封装类代替

        Test1<int,String>  t1=new Test1<int,String>(); //错误
        Test1<Integer,String>  t1=new Test1<Integer,String>();//正确

3.我们在创建泛型对象时，没有传递指定的数据类型时默认的是Objetc类型，并伴随警告信息出现

例如：

package com.wangxing.test2;

public class Student {
	private int stuid;
	private String stuname;
	public Student(int stuid,String stuname){
		this.stuid=stuid;
		this.stuname=stuname;
	}
	public int getStuid() {
		return stuid;
	}
	public void setStuid(int stuid) {
		this.stuid = stuid;
	}
	public String getStuname() {
		return stuname;
	}
	public void setStuname(String stuname) {
		this.stuname = stuname;
	}
}

package com.wangxing.test2;
/*
 * 测试类
 */
import java.util.ArrayList;
import java.util.List;

public class TestMain {

	public static void main(String[] args) {
		Student student1=new Student(1001, "唐僧");
		Student student2=new Student(1002, "孙悟空");
		Student student3=new Student(1003, "猪八戒");
		List stulist=new ArrayList();
		stulist.add(student1);
		stulist.add(student2);
		stulist.add(student3);
		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> 

2.反射 

1.反射是什么，有什么作用？

1.反射---在程序运行过程中，我们可以得到某个类的对象，可以调用某个类中的任何一个变量/方法，这种动态获取信息的过程就是反射。

2.当我们在没有见过某个类的情况下，仅凭一个完整的类名【包名+类名】，就可以获取到整个类的所有信息

3.反射的使用场景：

    1、jdbc加载数据库驱动

    2、Servlet的web.xml配置

    3、Spring框架

2.实例对象与反射对象的相互转换

实例对象---就是我们通过类创建的对象

反射对象---通过反射机制得到的类对象

例如:  反射就是一面镜子，镜子前面的你就是实例对象，通过镜子得到的镜子里面的你就是反射对象。

反射对象是一个Class类型的对象

class---创建类的关键字

Class---类的类名，创建出来的Class类的对象就是反射对象。

public final class Class<T>

 1.通过实例对象得到反射对象

1.通过实例对象的getClass()得到，当前实例对象对应的反射对象

2.通过Class类的forname(类名【包名+类名】)

package com.wangxing.test3;
/*
 * 测试类
 */
public class TestMain {

	public static void main(String[] args)throws Exception{
		//通过实例对象得到反射对象
		//1.通过实例对象的getClass()得到，当前实例对象对应的反射对象
		Student stu1=new Student();
		Class stuclass1=stu1.getClass();
		//System.out.println(stuclass1);
		//2.通过Class类的forname(类名【包名+类名】)
		Class stuclass2=Class.forName("com.wangxing.test3.Student");
		System.out.println(stuclass2);
		
   }
}

 2.通过反射对象得到实例对象

反射对象的newInstance()方法，可以得到实例对象

例如：

      得到一个类的实例对象的方式:

      1.new     2.静态方法      3.反射

package com.wangxing.test3;
/*
 * 测试类
 */
public class TestMain {

	public static void main(String[] args)throws Exception{
		//通过反射对象得到实例对象
		//反射对象的newInstance()方法，可以得到实例对象
		Class stuclass=Class.forName("com.wangxing.test3.Student");
		Student stu1=(Student)stuclass.newInstance();
		stu1.setStuid(1001);
		stu1.setStuname("猪八戒");
   }
}

3.通过反射对象得到类的完整结构

Constructor<?>[]    getConstructors() 得到构造方法

Field[]    getDeclaredFields() 得到成员变量

Method[]    getDeclaredMethods() 得到成员方法

Class<?>[]    getInterfaces() 得到接口。 

Class<? super T>    getSuperclass() 得到父类。

Package    getPackage() 得到包对象。

int    getModifiers() Java语言修饰符

Modifier的toString(int mod)

String    getName() 得到类名称

例如：

package com.wangxing.test4;
public class Person {

}

package com.wangxing.test4;
/*
 * 接口
 */
public interface MyInterface {

}

package com.wangxing.test4;
public class Student extends Person implements MyInterface{
	private int stuid;
	private String stuname;
	public Student(){
	}
	public String getInfo(String agrs1)throws Exception{
		return "hello";
	}
}

package com.wangxing.test4;

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

/*
 * 测试类
 */
public class TestMain {

	public static void main(String[] args)throws Exception{
		//通过Class类的forname(类名【包名+类名】)
		Class stuclass=Class.forName("com.wangxing.test4.Student");
		//Package	getPackage() 得到包对象。
		Package stupacket=stuclass.getPackage();
		//String	getName() 得到类名称
		String stupackname=stupacket.getName();
		//int	getModifiers() Java语言修饰符 Modifier的toString(int mod)
		String classModifier=Modifier.toString(stuclass.getModifiers());
		//String	getName() 得到类名称
		String stuclassname= stuclass.getName();
		//拆分字符串
		stuclassname=getMyName(stuclassname);
		//Class<? super T>	getSuperclass() 得到父类。
		String supername=getMyName(stuclass.getSuperclass().getName());
		//Class<?>[]	getInterfaces() 得到接口。 
		String intername=getMyName(stuclass.getInterfaces()[0].getName());
		System.out.println(classModifier+"class"+stuclassname+"exdents"+supername+"interface"+intername+"{");
		//Field[]	getDeclaredFields() 得到成员变量
		Field fileds[]= stuclass.getDeclaredFields();
		for(Field  field:fileds){
			String fieldmod=Modifier.toString(field.getModifiers());
			String fieldtype=getMyName(field.getType().getName());
			String fieldname=field.getName();
			System.out.println("\t"+fieldmod+" "+fieldtype+" "+fieldname+";");
		}
		//Constructor<?>[]	getConstructors() 得到构造方法
		Constructor stuConstructor=stuclass.getConstructors()[0];
		String stuConModifier=Modifier.toString(stuConstructor.getModifiers());
		String stuConClassName=getMyName(stuConstructor.getName());
		System.out.println("\t"+stuConModifier+" "+stuConClassName+"(){}");
		//Method[]	getDeclaredMethods() 得到成员方法
		Method method=stuclass.getDeclaredMethods()[0];
		String methodmodifier=Modifier.toString(method.getModifiers());
		String methodreturn=getMyName(method.getReturnType().getName());
		String methodname=method.getName();
		String methodparame=getMyName(method.getParameterTypes()[0].getName());
		String methodexce=getMyName(method.getExceptionTypes()[0].getName());
		System.out.println("\t"+methodmodifier+" "+methodreturn+" "+methodname+"("+methodparame+" args1)throws "+methodexce+"{");
		System.out.println("\t\t return \"hello\";");
		System.out.println("\t}");
		System.out.println("}");
	}
	/*
	 * 得到不带包名的数据类型名称
	 */
	private static String getMyName(String stuclassname) {
		return stuclassname.substring(stuclassname.lastIndexOf(".")+1);
	}
}

3.注解

    注释---标注解释说明代码的含义用的文字
    注解---标注解释说明功能的代码

 1.@Override  判断方法重写是否正确

2.@SuppressWarnings  抑制警告信息。

有参数---产生警告的原因

位置：当前代码的上面，只抑制当前代码上的警告信息

           方法代码的上面，只抑制当前方法中的同类型的警告信息

           类的上面，只抑制当前类中的同类型的警告信息

@SuppressWarnings({ "unused", "rawtypes" })

3. @Deprecated  标识变量/方法/类/接口，已过时。
    已过时的元素尽量避免使用，因为有潜在的错误

package com.wangxing.test5;

public class Person {

	public  void  getinfo(){
		System.out.println("Person类的实例方法");
	}
}

package com.wangxing.test5;

public class Student extends Person{
	//下面这个方法不是重写父类的方法
	//子类自己声明定义的实例方法
	@Override
	public void  getinfo(){
		System.out.println("重写父类的方法");
	}
}
package com.wangxing.test5;

import java.util.ArrayList;
import java.util.List;
@SuppressWarnings({ "unused", "rawtypes" })
public class TestMain {
	
   public  static  void  main(String args[]){
	Student  stu1=new Student();
	Student  stu2=new Student();
	List  list=new ArrayList();
   }
	 
	public  void  test1(){
		Student  stu1=new Student();
		Student  stu2=new Student();
		List  list=new ArrayList();
	}
}