java--泛型加强、注解、日志组件

泛型

概述

泛型是JDK1.5以后才有的， 可以在编译时期进行类型检查，且可以避免频繁类型转化！

声明泛型集合，集合两端类型必须一致

运行时期异常

@Test
public void testGeneric() throws Exception {
    // 集合的声明
    List list = new ArrayList();
    list.add("China");
    list.add(1);

    // 集合的使用
    String str = (String) list.get(1);

}

使用泛型就会在编译时报错

泛型擦除

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

public void save(List<Person> p){
}
public void save(List<Dept> d){    // 报错： 与上面方法编译后一样
}

泛型类型必须是引用类型,不能为基本类型

泛型方法

作用：
设计公用的类、方法，对公用的业务实现进行抽取！
使程序更灵活！

public class GenericDemo {

// 定义泛型方法
public <K,T> T save(T t,K k) {
    return null;
}

// 测试方法
@Test
public void testMethod() throws Exception {
    // 使用泛型方法:  在使用泛型方法的时候，确定泛型类型
    save(1.0f, 1);
}
｝

泛型类

public class GenericDemo<T> {

// 定义泛型方法
public <K> T save(T t,K k) {
    return null;
}

public void update(T t) {

}

// 测试方法
@Test
public void testMethod() throws Exception {

    // 泛型类：  在创建泛型类对象的时候，确定类型
    GenericDemo<String> demo = new GenericDemo<String>();
    demo.save("test", 1);
}
}

泛型接口

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

泛型接口类型确定： 在业务实现类中直接确定接口的类型

public class PersonDao implements IBaseDao<Person>{}

泛型接口类型确定： 实现泛型接口的类也是抽象，那么类型在具体的实现中确定或创建泛型类的时候确定

public class BaseDao<T> implements IBaseDao<T> {}

泛型关键字

?               指定只是接收值
extends      元素的类型必须继承自指定的类
super        元素的类型必须是指定的类的父类

关键字？

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 【上限】

list集合只能处理 Double/Float/Integer等类型
限定元素范围：元素的类型要继承自Number类  (上限)

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 【下限】

super限定元素范围：必须是String父类   【下限】

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);报错
}

泛型的反射

ParameterizedType 参数化类型的表示：ArrayList();

Type 接口，任何类型默认的接口！
包括： 引用类型、原始类型、参数化类型

List list = new ArrayList();

泛型集合： list

集合元素定义：new ArrayList(); 中的String

参数化类型： ParameterizedType
即：“ArrayList ” 为参数化类型

public class AdminDao extends BaseDao<Admin> {}
public class AccountDao extends BaseDao<Account> {}

所有dao的公用的方法，都在这里实现

public class BaseDao<T>{

// 保存当前运行类的参数化类型中的实际的类型
private Class clazz;
// 表名
private String tableName;



// 构造函数： 1. 获取当前运行类的参数化类型； 2. 获取参数化类型中实际类型的定义(class)
public BaseDao(){
    //  this  表示当前运行类  (AccountDao/AdminDao)
    //  this.getClass()  当前运行类的字节码(AccountDao.class/AdminDao.class)
    //  this.getClass().getGenericSuperclass();  当前运行类的父类，即为BaseDao<Account>
    //  其实就是“参数化类型”， ParameterizedType   
    Type type = this.getClass().getGenericSuperclass();
    // 强制转换为“参数化类型”  【BaseDao<Account>】
    ParameterizedType pt = (ParameterizedType) type;
    // 获取参数化类型中，实际类型的定义  【new Type[]{Account.class}】
    Type types[] =  pt.getActualTypeArguments();
    // 获取数据的第一个元素：Accout.class
    clazz = (Class) types[0];
    // 表名  (与类名一样，只要获取类名就可以)
    tableName = clazz.getSimpleName();
}


/**
 * 主键查询
 * @param id    主键值
 * @return      返回封装后的对象
 */
public T findById(int id){
    /*
     * 1. 知道封装的对象的类型
     * 2. 表名【表名与对象名称一样， 且主键都为id】
     * 
     * 即，
     *    ---》得到当前运行类继承的父类  BaseDao<Account>
     *   ----》 得到Account.class
     */

    String sql = "select * from " + tableName + " where id=? ";
    try {
        return JdbcUtils.getQuerrRunner().query(sql, new BeanHandler<T>(clazz), id);
    } catch (SQLException e) {
        throw new RuntimeException(e);
    }
}


/**
 * 查询全部
 * @return
 */
public List<T> getAll(){
    String sql = "select * from " + tableName ;
    try {
        return JdbcUtils.getQuerrRunner().query(sql, new BeanListHandler<T>(clazz));
    } catch (SQLException e) {
        throw new RuntimeException(e);
    }
}
}

注解

注解作用，

1. 告诉编译器如何运行程序；
2. 简化(取代)配置文件
3

常用注解

// 重写父类的方法
@Override
public String toString() {
    return super.toString();
}

// 抑制编译器警告
@SuppressWarnings({"unused","unchecked"})
private void save() {
    List list = null;
}

// 标记方法以及过时
@Deprecated
private void save1() {
}

自定义注解

public @interface Author {

/**
 * 注解属性
 *    1. 修饰为默认或public
 *    2. 不能有主体
 */
String name();
int age();
}

使用：

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

}

带默认值的注解

public @interface Author {

/**
 * 注解属性
 *    1. 修饰为默认或public
 *    2. 不能有主体
 */
String name();
int age() default 30;   // 带默认值的注解;  使用的时候就可以不写此属性值
}

默认名称的注解

注解属性名称为value，这就是默认名称

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

使用

@Author(“Jet”)

@Author(value = “Jet”)

注解属性类型为数组：

public @interface Author {

String[] value() default {"test1","test2"};
}

使用

@Author（{“”，“”}）
public void save() {

}

元注解

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

指定注解的可用范围：

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

// 元注解 - 2. 指定注解的声明周期

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

---

// 元注解 - 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();

}

注解反射

@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());
}

注解：

简化XML配置， 程序处理非常方便！
(不便于维护： 例如修改字段名，要重新编译！)

XML
便于维护！ 需要些读取代码！

Log4J日志组件

使用步骤：

1. 下载组件，引入jar文件;
    log4j-1.2.11.jar
2. 配置 :  src/log4j.properties
3. 使用

log4j.properties内容

# 通过根元素指定日志输出的级别、目的地： 
#  日志输出优先级： debug < info < warn < error 
log4j.rootLogger=info,console,file

############# 日志输出到控制台 #############
# 日志输出到控制台使用的api类
log4j.appender.console=org.apache.log4j.ConsoleAppender
# 指定日志输出的格式： 灵活的格式
log4j.appender.console.layout=org.apache.log4j.PatternLayout
# 具体格式内容
log4j.appender.console.layout.ConversionPattern=%d %p %c.%M()-%m%n


############# 日志输出到文件 #############
log4j.appender.file=org.apache.log4j.RollingFileAppender
# 文件参数： 指定日志文件路径
log4j.appender.file.File=../logs/MyLog.log
# 文件参数： 指定日志文件最大大小
log4j.appender.file.MaxFileSize=5kb
# 文件参数： 指定产生日志文件的最大数目
log4j.appender.file.MaxBackupIndex=100
# 日志格式
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d %c.%M()-%m%n

---

public class App {

Log log = LogFactory.getLog(App.class);

@Test
public void save() {
    try {
        log.info("保存： 开始进入保存方法");

        int i = 1/0;

        log.info("保存： 执行保存结束，成功");
    } catch (Exception e) {

        log.error("执行App类Save()方法出现异常！");  // 异常

        e.printStackTrace();
    }
}

/*
 * 思考： 日志的输出级别作用？
 *   ----> 控制日志输出的内容。
 */
@Test
public void testLog() throws Exception {
    // 输出不同级别的提示
    log.debug("调试信息");
    log.info("信息提示");
    log.warn("警告");
    log.error("异常");

}
}