JavaSE基础自学-------集合框架--泛型

泛型

泛型:JDK1.5 版本以后出现的新特性,用于解决安全问题,是一个安全机制

好处:

• 将运行时期出现的问题:ClassCastException,转移到的编译时期 方便程序员更早就发现解决问题,让运行时期问题减少
• 避免了向下转型的麻烦

泛型的格式:通过< …>定义要操作的数据类型

泛型在集合框架中很常见
一般的 , 集合 , Iterator(迭代器) , Comparator(比较器) , Comparable 都可以使用泛型< >
注:equals是Object类的,所以不能使用泛型,还是需要进行类型转换

代码演示-----

import java.util.*;  //导入集合类包
//按字符串长度排序
class MyCompare implements Comparator<String> { //明确比较器元素存放类型
    public int compare(String s1, String s2) {
    
        int num = new Integer(s2.length()).compareTo(s1.length());
        if (num == 0) {
            return s2.compareTo(s1);
        }
        return num;
    }
}

public class DEMO {

    public static void main(String[] args) {
        TreeSet<String> al = new TreeSet <String> (new MyCompare());  //明确了集合元素的类型

        al.add("faa");
        al.add("acaadd");
        al.add("cfdd");
        al.add("cddd");
        al.add("abaaaaaaa");

        Iterator<String> it = al.iterator();  //明确了迭代器存放元素的类型

        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }
    }
}

---

泛型类/泛型方法/泛型限定

当类中要操作的引用数据类型不确定的时候,可以使用泛型< *** >,由使用者确定引用数据类型
早期是定义Object来完成扩展,因此需要转换类型,向下转型
现在是自定义泛型来完成扩展,不需要转型;

注:如果使用者没有确定引用数据类型,则默认Object 类型

泛型限定

• ? extends E : 可以接受E类型或者E的子类型. 上限
• ? super E : 可以接受E类型或者E的父类型. 下限

---

泛型限定代码演示1

class Person{
    private String name;

    Person(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }
}

class Student extends Person {
    Student(String name){
        super(name);
    }
}

class MyComp implements Comparator<Person>{    //? super Studengt...可以接收Student类型,也可以接收它的父类型Person
    public int compare(Person o1,Person o2){
        return o1.getName().compareTo(o2.getName());
    }
}

public class DEMO {

    public static void main(String[] args) {
        TreeSet<Person> al = new TreeSet<Person>(new MyComp());
        al.add(new Person("d张三"));
        al.add(new Person("a李四"));
        al.add(new Person("b王五"));
        It(al);

        TreeSet<Student> al2 = new TreeSet<Student>(new MyComp());
        al2.add(new Student("c狗蛋"));
        al2.add(new Student("a狗剩"));
        al2.add(new Student("g土蛋"));
        It(al2);

    }
    public static void It(TreeSet<? extends Person> a){  // ? extends Person  可以接收Person类型和它的子类Student类型

        Iterator<? extends Person> it=a.iterator();

        while (it.hasNext()){

            System.out.println(it.next().getName());
        }
    }
}

---

泛型类代码演示2

class Worker{}
class Student{}

//定义一个工具类,通过此类来处理对象和获取对象
class Tool<TT>{  //引用类型的不确定,使用泛型TT表示
    private TT q;
    public void setObject(TT q){  //设置对象
        this.q=q;
    }
    public TT getObject(){   //获取对象 
        return q;
    }
}

//没有泛型前的做法
class Tool1{
    private Object obj;
    public void setObj(Object obj){
        this.obj=obj;
    }
    public Object getObj(){
        return obj;
    }
}

public class DEMO {
    public static void main(String[] args) {
        //使用泛型
        Tool<Worker> t1=new Tool<Worker>();  //定义了Woker数据类型
        t1.setObject(new Worker());
        Worker w1=t1.getObject();   //数据类型不需要转型.

   

---

泛型方法代码演示3

注:静态方法无法访问类上定义的泛型

class Text<T> {
    public void show(T t) {    //该方法的数据类型是根据类如何定义数据类型
        System.out.println(t);
    }

    public <P> void show1(P p) {  //该方法定义了泛型,和类的泛型没关系
        System.out.println(p);
    }
     public static <C> void show2(C c){  //静态方法定义泛型,
        System.out.println(c);           
    }
}

public class DEMO {
    public static void main(String[] args) {
        Text<String> t = new Text<String>();
        t.show("String");         //类定义了String类型,该方法也只能输入String类型引用数据

        t.show1(5555);            //该方法定义了自身泛型,可以输入任意类型引用数据
        t.show1("sss");

---

接口定义泛型

interface  Inter<T>{         //定义了泛型接口,未知类型由T表示

    public void show(T t);   //该方法的数据类型未定
}

class Text implements Inter<String>{   //继承了泛型接口,并定义了String数据类型,

    public void show(String t){
        
    }
}

class Text1<T> implements Inter<T>{    //继承了泛型接口,但是还未确定所操作的数据类型,继续使用泛型
    public void show(T t){

    }
}

---