Java泛型、反射和注解
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();
}