泛型技术

针对集合这个容器，它中可以存放任意对象，存过之后，对象会被转化成Object类型，因此之前想使用对象的特有功能时都会向下转型。现在我们使用java为我们提供的一个技术
泛型技术。

import java.util.ArrayList;
import java.util.Iterator;

public class FanXingDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        method();
    }

    private static void method() {
        // TODO Auto-generated method stub
        ArrayList<String> al=new ArrayList<String>();
        al.add("aa");
        al.add("aaa");
        al.add("aaaaaa");
        al.add("aaaa");
        for (Iterator<String> iterator = al.iterator(); iterator.hasNext();) {
            String s=iterator.next();
            System.out.println(s.length());
        }
    }

}

泛型技术的应用：

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

public class FanXingDemo {

    public static void main(String[] args) {
        TreeSet<String> ts = new TreeSet<String>(new Comparator<String>() {

            @Override
            public int compare(String s1, String s2) {
                // TODO Auto-generated method stub
                int temp = s1.length() - s2.length();
                return temp == 0 ? s1.compareTo(s2) : temp;
            }

        });
        ts.add("a");
        ts.add("aaaaa");
        ts.add("AAAAA");
        ts.add("ccccc");
        ts.add("CCCCC");
        for (Iterator<String> iterator = ts.iterator(); iterator.hasNext();) {
            String s = iterator.next();
            System.out.println(s);
        }
    }

}

泛型类：

在查看api中有许多接口后面写了泛型，那么我们也可以自定义泛型类。
不知道有没有忘记，在学习面向对象时，私有了一大堆数据，之后还要根据每一个数据复写set ，get方法，这样就造成了代码的大量重复。通过泛型类我们可以解决这个问题。当我们创建对象时就给它设置对象类型。

class Demo<LS> {
    private LS value;

    public LS getValue() {
        return value;
    }

    public void setValue(LS value) {
        this.value = value;
    }
}

public class FanXingDemo {
    public static void main(String[] args) {
        Demo<String> d1 = new Demo<String>();
        d1.setValue("lishuai");
        System.out.println(d1.getValue());
        Demo<Integer> d2 = new Demo<Integer>();
        d2.setValue(22);
        System.out.println(d2.getValue());
    }

}

泛型方法：

当方法中想换一个泛型的时候，我们可以在返回类型前加一个泛型。

class Demo<LS> {
    public void print(LS ls){
        System.out.println(ls);
    }
    public <LE>void println(LE le){
        System.out.println(le);
    }
}

public class FanXingDemo {
    public static void main(String[] args) {
        Demo<String> d1 = new Demo<String>();
        d1.print("aaa");
    }

}

泛型接口：

我们可以在接口上添加泛型，如果实现此接口的类明确泛型类型，那就明确，如果不知道类型的话就将泛型进行传递，让调用者明确。

interface inter<W>{
    public void show(W w);
}
class Demo<W> implements inter<W>{

    @Override
    public void show(W w) {
        // TODO Auto-generated method stub
        
    }
    
}

public class FanXingDemo {
    public static void main(String[] args) {
        Demo<String> d=new Demo<String>();
        d.show("aaaa");
    }
    
}

泛型的通配符？，当无法确定类型的时候可以直接敲个？代替。？extends类，？super类，这是泛型到上下转型。