JDK5.0新特性-泛型

泛型(重点)
什么是泛型？
对数据类型进行一个限定.
应用最多的地方是集合。
为什么要使用泛型?
1.提高我们程序安全性.
2.将运行阶段的问题在编译阶段解决.
3.不用进行类型强制转换
-----------------------------------------------
我们学习泛型的目的:会使用集合上定义的泛型。

1.集合上泛型的基本使用.
//Collection<E>
//List<E>
//Set<E>
//它们的作用是限定集合中元素的类型.

我们可不可以自己在类上或接口上定义泛型?
可以。怎样定义?

class 类名<T>{

}
在类上声明的泛型怎样使用?
类的成员:成员属性---成员方法.
成员属性:类属性(static) 实例属性(非static)---我们管实例属性就叫成员属性.
成员方法:类方法 实例方法(成员方法)

类上声明的泛型 可以应用于成员方法或成员属性上。


在类上声明的泛型不能在类的静态成员上使用?
原因:是类上声明的泛型，只有在创建对象进才能进行类型传递。
而静态成员是不需要对象就可以调用。


我们可不可以在静态的方法上声明泛型？

可以
格式
修饰符 <泛型> 返回值 方法名(){}


泛型是应用于设计阶段.

-----------------------------------------------------------------------------
在集合上应用泛型高级
通配符. ?

关于?在集合中的应用.
1. ? extends E
代表的是E类型或E的子类类型.

应用:在Collection接口中的addAll 方法
2. ? super E
代表的是E类型或E的父类类型.

应用:在TreeSet的构造方法上。

TreeSet集合:
它是一个可以排序的Set集合.

TreeSet集合怎样排序?
1.自然顺序
只要实现这个接口Comparable,就代表这个类型的元素具有自然顺序
2.比较器.
实现这个接口Comparator的类，可以根据指定条件进行比较。

指定比较器时，如果集合中的元素是按照父类中的属性进行比较，这时可以使用父类的比较顺.

------------------------------------------------------------------
泛型擦除机制

笔试题:List<String> list=new ArrayList<String>().要求向集合中添加一个Integer数值10

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

// list.add(10);

List a = list;
a.add(10);

System.out.println(list);

上面操作，在笔试中不要使用，而要使用反射完成.

泛型在编译阶段有效，在运行阶段无效果。

package cn.itcast.generic;

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

import org.junit.Test;

public class Demo {

    @Test
    public void fun1() {

        //show("abc"); // 这时show方法上的T描述的就是String

        //show(10); // 这时show方法上的T描述的就是Intger
    }

    // 定义两个方法.
    // public void show(String s) {
    // System.out.println(s);
    // }
    //
    // public void show(int i) {
    // System.out.println(i);
    // }

    // public <T> void show(T t) {
    //
    // System.out.println(t);
    // }

    // public void show(Object obj) { //
    // 使用Object来描述我们的信息，类型模糊.在使用时，还需要进行手动转型.------ClassCastException
    // // 类型转换异常
    // System.out.println(obj);
    // }

    // 泛型应用最多的地方---集合.
    @Test
    public void fun2() {
        // Collection<E>
        // List<E>
        // Set<E>
        // 它们的作用是限定集合中元素的类型.

        List<String> list = new ArrayList<String>();
        list.add("abc");

    }

    // 在类上声明泛型使用
    @Test
    public void fun3() {
        GenericDemo1<String> d = new GenericDemo1<String>();

        // 在GenericDemo1类中的t属性它的类型是String print方法的参数与返回值也是String。

    }

    // 做一个方法，它可以将集合中的所有元素打印.
    public void show(List<?> list) {

        System.out.println(list);
    }

    @Test
    public void fun4() {
        List<String> list = new ArrayList<String>();
        list.add("a");
        list.add("b");
        list.add("c");
        
        List<Integer> list1 = new ArrayList<Integer>();
        list1.add(1);
        list1.add(2);
        list1.add(3);
        
        show(list);
        show(list1);

    }
}

package cn.itcast.generic;

public class GenericDemo1<T> { // 类上声明一个泛型

    // 成员属性
    T t;

    // 成员方法-----返回值上应用 参数
    public T print(T s) {
        return s;
    }
    
    //可不可以在静态成员上使用.
    
    //static T tt;

    // public static T show(){
    // return null;
    // }
    
    
    //在方法上定义泛型.  定义泛型
    public  <K> K show(K k){
        return k;
    }
}

泛型擦除

package cn.itcast.generic;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.TreeSet;

import org.junit.Test;

public class Demo1 {

    // ? extends E
    @Test
    public void fun1() {

        List<Integer> list1 = new ArrayList<Integer>();
        list1.add(1);
        list1.add(2);
        list1.add(3);
        List<Double> list2 = new ArrayList<Double>();
        list2.add(1.0);
        list2.add(2.0);
        list2.add(3.0);

        // List<String> l=new ArrayList<String>();

        List<Number> list = new ArrayList<Number>();

        list.addAll(list1); // addAll(Collection<? extends E> c); E代表的是Number
        list.addAll(list2);
        // list.add(l);

        System.out.println(list);

        // 理解 Integer Double与Number的关系
    }

    // TreeSet集合应用
    // 要求：学生的按照年龄排序输出.---指定比较器
    @Test
    public void fun2() {

        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge() - o2.getAge();
            }
        }); // TreeSet集合中的元素必须有顺序.
        ts.add(new Student(1, "tom", 20));
        ts.add(new Student(4, "fox", 23));
        ts.add(new Student(2, "tony", 15));

        System.out.println(ts);
    }

    @Test
    public void fun3() {

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

        // list.add(10);

        List a = list;
        a.add(10);

        System.out.println(list);
    }

}

class Person {
    public String name;
    public int age;

    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;
    }

}

// Student类的自然顺序就是按照id排序.
class Student extends Person implements Comparable<Student> {
    private int id;

    public Student(int id, String name, int age) {
        super();
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    @Override
    public int compareTo(Student o) {

        // return this.age-o.age;
        return this.id - o.id;
    }

    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
    }

}