package com.list.demo.entity;public class Student implements Comparable
     
       {        private Integer id;                public Integer getId() {        return id;    }    public void setId(Integer id) {        this.id = id;    }    public Student() {            }        public Student(int id) {        this.id = id;    }    @Override    public String toString() {        return "Student [id=" + id + "]";    }    @Override    public int compareTo(Student o) {        return this.getId() - o.getId();    }        }
     

 

package com.list.demo;import java.lang.reflect.Method;import java.util.ArrayList;import java.util.Comparator;import java.util.HashMap;import java.util.HashSet;import java.util.List;import java.util.Map;import java.util.Set;import java.util.TreeMap;import com.list.demo.entity.Student;public class ListDemo {        public static void main(String[] args) {        // 只能存储带String类的元素        // 数组： 基本数据类型和对象类都是可以的        // 集合: 元素必须是对象类型        // 泛型检测是编译阶段（类型擦除）        List
     
       list = new ArrayList
      
       ();        list.add(1111);        list.add(2222);        list.add(4444);                // 绕过编译检测        Class
        clazz = list.getClass();        try {            Method method = clazz.getDeclaredMethod("add", Object.class);            method.invoke(list, "aaa");        } catch (Exception e) {            e.printStackTrace();        }                System.out.println(list);                for (Object value : list) {            System.out.println(value);        }                        Set
       
         studentSet = new HashSet
        
         ();        studentSet.add(new Student());        studentSet.add(new Student());                System.out.println(studentSet);                // Map /        Map
         
           stuMap = new HashMap
          
           (); stuMap.put("1001", new Student()); stuMap.put("1002", new Student()); stuMap.put("1003", new Student()); stuMap.put("1004", new Student()); for (Map.Entry
           
             entry : stuMap.entrySet()) { String key = entry.getKey(); Student value = entry.getValue(); System.out.println(key+"----"+value); } System.out.println("---------------------------------"); // 局部内部类 class MyComparator implements Comparator
            
              { @Override public int compare(String o1, String o2) { return -o2.hashCode() + o1.hashCode(); } } / 排序的Map->对象key进行排序 /// // Map
             
               treeMap = new TreeMap<>(new MyComparator()); Map
              
                treeMap = new TreeMap<>(new Comparator
               
                () { @Override public int compare(String o1, String o2) { return -o2.hashCode() + o1.hashCode(); } }); treeMap.put("1001A", new Student(1001)); treeMap.put("1aAa", new Student(1002)); treeMap.put("AAA", new Student(1000)); treeMap.put("1004B", new Student(1003)); for (Map.Entry
                
                  entry : treeMap.entrySet()) { String key = entry.getKey(); Student value = entry.getValue(); System.out.println(key+"----"+value); } /** * */ Function fun = new Function() { @Override public void add() { System.out.println("调用了Add方法"); } }; fun.add(); } }interface Function { void add();}
                
               
              
             
            
           
          
         
        
       
      
     

泛型

package com.generic.demo;public interface GenericInterface
     
       {    void add(T t);}
     

 

package com.generic.demo;/** *  * @author Administrator * */public class GenericClass implements GenericInterface
     
       {    public static void main(String[] args) {        BaseDAO
      
        dao = new BaseDAO
       
        ();        dao.add(new Student());                BaseDAO
        
          bookDao = new BaseDAO
         
          ();        bookDao.add(new Book());                BaseDAO
          
            teaDao = new BaseDAO
           
            (); teaDao.add(new Teacher()); // 调用泛型方法 String row = teaDao.get(11F, "AAA"); String row1 = teaDao.
            
             get(11D, "AAA"); System.out.println(row); } @Override public void add(Teacher t) { // TODO Auto-generated method stub }}/** * 泛型类 * T 对象 * E 元素 * V value * K key */class BaseDAO
             
               { void add(T t) { System.out.println("我添加了:"+t); } /** * 泛型方法 * @param e * @return * 
              
                声明泛型类型 */ public 
               
                 X get(E e, X x) { System.out.println(e+"--"+x); return x; }}class Student { }class Teacher { }class Book { }
               
              
             
            
           
          
         
        
       
      
     

泛型绑定接口的测试

package com.generic.demo.supers.interfacess;public interface IBaseDAO {    void query();}class UserDAO implements IBaseDAO {    @Override    public void query() {        // TODO Auto-generated method stub            }    }class BookDAO implements IBaseDAO {    @Override    public void query() {        // TODO Auto-generated method stub            }    }class TeacherDAO implements IBaseDAO {    @Override    public void query() {        // TODO Auto-generated method stub            }    }class Student {    }

package com.generic.demo.supers.interfacess;/** * 泛型绑定接口的测试 * @author Administrator * */public class Genderic1 {    public static void main(String[] args) {        print(new UserDAO());        print(new BookDAO(),new TeacherDAO());        print(new IBaseDAO[]{
   new TeacherDAO(),new TeacherDAO(),new TeacherDAO(),new TeacherDAO()});        // print(new Student());  //Student 不是IBaseDao的实现类            }        // 
     
       T泛型类绑定了一个范围    // 可变参数数组: 要求只能放在参数列表中的最后一个位置    public static 
      
        void print(T... t) {        System.out.println(t.length);    }}
      
     

泛型绑定类的测试

package com.generic.demo.supers.types;import java.io.Serializable;public class Animal {}class Lion extends Animal {    }class Tiger extends Animal implements Serializable {    }class Mouse extends Animal implements Serializable {    }class Grass implements Serializable {    }

package com.generic.demo.supers.types;import java.io.Serializable;/** * 泛型绑定类的测试 * @author Administrator * */public class TestBindType {        public static void main(String[] args) {        printSingle(new Animal());        printSingle(new Tiger());        printMulti(new Tiger());        printMulti(new Mouse());        // printMulti(new Grass()); // Grass不是Animal子类                            }        // 绑定了类型： 绑定类必须为Animal及其子类    public static 
     
       void printSingle(T t) {        System.out.println(t);    }        // 绑定了多个类型： 绑定类必须为Animal及其子类,还必须实现Serializable    public static 
      
        void printMulti(T t) {        System.out.println(t);    }}
      
     

通配符

package com.generic.demo.supers.common;import java.util.ArrayList;import java.util.List;/** * 通配符 * ? 无边界 * ? extends 上边界 * ? super   下边界 （用的非常少） * @author Administrator * */public class TestCommon {    public static void main(String[] args) {        // ? 问号统配        Point
      point = new Point
     
      (222, 33);        point = new Point
      
       (111, 11);        point = new Point
       
        (33D, 33D);        point = new Point
        
         ("111", "AAAA");                // ? extends限定上限: 能读但是不能存 （找本身及其子类）        Point
          p = new Point
         
          (11L,33L);        p = new Point
          
           (11.1F,33.2F); p = new Point
           
            (11,33); p = new Point
            
             (11,23); // p = new Point
             
              ("111","22"); String 不是Number子类 System.out.println(p.getX()); // p.setX(new Long(1)); //? super 限定下限 找本身及父类 List
               list = new ArrayList
              
               (); /** * 通配符？总结 ? extends 和 t ? super 通配符的特征，我们可以得出以下结论： ◆ 如果你想从一个数据类型里获取数据，使用 ? extends 通配符（能取不能存） ◆ 如果你想把对象写入一个数据结构里，使用 ? super 通配符 ◆ 如果你既想存，又想取，那就别用通配符 */ }}class Point
               
                 { private X x; public X getX() { return x; } public void setX(X x) { this.x = x; } public Point(X x, X y) { this.x = x; }}class CEO extends Manager { } class Manager extends Employee { } class Employee { }