泛型集合和泛型类，方法，高级特征详解

package com.list.demo.entity;

public class Student implements Comparable<Student> {
    
    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<Integer> list = new ArrayList<Integer>();
        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<Student> studentSet = new HashSet<Student>();
        studentSet.add(new Student());
        studentSet.add(new Student());
        
        System.out.println(studentSet);
        
        ////////////// Map /////////////////
        Map<String,Student> stuMap = new HashMap<String,Student>();
        stuMap.put("1001", new Student());
        stuMap.put("1002", new Student());
        stuMap.put("1003", new Student());
        stuMap.put("1004", new Student());
        
        
        for (Map.Entry<String, Student> entry : stuMap.entrySet()) {
            String key = entry.getKey();
            Student value = entry.getValue();
            System.out.println(key+"----"+value);
        }
        System.out.println("---------------------------------");
        
        
        // 局部内部类
        class MyComparator implements Comparator<String> {

            @Override
            public int compare(String o1, String o2) {
                return -o2.hashCode() + o1.hashCode();
            }
            
        }
        
        ///////////////////// 排序的Map->对象key进行排序 ///////////////
        // Map<String,Student> treeMap = new TreeMap<>(new MyComparator());
        Map<String,Student> treeMap = new TreeMap<>(new Comparator<String>() {

            @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<String, Student> 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<T> {
    void add(T t);
}

package com.generic.demo;

/**
 * 
 * @author Administrator
 *
 */
public class GenericClass implements GenericInterface<Teacher> {
    public static void main(String[] args) {
        BaseDAO<Student> dao = new BaseDAO<Student>();
        dao.add(new Student());
        
        BaseDAO<Book> bookDao = new BaseDAO<Book>();
        bookDao.add(new Book());
        
        BaseDAO<Teacher> teaDao = new BaseDAO<Teacher>();
        teaDao.add(new Teacher());
        // 调用泛型方法
        String row = teaDao.get(11F, "AAA");
        String row1 = teaDao.<Double, String, Student>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<T> {
    void add(T t) {
        System.out.println("我添加了:"+t);
    }
    
    /**
     * 泛型方法
     * @param e
     * @return
     * <E> 声明泛型类型
     */
    public <E,X,K> 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 extends IBaseDAO> T泛型类绑定了一个范围
    // 可变参数数组: 要求只能放在参数列表中的最后一个位置
    public static <T extends IBaseDAO> 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 <T extends Animal> void printSingle(T t) {
        System.out.println(t);
    }
    
    // 绑定了多个类型： 绑定类必须为Animal及其子类,还必须实现Serializable
    public static <T extends Animal&Serializable> 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<Integer>(222, 33);
        point = new Point<Integer>(111, 11);
        point = new Point<Double>(33D, 33D);
        point = new Point<String>("111", "AAAA");
        
        // ? extends限定上限: 能读但是不能存 （找本身及其子类）
        Point<? extends Number> p = new Point<Long>(11L,33L);
        p = new Point<Float>(11.1F,33.2F);
        p = new Point<Integer>(11,33);
        p = new Point<Number>(11,23);
        // p = new Point<String>("111","22"); String 不是Number子类
        System.out.println(p.getX());
        // p.setX(new Long(1));
        
        //? super 限定下限 找本身及父类
        List<? super Manager> list = new ArrayList<Employee>(); 
        
        /**
         * 通配符？总结
         ? extends 和 t ? super 通配符的特征，我们可以得出以下结论：
          ◆ 如果你想从一个数据类型里获取数据，使用 ? extends 通配符（能取不能存）
          ◆ 如果你想把对象写入一个数据结构里，使用 ? super 通配符
          ◆ 如果你既想存，又想取，那就别用通配符
         */
        
        
    }
}

class Point<X> {
    
    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 {  
}