泛型

一、泛型产生的原因

①、最主要的目的就是创造容器。

举例：只能持有一个对象的类

public class Holder{
   private Auto mAuto;
  public Holder(Auto auto){
       mAuto = auto;
  }

  public Auto getAuto(){
    return mAuto;
  }
}

这个类只能持有Auto类型的对象，而不能持有其他类型的对象。缺点：如果想持有其他类型的对象，就需要重新在创建一个。

在没有泛型的解决方法：就是将Auto转换成Object，这样其他对象就可以使用了

缺点：但是Object类说明，什么样的类都可进入容器，但是一般我们只需要存储一种类型，而不是各种各样的类型都可以放进容器中。

所以：泛型的主要作用是，确定容器要持有什么对象，然后通过编译器保证类型的正确性。

举例：

public class SimpeHolder<T> {
    
    private T base;
    
    public void setBase(T base) {
        this.base = base;
    }

    public T getBase() {
        return base;
    }
    
    public static void main(String[]args){
        //说明如果不添加泛型，T就被当成Object
        SimpeHolder simple = new SimpeHolder();
        simple.setBase(new Mocha());
        Object object = simple.getBase();
        //添加泛型的使用
        SimpeHolder<Mocha> mocha = new SimpeHolder<Mocha>();
        mocha.setBase(new Mocha());
        Mocha mo = mocha.getBase();
    }
}

小知识：①、静态类型无法使用泛型   ②、不指定泛型，T代表Object

二、元组

产生的原因：以此方法调用能够返回许多个对象。可是return只能返回一个对象

解决方法：创建一个对象，持有想返回的多个对象。（这就是元组）

特性：这个对象允许读取元素，但不能够允许添加或者修改元素。

举例：

public class TwoTuple<BasicClass,BasicClass1>{
    //① 为什么用public final 而不使用private 加上get()方法
    public final BasicClass base1;
    public final BasicClass1 base2;
    public TwoTuple(BasicClass a,BasicClass1 b){
        base1 = a;
        base2 = b;
    }
}

知识：①、根据功能出发，我们声明private然后提供get()方法，不如使用final，因为final提供了同样的安全性。相比而言优点更加简洁明了。

注意：元组的顺序是根据泛型的顺序确定的。

三、通用的堆栈类

public class ListStack<T> {
    public static class Node<T>{
        public T item;
        public Node next;
        //结合isEnd() 初始化Node为null，然后当到达尾部的时候，就是到达初始化Node，如果为null则表示到达尾部。
        public Node(){
            this.item = null;
            this.next = null;
        }
        public Node(T item,Node next){
            this.item = item;
            this.next = next;
        }
        public boolean isEnd(){
            return item == null && next == null;
        }
    }
    //初始化一个Node，不传值，用来进行是否达到队列尾部的判断
    private Node<T> top = new Node();
    public void push(T item){
        //创建node，并放入顶部
        Node node = new Node(item,top);
        top = node;
    }
    //获取栈顶 
    public T pop(){
        if (!top.isEnd()){
            T item = top.item;
            top = top.next;
            return item;
        }
        return null;
    }
    //返回true代表成功，返回false代表失败
    public boolean remove(){
        if (!top.isEnd()){
            Node oldTop = top;
            top = top.next;
            oldTop.next = null;
            return true;
        }
        return false;
    }
    
    public static void main(String[]args){
        ListStack<BasicClass> stack = new ListStack();
        for(int i=0; i<3; ++i){
            BasicClass item = new BasicClass();
            stack.push(item);
        }
        for(int i=0; i<5; ++i){
            BasicClass data = stack.pop();
            if (data != null)
            System.out.println(data);
        }
    }
}

技巧：明白栈的主要方法：入栈和出栈  ②、明白结构体的作用  ③、判定是否到达栈底

四、泛型接口（生成器、适配器）

作用：专门负责生成新的对象。 

与工厂方法的比较：工厂方法一般需要参数  但是  生成器不需要参数。

举例：

新建：多个元素 继承Coffee  比如：Macha,Cappuccio,Breve

新建：生成器Generator<T>

public interface Generator<T> {
    T next();
}

利用生成器产生随机的Coffee类

public class CoffeeGenerator implements Generator<Coffee>,Iterable<Coffee>{
    //当使用Iterator的时候，进行判定的
    private int size;
    
    private Class [] objects = {Breve.class,Cappuccino.class,Mocha.class};
    //用普通方法生成对象
    public CoffeeGenerator(){}
    //用构造器生成对象
    public CoffeeGenerator(int size){
        this.size = size;
    }
    //生成器
    @Override
    public Coffee next() {
        // TODO Auto-generated method stub
        try {
            return (Coffee)objects[new Random().nextInt(objects.length)].
                    newInstance();
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }
    //定制迭代器
    class CoffeeIterator implements Iterator<Coffee>{
        @Override
        public boolean hasNext() {
            size = size-1;
            return size>0;
        }
        @Override
        public Coffee next() {
            // TODO Auto-generated method stub
            return CoffeeGenerator.this.next();
        }
        
    }
    @Override
    public Iterator<Coffee> iterator() {
        // TODO Auto-generated method stub
        return new CoffeeIterator();
    }
    
    public static void main(String[]args){
        
        //未使用迭代器
        CoffeeGenerator coffee = new CoffeeGenerator();
        for(int i=0; i<5; ++i){
            System.out.println(coffee.next());
        }
    System.out.println("-------------------------------------");
        //使用迭代器
        for(Coffee cof:new CoffeeGenerator(6)){
            System.out.println(cof);
        }
    }
}

这里用到了迭代器：如何创建迭代器（复习知识）  迭代器也是使用到了泛型，因为要迭代的容器肯定是某一类，而不可能是多种类

让CoffeeGenerator继承 Iterable<>接口：只有声明为Iterable才能使用迭代器。

之后创建Iterator<>迭代器，创建类，继承Iterator接口，并实现

之后将新建的Iterator对象交给Iterable<>  

foreach循环能够执行继承Iterable接口的类

适配器

假设现在有：sequence这个类，这个类的作用是随机创建一个数字
举例：

public class RandomSequence {
    private int data;
    private Random mRandom;
    public RandomSequence(){
        mRandom = new Random();
    }
    public Integer getData(){
        return mRandom.nextInt(100);
    }
    
    public static void main(String[]args){
        RandomSequence random = new RandomSequence();
        for (int i=0; i<50; ++i){
            System.out.println(random.getData());
        }
    }
}

现在想通过利用foreach循环来创建数字。

但是foreach循环需要是Iterable接口才能使用。

所以为能够使用foreach循环，需要一个接口能够相互转换将Sequence类转换成Iterator类(或者说小明充电，他是苹果机(Squence)，现在只有一条android数据线，所以需要一个能够连接android线的苹果插口，能够连接充电宝（foreach）)

新建IteratorSequence类 继承Iterabe接口（苹果连接android插口）提供了转化的工具

ublic class IteratorSquence extends RandomSequence implements Iterable<Integer> {
    private int mCount = 0;
    public IteratorSquence(int count){
        mCount = count;
    }
    
    class Squence implements Iterator<Integer>{
        @Override
        public boolean hasNext() {
            // TODO Auto-generated method stub
            return mCount>0;
        }

        @Override
        public Integer next() {
            mCount = mCount + 1;
            // TODO Auto-generated method stub
            return IteratorSquence.this.getData();
        }
        
    }
    public static void main(String[]args){
        for(int data : new IteratorSquence(18)){
            System.out.println(data);
        }
    }
    @Override
    public Iterator<Integer> iterator() {
        // TODO Auto-generated method stub
        return new Squence();
    }
}

这就是适配器模式：将一个类，通过适配，能够被另一个类使用。

泛型：Iterable接口使用了泛型，使其能够通用。

五、泛型方法（之前谈论的都是在类上加上泛型）

使用：在返回值前添加泛型参数

举例：

public class GenericMethods {
    //在返回值前面添加参数
    public <T> void f(T data){
        System.out.println(data.getClass().getSimpleName());
    }

    public static void main(String[] args){
        GenericMethods methods = new GenericMethods();
        methods.f("");
        methods.f(12);
    }
}

特性：参数推断（编译器会为我们找出具体值）

参数推断的作用：

现在我们有Map<String,List<String>> map = new Map<String,List<String>>();这样写的方式太长了

所以利用参数推断：

public class ConcludeElements {
    public static <T,V> Map<T,V> map(){
        return new HashMap<T,V>();
    }
    
    public static void main(String[]args){
        //map()的返回值类型由前面的类型参数确定   （编译器自动进行参数推断）
        Map<String,List<String>> map = ConcludeElements.map();
    
    }
}

这样可以减少重复的泛型参数列表：

这还可以用在强制转换上，如果有个方法返回的是Object类型，需要强制转换成其他类型的类的时候，就可以很好的使用到。

比如说android的findViewById():

public class ConcludeElements {
    public <VT extends View> VT getViewById(int data){
        return (VT)findViewById(data);
    }
    
    public static void main(String[]args){
        Button btn = getViewById(R.id.main_btn);
    }
}

注意：但是类型参数推断只对赋值有效（因为推断是根据前面的参数决定的，只有赋值才有前面的参数列表）

如果直接使用方法，则参数推断的就是Object类

可变参数与泛型方法