Java泛型、反射和注解

小鱼儿 2021-09-28 18:36 335阅读 0赞

# Java泛型、反射和注解 #

本文是基于Windows 10系统环境，学习和使用java泛型、反射和注解

*  **Windows 10**
 *  **MyEclipse 10**

--------------------

## 一、泛型 ##

### (1) 基本概念 ###

*  **泛型方法的定义**

public <T,K> T save(T t, K k){ 
    	return t;
    }

*  **泛型类的定义**

public class GenericDemo<T>{ 
    	public T save(T t){ 
    		return t;
    	}
    }

*  **泛型接口的定义**

public interface IBaseDao<T> { 
    	void save(T t);
    }

*  **？关键字**

public class App_extends_super { 
    	
    	//只带泛型特征的方法
    	public void save(List<?> list) { 
    		// 只能获取、迭代list; 不能编辑list
    	}
    	@Test
    	public void testGeneric() throws Exception { 
    		// ? 可以接收任何泛型集合， 但是不能编辑集合值； 所以一般在方法参数中用
    		List<?> list = new ArrayList<String>();
    		//list.add("");// 报错
    	}
    }

*  **extends关键字**

public class App_extends_super { 
    	
    	
    	/** * list集合只能处理 Double/Float/Integer等类型 * 限定元素范围：元素的类型要继承自Number类 (上限) * @param list */
    	public void save(List<? extends Number> list) { 
    	}
    	@Test
    	public void testGeneric() throws Exception { 
    		List<Double> list_1 = new ArrayList<Double>();
    		List<Float> list_2 = new ArrayList<Float>();
    		List<Integer> list_3 = new ArrayList<Integer>();
    		
    		List<String> list_4 = new ArrayList<String>();
    		
    		// 调用
    		save(list_1);
    		save(list_2);
    		save(list_3);
    		//save(list_4); 会报错
    	}
    }

*  **super关键字**

/** * 泛型, 涉及到一些关键字 * * Ctrl + shift + R 查看当前项目中类 * Ctrl + shift + T 查看源码jar包中的类 * @author Jie.Yuan * */
    public class App_super { 
    	/** * super限定元素范围：必须是String父类 【下限】 * @param list */
    	public void save(List<? super String> list) { 
    	}
    	@Test
    	public void testGeneric() throws Exception { 
    		// 调用上面方法，必须传入String的父类
    		List<Object> list1 = new ArrayList<Object>();
    		List<String> list2 = new ArrayList<String>();
    		
    		List<Integer> list3 = new ArrayList<Integer>();
    		//save(list3); 会报错
    	}
    }

*  **声明泛型时，两端类型必须一致**

List<Object> list = new ArrayList<Object>();
    List<String> list1 = new ArrayList<String>();
    // 两端类型必须一致,编译会报错
    List<Object> list2 = new ArrayList<String>();

*  **泛型的类型只能是引用类型，不能是基本类型**

// 编译会报错，因为泛型的类型不能是基本类型
    List<int> list3 = new ArrayList<int>();

### (2) 泛型擦除 ###

*  **泛型只在编译时期有效，编译后的字节码文件中不存在有泛型信息！**

// 编译会报错，因为编译器会认为参数都是List类型，不会认为是函数重载
    public void save(List<Person> p);
    public void save(List<String> name);

## 二、反射 ##

### (1) 反射技术 ###

*  **反射定义**  
    可以在运行时期动态创建对象；获取对象的属性、方法。
 *  **Demo.java**

/** * */
    package com.inspur.c_reflect;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    
    import org.junit.Test;
    
    /** * ClassName: Demo * Function: TODO ADD FUNCTION * @author: xuzheng * date: 2019-5-30 下午7:30:12 */
    public class Demo { 
    	@Test
    	public void test1() throws Exception{ 
    		String className = "com.inspur.c_reflect.Admin";
    		Class<?> clazz = Class.forName(className);
    		//创建对象1：默认构造函数简写
    		//Admin admin = (Admin) clazz.newInstance();
    		
    		//创建对象2：通过带参数构造器创建对象
    		Constructor<?> declaredConstructor = clazz.getDeclaredConstructor(String.class);
    		declaredConstructor.newInstance("name");
    	}
    	
    	//反射获取属性名称、值
    	@Test
    	public void test2() throws Exception{ 
    		String className = "com.inspur.c_reflect.Admin";
    		Class<?> clazz = Class.forName(className);
    		Admin admin = (Admin) clazz.newInstance();
    		
    		Field[] fields = clazz.getDeclaredFields();
    		for(Field f : fields){ 
    			f.setAccessible(true);
    			String name = f.getName();
    			Object value = f.get(admin);
    			System.out.println(name+ value);
    		}
    	}
    	
    	//反射获取方法对象
    		@Test
    		public void test3() throws Exception{ 
    			String className = "com.inspur.c_reflect.Admin";
    			Class<?> clazz = Class.forName(className);
    			Admin admin = (Admin) clazz.newInstance();
    			
    			Method m = clazz.getDeclaredMethod("getId");
    			Object value = m.invoke(admin);
    			System.out.println(value);
    		}
    }

*  **Admin.java**

/** * */
    package com.inspur.c_reflect;
    
    /** * ClassName: Admin * Function: TODO ADD FUNCTION * @author: xuzheng * date: 2019-5-30 ÏÂÎç7:29:19 */
    public class Admin { 
    	private int id = 100;
    	private String name = "tom";
    	public Admin(){ 
    		System.out.println("Admin()");
    	}
    	public Admin(String name){ 
    		System.out.println("Admin(name)");
    	}
    	public int getId() { 
    		return id;
    	}
    	public void setId(int id) { 
    		this.id = id;
    	}
    	public String getName() { 
    		return name;
    	}
    	public void setName(String name) { 
    		this.name = name;
    	}
    	@Override
    	public String toString() { 
    		return "Admin [id=" + id + ", name=" + name + "]";
    	}
    	
    }

### (2) 反射泛型 ###

*  **Demo.java**

/** * */
    package com.inspur.b_reflect;
    
    import org.junit.Test;
    
    /** * ClassName: Demo * Function: TODO ADD FUNCTION * @author: xuzheng * date: 2019-5-30 ÏÂÎç4:14:36 */
    public class Demo { 
    	@Test
    	public void test(){ 
    		AdminDao adminDao = new AdminDao();
    		Admin admin = adminDao.findById(1);
    		System.out.println(admin);
    		
    		System.out.println(adminDao.getAll());
    	}
    }

*  **Admin.java**

/** * */
    package com.inspur.b_reflect;
    
    /** * ClassName: Admin * Function: TODO ADD FUNCTION * @author: xuzheng * date: 2019-5-30 ÏÂÎç2:46:08 */
    public class Admin { 
    	private int id;
    	private String userName;
    	private String pwd;
    	public int getId() { 
    		return id;
    	}
    	public void setId(int id) { 
    		this.id = id;
    	}
    	public String getUserName() { 
    		return userName;
    	}
    	public void setUserName(String userName) { 
    		this.userName = userName;
    	}
    	public String getPwd() { 
    		return pwd;
    	}
    	public void setPwd(String pwd) { 
    		this.pwd = pwd;
    	}
    	@Override
    	public String toString() { 
    		return "Admin [id=" + id + ", userName=" + userName + ", pwd=" + pwd
    				+ "]";
    	}
    	
    }

*  **Account.java**

/** * */
    package com.inspur.b_reflect;
    
    /** * ClassName: Account * Function: TODO ADD FUNCTION * @author: xuzheng * date: 2019-5-30 ÏÂÎç2:47:12 */
    public class Account { 
    	private int id;
    	private String accountName;
    	private double money;
    	public int getId() { 
    		return id;
    	}
    	public void setId(int id) { 
    		this.id = id;
    	}
    	public String getAccountName() { 
    		return accountName;
    	}
    	public void setAccountName(String accountName) { 
    		this.accountName = accountName;
    	}
    	public double getMoney() { 
    		return money;
    	}
    	public void setMoney(double money) { 
    		this.money = money;
    	}
    	@Override
    	public String toString() { 
    		return "Account [id=" + id + ", accountName=" + accountName
    				+ ", money=" + money + "]";
    	}
    	
    }

*  **AdminDao.java**

/** * */
    package com.inspur.b_reflect;
    
    /** * ClassName: AdminDao * Function: TODO ADD FUNCTION * @author: xuzheng * date: 2019-5-30 ÏÂÎç4:34:59 */
    public class AdminDao extends BaseDao<Admin> { 
    
    }

*  **AccountDao.java**

/** * */
    package com.inspur.b_reflect;
    
    /** * ClassName: AccountDao * Function: TODO ADD FUNCTION * @author: xuzheng * date: 2019-5-30 ÏÂÎç4:35:59 */
    public class AccountDao extends BaseDao<Account> { 
    
    }

*  **BaseDao.java**

/** * */
    package com.inspur.b_reflect;
    
    import java.lang.reflect.ParameterizedType;
    import java.lang.reflect.Type;
    import java.sql.SQLException;
    import java.util.List;
    
    import org.apache.commons.dbutils.handlers.BeanHandler;
    import org.apache.commons.dbutils.handlers.BeanListHandler;
    
    /** * ClassName: BaseDao * Function: TODO ADD FUNCTION * @author: xuzheng * date: 2019-5-30 ÏÂÎç2:48:47 */
    public class BaseDao<T> { 
    	private Class clazz;
    	private String tableName;
    	public BaseDao(){ 
    		Type type = this.getClass().getGenericSuperclass();
    		ParameterizedType pt = (ParameterizedType)type;
    		Type[] types = pt.getActualTypeArguments();
    		clazz = (Class)types[0];
    		tableName = clazz.getSimpleName();
    		System.out.println(tableName);
    	}
    	public T findById(int id) { 
    		String sql = "select * from "+ tableName + " where id=?";
    		try { 
    			return JdbcUtils.getQueryRunner().query(sql, new BeanHandler<T>(clazz), id);
    		} catch (SQLException e) { 
    			throw new RuntimeException(e);
    		}
    	}
    	
    	public List<T> getAll() { 
    		String sql = "select * from "+ tableName;
    		try { 
    			return JdbcUtils.getQueryRunner().query(sql, new BeanListHandler<T>(clazz));
    		} catch (SQLException e) { 
    			throw new RuntimeException(e);
    		}
    	}
    }

*  **JdbcUtils.java**

/** * */
    package com.inspur.b_reflect;
    
    import javax.sql.DataSource;
    
    import org.apache.commons.dbutils.QueryRunner;
    
    import com.mchange.v2.c3p0.ComboPooledDataSource;
    
    /** * ClassName: JdbcUtils * Function: TODO ADD FUNCTION * @author: xuzheng * date: 2019-5-30 ĎÂÎç4:06:11 */
    public class JdbcUtils { 
    	private static DataSource dataSource;
    	static{ 
    		dataSource = new ComboPooledDataSource();
    	}
    	
    	public static DataSource getDataSource(){ 
    		return dataSource;
    	}
    	
    	public static QueryRunner getQueryRunner(){ 
    		return new QueryRunner(dataSource);
    	}
    }

## 三、注解 ##

### (1) 基本概念 ###

*  **注解与注释**  
    注解，告诉编译器如何运行程序！  
    注释， 给程序员阅读，对编译、运行没有影响；
 *  **注解作用**  
    告诉编译器如何运行程序；  
    简化(取代)配置文件 【案例后再看】
 *  **常用的注解**
 *  **Demo.java**

// 重写父类的方法
    	@Override
    	public String toString() { 
    		return super.toString();
    	}
    	
    	// 抑制编译器警告
    	@SuppressWarnings({ "unused","unchecked"})
    	private void save() { 
    		List list = null;
    	}
    	
    	// 标记方法以及过时
    	@Deprecated
    	private void save1() { 
    	}

### (2) 自定义注解 ###

通过自定义注解，可以给类、字段、方法上添加描述信息！

#### a. 注解基本写法 ####

*  **Author.java**

/** * 自定义注解 (描述一个作者) * @author xuzheng * */
    public @interface Author { 
    	/** * 注解属性 * 1. 修饰为默认或public * 2. 不能有主体 */
    	String name();
    	int age();
    }

*  **调用**

@Author(name = "Jet", age = 30)
    public void save() { 
    }

#### b. 带默认值的注解 ####

*  **Author.java**

/** * 自定义注解 (描述一个作者) * @author xuzheng * */
    public @interface Author { 
    	/** * 注解属性 * 1. 修饰为默认或public * 2. 不能有主体 */
    	String name();
    	int age() default 30; // 带默认值的注解;使用的时候就可以不写此属性值
    }

*  **调用**

@Author(name = "Jet")
    public void save() { 
    }

#### c. 默认名称的注解 ####

*  **注解属性名称为value，这就是默认名称**
 *   *  **Author.java**

/** * 自定义注解 (描述一个作者) * @author xuzheng * */
    public @interface Author { 
    	// 如果注解名称为value,使用时候可以省略名称，直接给值
    	// (且注解只有一个属性时候才可以省略名称)
    	String value();
    }

*  **调用**

@Author("Jet")
    @Author(value = "Jet")

*  **注解属性类型为数组**
 *   *  **Author.java**

/** * 自定义注解 (描述一个作者) * @author xuzheng * */
    public @interface Author { 
    	String[] value() default { "test1","test2"};
    }

*  **调用**

@Author（{ "",""}）
    public void save() { 
    }

### (3) 元注解 ###

元注解，表示注解的注解！

*  **1. 指定注解的可用范围**

@Target({ TYPE,FIELD,METHOD,PARAMETER,CONSTRUCTOR,LOCAL_VARIABLE})
    //TYPE, 类
    //FIELD, 字段
    //METHOD, 方法
    //PARAMETER, 参数
    //CONSTRUCTOR, 构造器
    //LOCAL_VARIABLE 局部变量

*  **2. 指定注解的声明周期**

@Retention(RetentionPolicy.SOURCE)    //注解只在源码级别有效
    @Retention(RetentionPolicy.CLASS)     //注解在字节码即别有效 默认值
    @Retention(RetentionPolicy.RUNTIME)   //注解在运行时期有效

### (4) 注解反射 ###

*  **Demo.java**

@Id
    @Author(remark = "保存信息！！！", age = 19)
    public void save() throws Exception { 
    	// 获取注解信息： name/age/remark
    	// 1. 先获取代表方法的Method类型;
    	Class clazz = App_2.class;
    	Method m = clazz.getMethod("save");
    	// 2. 再获取方法上的注解
    	Author author = m.getAnnotation(Author.class);
    	// 获取输出注解信息
    	System.out.println(author.authorName());
    	System.out.println(author.age());
    	System.out.println(author.remark());
    }

*  **Author.java**

/** * 自定义注解 (描述一个作者) * @author xuzheng * */
    // 元注解 - 1. 定义注解的可用范围
    @Target({ TYPE,FIELD , METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
    //@Target({METHOD,FIELD,TYPE}) 指定只能在方法、字段、类上用；
    
    // 元注解 - 2. 指定注解的声明周期
    @Retention(RetentionPolicy.RUNTIME)   // 字节码级别有效
    public @interface Author { 
    	String authorName() default "Jet";
    	int age() default 30;	
    	String remark();
    }

--------------------