清风微凉 aaa

day05--java高级编程：Junit单元测试框架、泛型，集合：集合数组互转，迭代器，增强for循环，集合工具类，数据结构简介

补充：Junit单元测试框架

1. 简介

概述：

JUnit是使用Java语言实现的单元测试框架，它是开源的，Java开发者都应当学习并使用JUnit编写单元测试。
此外，几乎所有的IDE工具都集成了JUnit，这样我们就可以直接在IDE中编写并运行JUnit测试，JUnit目前最新版本是5

使用main方法测试的缺点：

只有一个main方法，如果一个方法的测试失败了，其他方法测试会受到影响。
无法得到测试的结果报告，需要程序员自己去观察测试是否成功。
无法实现自动化测试。

Junit单元测试的优点：

JUnit可以灵活的选择执行哪些测试方法，也可以一键执行全部测试方法。
JUnit可以生测试报告，如果测试良好则是绿色；如果测试失败则是红色。
单元测试中的某个方法测试失败了，不会影响其他测试方法的测试。

2. 快速入门

说明：将JUnit的jar包导入到项目中

IDEA通常整合好了Junit框架，一般不需要导入。
解释：很多idea只是把Junit框架集成了并没有下载，所以你第一次使用时可以根据注解提示的报错进行自动下载(前提是联网)，在之后使用中就不需要导包了。
如果IDEA没有整合好，需要自己手工导入如下2个JUnit的jar包到模块

package com.atguigu.java2;

import java.util.Date;

import org.junit.Test;

/*
 * Java中的JUnit单元测试
 * 
 * 步骤：
 * 1.选中当前工程 - 右键选择：build path - add libraries - JUnit 4 -， 
 *    (可选，这一步也可以放在第四步直接add添加依赖和导包)
 * 2.下一步创建 Java类，进行单元测试。
 *   此时的Java类要求：① 此类是public的  ②此类提供公共的无参的构造器
 * 3.此类中声明单元测试方法。
 *   此时的单元测试方法：方法的权限是public,没有返回值，没有形参
 * 
 * 4.此单元测试方法上需要声明注解：@Test,并在单元测试类中导入：import org.junit.Test;
 * 
 * 5.声明好单元测试方法以后，就可以在方法体内测试相关的代码。
 * 6.写完代码以后，左键双击单元测试方法名，右键：run as - JUnit Test
 * 
 * 说明：
 * 1.如果执行结果没有任何异常：绿条
 * 2.如果执行结果出现异常：红条
 */
public class JUnitTest {
	
	int num = 10;
	
	@Test
	public void testEquals(){
		String s1 = "MM";
		String s2 = "MM";
		System.out.println(s1.equals(s2));
		//ClassCastException的异常
//		Object obj = new String("GG");
//		Date date = (Date)obj;
		
		System.out.println(num);
		show();
	}
	
	public void show(){
		num = 20;
		System.out.println("show()....");
	}
	
	@Test
	public void testToString(){
		String s2 = "MM";
		System.out.println(s2.toString());
	}
}

测试：
执行一个测试方法

3. 常用注解

Junit 4.xxxx版本：

Junit 5.xxxx版本：

测试：
一次性执行所有的测试方法

4. 泛型

4.1 出现背景

4.2 概念

4.3 测试1：在集合ArrayList，HashMap中使用泛型

package com.atguigu.java;

import org.junit.Test;

import java.util.*;

/**
 *
 * 泛型的使用
 * 1.jdk 5.0新增的特性
 *
 * 2.在集合中使用泛型：
 *  总结：
 *  ① 集合接口或集合类在jdk5.0时都修改为带泛型的结构。
 *  ② 在实例化集合类时，可以指明具体的泛型类型
 *  ③ 指明完以后，在集合类或接口中凡是定义类或接口时，内部结构（比如：方法、构造器、属性等）使用到类的泛型的位置，都指定为实例化的泛型类型。
 *    比如：add(E e)  --->实例化以后：add(Integer e)
 *  ④ 注意点：泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，拿包装类替换
 *  ⑤ 如果实例化时，没有指明泛型的类型。默认类型为java.lang.Object类型。
 *  ⑥ 在集合类或接口中凡是定义类或接口时，如果实例化时，没有指明泛型的类型，在eclipse中会有警告信息 在idea中没有警告。警告就是不强制 你不要
 *                                                                                              也不报错。
 *
 * 3.如何自定义泛型结构：泛型类、泛型接口；泛型方法。见 GenericTest1.java
 *
 * @author shkstart
 * @create 2019 上午 9:59
 */
public class GenericTest {


    //在集合中使用泛型之前的情况：
    @Test
    public void test1(){
        ArrayList list = new ArrayList();
        //需求：存放学生的成绩
        list.add(78);
        list.add(76);
        list.add(89);
        list.add(88);
        //问题一：类型不安全,没有限制可以存放任何类型。
//        list.add("Tom");

        for(Object score : list){
            //问题二：强转时，可能出现ClassCastException。因为强转要满足父子类关系，Tom是String类型 不满足条件。
            int stuScore = (Integer) score;//强转+自动拆箱

            System.out.println(stuScore);//78,76,89,88

        }

    }

    //在集合中使用泛型的情况：以ArrayList为例
    @Test
    public void test2(){
        //泛型都是引用数据类型，基本数据类型用它的包装类。
        /*
         * 说明：
         * ArrayList能指定泛型的前提是,底层源码定义这个类时声明了泛型 如：public class ArrayList extends AbstractList，
         * 创建对象时相当于是给这个泛型赋值了个具体的类型 如：ArrayList list =  new ArrayList(); 为Integer类型，
         * 那么凡是在这个底层源码的类ArrayList中用到泛型的地方 如：add()方法使用了泛型 public boolean add(E e) {}，则在实例化对象时，
         * 通过对象调用这个方法 如list.add(87);中元素的类型也应该和声明的泛型类型保持一致，即实例化的类型是Integer ，add方法添加元素类型也是Integer。
         *
         * 注意：如果定义类时没有指定泛型，那么创建对象时不能直接使用泛型。
         * */
        ArrayList<Integer> list =  new ArrayList<Integer>();

        list.add(78);//public boolean add(E e) {} 方法声明用的泛型和定义时一致，创建对象时有指定泛型为Integer,所以这里只能用Integer类型数据添加。
        list.add(87);
        list.add(99);
        list.add(65);
        //编译时，就会进行类型检查，保证数据的安全
//        list.add("Tom");

        //方式一：
//        for(Integer score : list){//直接就可以使用Integer类型来接收
//            //避免了强转操作
//            int stuScore = score;
//
//            System.out.println(stuScore);
//
//        }
        //方式二：
       /* Iterator在定义这个类时就使用了泛型，所以在这个地方就可以使用泛型了。public interface Iterator {}
       * 问题：为什么这个地方Iterator iterator调用方法的返回值 ，直接是Integer类型呢???
       * 原因：在ArrayList中，这个iterator()方法：  public Iterator iterator() {return new Itr();}使用了泛型，
       *      在实例化ArrayList时已经指定了泛型为Integer,所以这个方法中的泛型也是Integer。
       *
       * */
        Iterator<Integer> iterator = list.iterator();
        while(iterator.hasNext()){
            int stuScore = iterator.next();
            System.out.println(stuScore);
        }

    }

    //在集合中使用泛型的情况：以HashMap为例。Map集合有2值所以k v都要指定泛型。
    @Test
    public void test3(){
        //定义Map接口时泛型就写了2个，所以实例化对象也要写2个。public interface Map {}

        //jdk7新特性：类型推断。 原来的写法：Map map = new HashMap();
        Map<String,Integer> map = new HashMap<>();

        map.put("Tom",87);
        map.put("Jerry",87);
        map.put("Jack",67);

//        map.put(123,"ABC");

        //解释1，泛型的嵌套：map.entrySet()返回的数据放在Set集合中，
        //     第一层嵌套：Set集合里面是一个个的Entry对象，所以泛型是Entry类型
        //     第二层嵌套：而Entry里面又有自己的泛型k v ，所以在进一步指定泛型。
        //解释2：Map.Entry为什么是通过Map.来调用
        //     Entry为Map集合接口的一个内部接口，所以想要使用内部接口就需要Map.Entry一下才能使用。
        //     如果想要省写为Set> entry = map.entrySet();，那么在上面需要进行导包：import java.util.Map.*;
        //                                                          因为Map导了import java.util.*;,如果连Map都没导还是需要写全。
        Set<Map.Entry<String,Integer>> entry = map.entrySet();
        Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();

        while(iterator.hasNext()){
            Map.Entry<String, Integer> e = iterator.next();
            String key = e.getKey();
            Integer value = e.getValue();
            System.out.println(key + "----" + value);
        }

    }


}

4.4 测试2：在集合TreeSet中使用泛型实现自然排序,定制排序

EmployeeTest：

package com.atguigu.exer;

import org.junit.Test;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

/**
 * 创建该类的 5 个对象，并把这些对象放入 TreeSet 集合中（下一章：TreeSet 需使用泛型来定义）
 分别按以下两种方式对集合中的元素进行排序，并遍历输出：

 1). 使Employee 实现 Comparable 接口，并按 name 排序
 2). 创建 TreeSet 时传入 Comparator对象，按生日日期的先后排序。

 *
 * @author shkstart
 * @create 2019 上午 10:23
 */
public class EmployeeTest {

    //问题二：按生日日期的先后排序。
    @Test
    public void test2(){

        TreeSet<Employee> set = new TreeSet<>(new Comparator<Employee>() {
            //使用泛型以后的写法
            @Override
            public int compare(Employee o1, Employee o2) {
                MyDate b1 = o1.getBirthday();
                MyDate b2 = o2.getBirthday();

                return b1.compareTo(b2);
            }
            //使用泛型之前的写法
            //@Override
//            public int compare(Object o1, Object o2) {
//                if(o1 instanceof Employee && o2 instanceof Employee){
//                    Employee e1 = (Employee)o1;
//                    Employee e2 = (Employee)o2;
//
//                    MyDate b1 = e1.getBirthday();
//                    MyDate b2 = e2.getBirthday();
//                    //方式一：
                    //比较年
                    int minusYear = b1.getYear() - b2.getYear();
                    if(minusYear != 0){
                        return minusYear;
                    }
                    //比较月
                    int minusMonth = b1.getMonth() - b2.getMonth();
                    if(minusMonth != 0){
                        return minusMonth;
                    }
                    //比较日
                    return b1.getDay() - b2.getDay();
//
//                    //方式二：
//                    return b1.compareTo(b2);
//
//                }
                return 0;
//                throw new RuntimeException("传入的数据类型不一致！");
//            }
        });

        Employee e1 = new Employee("liudehua",55,new MyDate(1965,5,4));
        Employee e2 = new Employee("zhangxueyou",43,new MyDate(1987,5,4));
        Employee e3 = new Employee("guofucheng",44,new MyDate(1987,5,9));
        Employee e4 = new Employee("liming",51,new MyDate(1954,8,12));
        Employee e5 = new Employee("liangzhaowei",21,new MyDate(1978,12,4));

        set.add(e1);
        set.add(e2);
        set.add(e3);
        set.add(e4);
        set.add(e5);

        Iterator<Employee> iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }


    //问题一：使用自然排序
    @Test
    public void test1(){
        TreeSet<Employee> set = new TreeSet<Employee>();

        Employee e1 = new Employee("liudehua",55,new MyDate(1965,5,4));
        Employee e2 = new Employee("zhangxueyou",43,new MyDate(1987,5,4));
        Employee e3 = new Employee("guofucheng",44,new MyDate(1987,5,9));
        Employee e4 = new Employee("liming",51,new MyDate(1954,8,12));
        Employee e5 = new Employee("liangzhaowei",21,new MyDate(1978,12,4));

        set.add(e1);
        set.add(e2);
        set.add(e3);
        set.add(e4);
        set.add(e5);

        Iterator<Employee> iterator = set.iterator();
        while (iterator.hasNext()){
            Employee employee = iterator.next();
            System.out.println(employee);
        }
    }
}

Employee：

package com.atguigu.exer;

/**
 * 定义一个Employee类。
 该类包含：private成员变量name,age,birthday，其中 birthday 为 MyDate 类的对象；
 并为每一个属性定义 getter, setter 方法；
 并重写 toString 方法输出 name, age, birthday

 * @author shkstart
 * @create 2019 上午 10:22
 */
public class Employee implements Comparable<Employee>{
    private String name;
    private int age;
    private MyDate birthday;

    public Employee(String name, int age, MyDate birthday) {
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }

    public Employee() {

    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public MyDate getBirthday() {
        return birthday;
    }

    public void setBirthday(MyDate birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", birthday=" + birthday +
                '}';
    }

    //指明泛型时的写法
    @Override
    public int compareTo(Employee o) {
        return this.name.compareTo(o.name);
    }

    //没有指明泛型时的写法
    //按 name 排序
//    @Override
//    public int compareTo(Object o) {
//        if(o instanceof Employee){
//            Employee e = (Employee)o;
//            return this.name.compareTo(e.name);
//        }
        return 0;
//        throw new RuntimeException("传入的数据类型不一致！");
//    }
}

MyDate：

package com.atguigu.exer;

/**
 * MyDate类包含:
 private成员变量year,month,day；并为每一个属性定义 getter, setter 方法；

 * @author shkstart
 * @create 2019 上午 10:21
 */
public class MyDate implements Comparable<MyDate>{
    private int year;
    private int month;
    private int day;

    public MyDate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public MyDate() {

    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public int getDay() {
        return day;
    }

    public void setDay(int day) {
        this.day = day;
    }

    @Override
    public String toString() {
        return "MyDate{" +
                "year=" + year +
                ", month=" + month +
                ", day=" + day +
                '}';
    }


//    @Override
//    public int compareTo(Object o) {
//        if(o instanceof MyDate){
//            MyDate m = (MyDate)o;
//
//            //比较年
//            int minusYear = this.getYear() - m.getYear();
//            if(minusYear != 0){
//                return minusYear;
//            }
//            //比较月
//            int minusMonth = this.getMonth() - m.getMonth();
//            if(minusMonth != 0){
//                return minusMonth;
//            }
//            //比较日
//            return this.getDay() - m.getDay();
//        }
//
//        throw new RuntimeException("传入的数据类型不一致！");
//
//    }

    @Override
    public int compareTo(MyDate m) {
        //比较年
        int minusYear = this.getYear() - m.getYear();
        if(minusYear != 0){
            return minusYear;
        }
        //比较月
        int minusMonth = this.getMonth() - m.getMonth();
        if(minusMonth != 0){
            return minusMonth;
        }
        //比较日
        return this.getDay() - m.getDay();
    }
}

4.5 自定义泛型结构

4.5.1 自定义泛型类，接口

说明：如果是接口只需要改为interface的形式，里面不能有构造方法，用法和类一样就不在讲解了，这里只学习自定义泛型类。
GenericTest1类：

package com.atguigu.java;

import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

/** 如何自定义泛型结构：泛型类、泛型接口；泛型方法。
 *
 * 1. 关于自定义泛型类、泛型接口：
 *
 *
 *
 * @author shkstart
 * @create 2019 上午 11:09
 */
public class GenericTest1 {

    @Test
    public void test1(){
        //如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型(即自定义类声明时使用了泛型，但在实例化时没有使用泛型)
        //要求：如果大家定义了类是带泛型的，建议在实例化时要指明类的泛型。
        Order order = new Order();
        order.setOrderT(123);
        order.setOrderT("ABC");

        //建议：实例化时指明类的泛型。orderName orderId是确定的类型，T orderT是确定的泛型 所以String赋值的是这个不确定的类型T。
        Order<String> order1 = new Order<String>("orderAA",1001,"order:AA");

        order1.setOrderT("AA:hello");

    }

    //测试：自定义类Order的子类在继承时，子类泛型书写有二种方式：
    @Test
    public void test2(){
        //方式一：
        //由于子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不再需要指明泛型。
        //继承关系：public class SubOrder extends Order {}，
        // 则子类实例化时 SubOrder sub1 = new SubOrder();不用在指定泛型
        //此时父类Order为泛型类，子类SubOrder是普通的类。
        SubOrder sub1 = new SubOrder();
        sub1.setOrderT(1122);//默认里面的元素就是Integer类型

        //方式二：
        //由于子类在继承带泛型的父类时，没有指明具体的泛型类型。则实例化子类对象时，仍需要指明泛型。
        // 继承关系：public class SubOrder1 extends Order {}，
        //则子类实例化时 SubOrder1 sub2 = new SubOrder1<>();需要指定泛型
        此时父类Order为泛型类，子类SubOrder1也是泛型类。
        SubOrder1<String> sub2 = new SubOrder1<>();
        sub2.setOrderT("order2...");
    }

Order父类：

package com.atguigu.java;

import java.util.ArrayList;
import java.util.List;

/**
 * 自定义泛型类
 * 说明：如果是接口只需要改为interface的形式，里面不能有构造方法，用法和类一样就不在讲解了。
 * @author shkstart
 * @create 2019 上午 11:05
 */
public class Order<T> {//通配符为任意字母，这个T不是类 是个参数。   接口中使用泛型
    //之前定义类的属性都是确定的类型，如果类中的属性不确定可以再定义接口时加上泛型，之后在类的内部结构就可以使用类的泛型
    String orderName;
    int orderId;

    //类的内部结构就可以使用类的泛型

    T orderT; //变量使用泛型

    //注意构造方法上不能使用泛型，但是在实例化对象时需要指定泛型。但是可以再构造方法的参数上使用泛型。
    // 错误写法：public Order(){}
    //正确写法：public Order(){}，在实例化时需要指定泛型：Order order1 = new Order<>();
    public Order(){
       
    }

    public Order(String orderName,int orderId,T orderT){//在构造方法的参数上使用泛型
        this.orderName = orderName;
        this.orderId = orderId;
        this.orderT = orderT;
    }

  //如下的三个方法都不是泛型方法
    public T getOrderT(){//不是泛型方法
        return orderT;
    }

    public void setOrderT(T orderT){
        this.orderT = orderT;//不是泛型方法
    }

    @Override
    public String toString() {//不是泛型方法
        return "Order{" +
                "orderName='" + orderName + '\'' +
                ", orderId=" + orderId +
                ", orderT=" + orderT +
                '}';
    }
 
}

SubOrder子类：

package com.atguigu.java;

import java.util.ArrayList;
import java.util.List;

/**
 * @author shkstart
 * @create 2019 上午 11:15
 */
public class SubOrder extends Order<Integer> {//SubOrder:不是泛型类

}

SubOrder1子类：

package com.atguigu.java;


/**
 * @author shkstart
 * @create 2019 上午 11:18
 */
public class SubOrder1<T> extends Order<T> {//SubOrder1:仍然是泛型类
}

4.5.1 自定义泛型类，接口的注意事项

注意事项2，4，9，10，11测试：
GenericTest1类：

package com.atguigu.java;

import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

/** 如何自定义泛型结构：泛型类、泛型接口；泛型方法。
 *
 * 1. 关于自定义泛型类、泛型接口：
 *
 *
 *
 * @author shkstart
 * @create 2019 上午 11:09
 */
public class GenericTest1 {


     //测试注意事项2：泛型类的构造器如下：public GenericClass(){}
     //             而下面是错误的：public GenericClass(){}
    @Test
    public void test(){
        Order<String> objectOrder = new Order<>();
    }

    //测试注意事项4:泛型不同的引用不能相互赋值。
    @Test
    public void test3(){

        ArrayList<String> list1 = null;
        ArrayList<Integer> list2 = new ArrayList<Integer>();

        //泛型不同的引用不能相互赋值。
//        list1 = list2;

        Person p1 = null;
        Person p2 = null;
        //原来的写法可以进行赋值
        p1 = p2;


    }

    //测试泛型方法
    @Test
    public void test4(){
        Order<String> order = new Order<>();
        Integer[] arr = new Integer[]{1,2,3,4};
        //泛型方法在调用时，指明泛型参数的类型。
        List<Integer> list = order.copyFromArrayToList(arr);

        System.out.println(list);
    }
}

Order类：

package com.atguigu.java;

import java.util.ArrayList;
import java.util.List;

/**
 * 自定义泛型类
 * 说明：如果是接口只需要改为interface的形式，里面不能有构造方法，用法和类一样就不在讲解了。
 * @author shkstart
 * @create 2019 上午 11:05
 */
public class Order<T> {//通配符为任意字母，这个T不是类 是个参数。   接口中使用泛型
    //之前定义类的属性都是确定的类型，如果类中的属性不确定可以再定义接口时加上泛型，之后在类的内部结构就可以使用类的泛型
    String orderName;
    int orderId;

    //类的内部结构就可以使用类的泛型

    T orderT; //变量使用泛型

    //测试注意事项2：注意构造方法上不能使用泛型，但是在实例化对象时需要指定泛型。但是可以再构造方法的参数上使用泛型。
    // 错误写法：public Order(){}
    //正确写法：public Order(){}，在实例化时需要指定泛型：Order order1 = new Order<>();
    public Order(){
        //注意事项11：创建T类型的数组不能是直接new T(),因为T只能看参数 而不能看成是类，解决：可以创建Object类型数组，在进行强转。
        //编译不通过
//        T[] arr = new T[10];
        //编译通过
        T[] arr = (T[]) new Object[10];
    }

    public Order(String orderName,int orderId,T orderT){//在构造方法的参数上使用泛型
        this.orderName = orderName;
        this.orderId = orderId;
        this.orderT = orderT;
    }

    //如下的三个方法都不是泛型方法
    public T getOrderT(){
        return orderT;
    }

    public void setOrderT(T orderT){
        this.orderT = orderT;
    }

    @Override
    public String toString() {
        return "Order{" +
                "orderName='" + orderName + '\'' +
                ", orderId=" + orderId +
                ", orderT=" + orderT +
                '}';
    }
    //注意事项9：静态方法中不能使用类的泛型。因为类的泛型是实例化创建对象时指定，静态资源是类加载时创建。
//    public static void show(T orderT){
//        System.out.println(orderT);
//    }

    //普通方法中不能写try--catch,解释在定义类时虽然自命为异常类型，但到catch中万一匹配的类型不是它的子类异常，不就编译不通过了
    public void show(){
        //编译不通过
//        try{
//
//
//        }catch(T t){
//
//        }

    }

}

Person类：

package com.atguigu.java;

/**
 * @author shkstart
 * @create 2019 上午 11:24
 */
public class Person {
}

MyException类：

package com.atguigu.java;


/**
 * @author shkstart
 * @create 2019 上午 11:29
 */
//注意事项10：异常类不能声明为泛型类
//public class MyException extends Exception{
//}

//这样可以
public class MyException<T> {
}

注意事项12测试：

4.5.1 自定义泛型方法

GenericTest1：

package com.atguigu.java;

import org.junit.Test;

import java.util.List;

/** 如何自定义泛型结构：泛型类、泛型接口；泛型方法。
 *
 * 1. 关于自定义泛型类、泛型接口：
 *
 *
 *
 * @author shkstart
 * @create 2019 上午 11:09
 */
public class GenericTest1 {




    //测试泛型方法
    @Test
    public void test4(){
        Order<String> order = new Order<>();
        Integer[] arr = new Integer[]{1,2,3,4};
        //泛型方法在调用时，指明泛型参数的类型。Integer
        List<Integer> list = order.copyFromArrayToList(arr);

        System.out.println(list);//[1, 2, 3, 4]
    }
}

Order：

package com.atguigu.java;

import java.util.ArrayList;
import java.util.List;

/**
 * 自定义泛型类
 * 说明：如果是接口只需要改为interface的形式，里面不能有构造方法，用法和类一样就不在讲解了。
 * @author shkstart
 * @create 2019 上午 11:05
 */
public class Order<T> {//通配符为任意字母，这个T不是类 是个参数。   接口中使用泛型
    //之前定义类的属性都是确定的类型，如果类中的属性不确定可以再定义接口时加上泛型，之后在类的内部结构就可以使用类的泛型
    String orderName;
    int orderId;

    //类的内部结构就可以使用类的泛型

    T orderT; //变量使用泛型

    //测试注意事项2：注意构造方法上不能使用泛型，但是在实例化对象时需要指定泛型。但是可以再构造方法的参数上使用泛型。
    // 错误写法：public Order(){}
    //正确写法：public Order(){}，在实例化时需要指定泛型：Order order1 = new Order<>();
    public Order(){
        //注意事项11：创建T类型的数组不能是直接new T(),因为T只能看参数 而不能看成是类，解决：可以创建Object类型数组，在进行强转。
        //编译不通过
//        T[] arr = new T[10];
        //编译通过
        T[] arr = (T[]) new Object[10];
    }

    public Order(String orderName,int orderId,T orderT){//在构造方法的参数上使用泛型
        this.orderName = orderName;
        this.orderId = orderId;
        this.orderT = orderT;
    }

    //如下的三个方法都不是泛型方法，他们使用的是类上的泛型
    public T getOrderT(){
        return orderT;
    }

    public void setOrderT(T orderT){
        this.orderT = orderT;
    }

    @Override
    public String toString() {
        return "Order{" +
                "orderName='" + orderName + '\'' +
                ", orderId=" + orderId +
                ", orderT=" + orderT +
                '}';
    }


    //泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系。
    //换句话说，泛型方法所属的类是不是泛型类都没有关系。
    //泛型方法，可以声明为静态的。泛型类中的方法不可以声明为静态的。原因：泛型参数是在调用方法时确定的。并非在实例化类时确定。
    //需求：在方法的形参中声明一个不确定类型的数组，然后放到list集合中 并返回，
    //注意1：E[] arr和Object[] arr效果不一致，E[]是可以赋值给任何类型 但是最终放到集合中的类型只有一种，
    //                                       而Object[]是任意类型，最终放到集合中的类型也是任意的。

    //注意2：数组元素是E类型，那么返回值也应该是List,但是这样写还不对 编译器会误认为这个E是类如String一个具体的类型,而不会认为是一个参数 我们
    //想要的是当作参数，在调用的时候进行赋值，解决需要在方法的返回值类型前面加上才会当做是参数来看。
    public static <E>  List<E> copyFromArrayToList(E[] arr){

        ArrayList<E> list = new ArrayList<>();

        for(E e : arr){
            list.add(e);
        }
        return list;

    }
}

4.5.2 泛型类和泛型方法的使用场景

DAOTest类：

package com.atguigu.java;

import org.junit.Test;

import java.util.List;

/**
 * @author shkstart
 * @create 2019 上午 11:57
 */
public class DAOTest {

    @Test
    public void test1(){

        //此时实例化dao层子类对象CustomerDAO后，CustomerDAO继承Dao指定了泛型为Customer类型，那么子类实例化就不用指定泛型，
        //调用方法时自动就是Customer类型
        CustomerDAO dao1 = new CustomerDAO();
        dao1.add(new Customer());
        List<Customer> list = dao1.getForList(10);



    }
}

DAO类：

package com.atguigu.java;

import java.util.List;

/**
 * @author shkstart
 * @create 2019 上午 11:50
 *
 *
 * DAO:data(base) access object  在java中Dao层定义数据库的访问对象进行crud操作对应 数据库的表中数据的crud操作。
 * 数据库中的表有对应java中的一个个自定义类 如：Customer，用自定义的类中的属性进行接收表中的字段。此时数据库中有多张表都需要crud操作，一般而言
 * 一张表对应java的一个类 对表的字段进行封装，那么此时操作这个类就相当于操作数据库中的表。如果每张表的crud操作都对应一个Dao层 多张表的操作有相同
 * 的功能，那么每张表的操作都写一个Dao层，此时会造成每个Dao层中有很多相似的代码。这就是用到了泛型，可以把父类Dao声明为泛型类型，通用的代码写在父类Dao层，
 * 用它的子类CustomerDAO写特有的功能 对应数据库每张表的特有功能，这样可以简写代码。
 *
 *
 */
public class DAO<T> {//表的共性操作的DAO

    //添加一条记录
    public void add(T t){

    }

    //删除一条记录
    public boolean remove(int index){

        return false;
    }

    //修改一条记录
    public void update(int index,T t){

    }

    //查询一条记录
    public T getIndex(int index){

        return null;
    }

    //查询多条记录
    public List<T> getForList(int index){

        return null;
    }

    //泛型方法：里面有不确定性，在加上看成是形参
    //举例：获取表中一共有多少条记录？获取最大的员工入职时间？
    public <E> E getValue(){

        return null;
    }

}

CustomerDAO类：

package com.atguigu.java;

/**
 * @author shkstart
 * @create 2019 上午 11:55
 */
public class CustomerDAO extends DAO<Customer>{//只能操作某一个表的DAO
}

Customer类：

package com.atguigu.java;


/**
 * @author shkstart
 * @create 2019 上午 11:54
 */
public class Customer { //此类对应数据库中的customers表
}

4.6 泛型在继承方面的体现

package com.atguigu.java1;

import com.atguigu.java.Person;
import org.junit.Test;

import java.util.AbstractList;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;


/**
 *
 * 1. 泛型在继承方面的体现
 *
 *
 * 2. 通配符的使用
 *
 * @author shkstart
 * @create 2019 下午 2:13
 */
public class GenericTest {

    /*
    1. 泛型在继承方面的体现

      虽然类A是类B的父类，但是G 和G二者不具备子父类关系，二者是并列关系。

       补充：类A是类B的父类，A 是 B 的父类

     */
    //情况一：虽然类A是类B的父类，但是G 和G二者不具备子父类关系，二者是并列关系。
    @Test
    public void test1(){
        //父子类，子类类型可以赋值给父类。
        Object obj = null;
        String str = null;
        obj = str;

        Object[] arr1 = null;
        String[] arr2 = null;
        arr1 = arr2;

        //编译不通过01
//        Date date = new Date();
//        str = date;

        List<Object> list1 = null;
        List<String> list2 = new ArrayList<String>();
        //此时的list1和list2的类型不具有子父类关系
        //编译不通过02，类似于01的写法，list1和list2里面的元素确实是父子类关系，但是list1和list2本身不是父子类关系 顶多是并列关系。
//        list1 = list2;
        /*
        反证法：假设list1 = list2;
               list1.add(123);导致混入非String的数据出错。

        解释反证法：list1 list2都是引用类型，list1 = list2相当于是 list1和list2都指向堆空间中的对象newArrayList，
              那么此时list1调用时也不会报空指针异常，在list1.add(123)添加数据时，由于list1是Object类型所以任何数据都能添加 ，
              list1添加integer类型的数据123 就相当于像lis2中添加123它们都指向ArrayList，而ArrayList又要求是String类型的
              所以报错。


         */

        show(list1);
        show1(list2);

    }



    public void show1(List<String> list){

    }

    public void show(List<Object> list){

    }
    //情况二：类A是类B的父类，A 是 B 的父类
    @Test
    public void test2(){

        AbstractList<String> list1 = null;
        List<String> list2 = null;
        ArrayList<String> list3 = null;

        list1 = list3;
        list2 = list3;

        List<String> list4 = new ArrayList<>();

    }

   

}

4.7 泛型通配符的使用

GenericTest类：
package com.atguigu.java1; import org.junit.Test; import java.util.ArrayList; import java.util.Iterator; import java.util.List; /** * * 1. 泛型在继承方面的体现 * * * 2. 通配符的使用 * * @author shkstart * @create 2019 下午 2:13 */ public class GenericTest { /* 2. 通配符的使用通配符：? 类A是类B的父类，G和G是没有关系的，二者共同的父类是：G */ @Test public void test3(){ //List