泛型

• 不使用泛型
  不使用泛型带来的问题
  ADHero（物理攻击英雄） APHero（魔法攻击英雄）都是Hero的子类
  ArrayList 默认接受Object类型的对象，所以所有对象都可以放进ArrayList中
  所以get(0) 返回的类型是Object
  接着，需要进行强制转换才可以得到APHero类型或者ADHero类型。
  如果软件开发人员记忆比较好，能记得哪个是哪个，还是可以的。 但是开发人员会犯错误，比如第20行，会记错，把第0个对象转换为ADHero,这样就会出现类型转换异常
  

  package generic;
   
  import java.util.ArrayList;
   
  import charactor.ADHero;
  import charactor.APHero;
   
  public class TestGeneric {
   
      public static void main(String[] args) {
           
          ArrayList heros = new ArrayList();
           
          heros.add(new APHero());
          heros.add(new ADHero());
           
          APHero apHero =  (APHero) heros.get(0);
          ADHero adHero =  (ADHero) heros.get(1);
           
          ADHero adHero2 =  (ADHero) heros.get(0);
      }
  }

• 使用泛型
  使用泛型的好处：
  泛型的用法是在容器后面添加<Type>
  Type可以是类，抽象类，接口
  泛型表示这种容器，只能存放APHero，ADHero就放不进去了。
  

  package generic;
   
  import java.util.ArrayList;
   
  import charactor.APHero;
   
  public class TestGeneric {
   
      public static void main(String[] args) {
          ArrayList<APHero> heros = new ArrayList<APHero>();
           
          //只有APHero可以放进去    
          heros.add(new APHero());
           
          //ADHero甚至放不进去
          //heros.add(new ADHero());
           
          //获取的时候也不需要进行转型，因为取出来一定是APHero
          APHero apHero =  heros.get(0);
           
      }
  }

• 子类对象
  假设容器的泛型是Hero,那么Hero的子类APHero,ADHero都可以放进去 
  和Hero无关的类型Item还是放不进去
  

  package generic;
   
  import java.util.ArrayList;
   
  import property.Item;
   
  import charactor.ADHero;
  import charactor.APHero;
  import charactor.Hero;
   
  public class TestGeneric {
   
      public static void main(String[] args) {
          ArrayList<Hero> heros = new ArrayList<Hero>();
           
          //只有作为Hero的子类可以放进去     
          heros.add(new APHero());
          heros.add(new ADHero());
           
          //和Hero无关的类型Item还是放不进去
          //heros.add(new Item());
           
      }
  }

• 泛型的简写
  为了不使编译器出现警告，需要前后都使用泛型，像这样：
   
  ArrayList<Hero> heros = new ArrayList<Hero>();
   
  
  
  不过JDK7提供了一个可以略微减少代码量的泛型简写方式
   
  ArrayList<Hero> heros2 = new ArrayList<>();
   
  
  
  后面的泛型可以用<>来代替，聊胜于无吧
  

  package generic;
    
  import java.util.ArrayList;
   
  import charactor.Hero;
    
  public class TestGeneric {
    
      public static void main(String[] args) {
          ArrayList<Hero> heros = new ArrayList<Hero>();
          //后面可以只用<>
          ArrayList<Hero> heros2 = new ArrayList<>();
           
      }
  }

• JAVA 如何设计支持泛型的类
  不支持泛型的Stack
  以Stack栈为例子，如果不使用泛型
  当需要一个只能放Hero的栈的时候，就需要设计一个HeroStack
  当需要一个只能放Item的栈的时候，就需要一个ItemStack
  

  package generic;
     
  import java.util.LinkedList;
   
  import charactor.Hero;
     
  public class HeroStack {
     
      LinkedList<Hero> heros = new LinkedList<Hero>();
         
      public void push(Hero h) {
          heros.addLast(h);
      }
     
      public Hero pull() {
          return heros.removeLast();
      }
     
      public Hero peek() {
          return heros.getLast();
      }
         
      public static void main(String[] args) {
             
          HeroStack heroStack = new HeroStack();
          for (int i = 0; i < 5; i++) {
              Hero h = new Hero("hero name " + i);
              System.out.println("压入 hero:" + h);
              heroStack.push(h);
          }
          for (int i = 0; i < 5; i++) {
              Hero h =heroStack.pull();
              System.out.println("弹出 hero" + h);
          }
      }
     
  }

  package generic;
     
  import java.util.LinkedList;
   
  import property.Item;
     
  public class ItemStack {
     
      LinkedList<Item> Items = new LinkedList<Item>();
         
      public void push(Item h) {
          Items.addLast(h);
      }
     
      public Item pull() {
          return Items.removeLast();
      }
     
      public Item peek() {
          return Items.getLast();
      }
         
      public static void main(String[] args) {
             
          ItemStack ItemStack = new ItemStack();
          for (int i = 0; i < 5; i++) {
              Item item = new Item("Item name " + i);
              System.out.println("压入 Item:" + item);
              ItemStack.push(item);
          }
          for (int i = 0; i < 5; i++) {
              Item item =ItemStack.pull();
              System.out.println("弹出 Item" + item);
          }
      }
     
  }

• 支持泛型的Stack
  设计一个支持泛型的栈MyStack
  设计这个类的时候，在类的声明上，加上一个<T>，表示该类支持泛型。
  T是type的缩写，也可以使用任何其他的合法的变量，比如A,B,X都可以，但是一般约定成俗使用T，代表类型。
  

  package generic;
     
  import java.util.HashMap;
  import java.util.LinkedList;
   
  import charactor.Hero;
  import property.Item;
     
  public class MyStack<T> {
     
      LinkedList<T> values = new LinkedList<T>();
         
      public void push(T t) {
          values.addLast(t);
      }
     
      public T pull() {
          return values.removeLast();
      }
     
      public T peek() {
          return values.getLast();
      }
         
      public static void main(String[] args) {
          //在声明这个Stack的时候，使用泛型<Hero>就表示该Stack只能放Hero
          MyStack<Hero> heroStack = new MyStack<>();
          heroStack.push(new Hero());
          //不能放Item
          heroStack.push(new Item());
           
          //在声明这个Stack的时候，使用泛型<Item>就表示该Stack只能放Item
          MyStack<Item> itemStack = new MyStack<>();
          itemStack.push(new Item());
          //不能放Hero
          itemStack.push(new Hero());
      }
     
  }