java泛型

泛型:JDK1.5版本以后出现新特性,用于解决安全问题,是一个安全机制.

升级3部 高效 简化书写 安全

好处:

1将运行时期出现问题ClassCastException类型转换异常，转移到了编译时期.方便程序员解决问题,让运行事情问题减少,安全.

2.避免了强制转换麻烦.

在使用java提供的对象时,什么时候写泛型呢?

通常在集合框架中很常见,只要见到<>就要定义泛型.

其实<>就是用来接收类型的.

什么时候定义泛型类?

 

当类中要操作的引用数据类型不确定的时候.

为了让不同方法可以操作不同类型,而且类型还部确定

那么可以将泛型在方法上

特殊之处:

静态方法不可以访问类上定义的泛型.

如果静态方法操作的应用数据类型不确定.可以将泛型定义在方法上.

泛型的位置也有将就

Public static <QQ> getfanxing(){} 位置错了也会报错.

可以既有泛型类,也有泛型方法

 

泛型定义在方法上事例

package pack;

import java.util.ArrayList;
import java.util.Collection;

public class Demo{
	public static void main(String[] args) {
		
	}
	
	//泛型定义在方法上,返回值和参数都是泛型
	public static <T> T show(ArrayList<T> al){
		
		return null;
	}
	
	//泛型定义在方法上,
	public static <T> void show(Collection<T> al){
		
	}
}

　　

泛型定义在类上事例

package pack;

import java.util.ArrayList;
import java.util.Collection;

public class Demo<T>{
	T a;
	
	
}

class Gen<T>{
	T a;
	public Gen(T obj){
		
	}
	
	public void Get(T t){
		
	}
	
	public T getObj(){
		return null;
	}
}

　　

 

泛型的限定:

 

? 通配符,也可理解为占位符

 

泛型的限定:

 

? extends E:可以接收E类型或者E的子类型.上限. 既能接收E 也能接收E的子类型 

 

?super E:可以接收E类型或者E的父类型.下限.

 

 

 

?	通配符,也可理解为占位符
泛型的限定:

public static void printToll(ArrayList<?> al)    //泛型通配符.?
{
    Iterator<?> it = al.iterator();
    while(it.hasNext())
    {
        System.out.println(it.next());
    }
}

 

泛型限定使用

package pack;

import java.util.*;

public class Demo
{ 
    public static void main(String args[])
    {
        TreeSet<Student> t1 = new TreeSet<Student>(new Comp());
        t1.add(new Student("abc03"));
        t1.add(new Student("abc04"));
        t1.add(new Student("abc01"));
        print(t1);

        TreeSet<Worker> t2 = new TreeSet<Worker>(new Comp());
        t2.add(new Worker("ab08"));
        t2.add(new Worker("ab03"));
        t2.add(new Worker("ab07"));
        print(t2);

    }

    public static void print(TreeSet<? extends Person> t)
    {
        Iterator<? extends Person> it = t.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next().getName());
        }
    }

}

class Person
{
    private String name;
    Person(String name)
    {
        this.name = name;
    }
    public String getName()
    {
        return name;
    }
}

class Student extends Person
{
    Student(String name)
    {
        super(name);
    }
}

class Worker extends Person
{
    Worker(String name)
    {
        super(name);
    }
}

/**
 * 这个比较器可以给Person 和Person子类使用
 */
class Comp implements Comparator<Person>
{
    public int compare(Person p1,Person p2)
    {
        return p2.getName().compareTo(p1.getName());
    }
}

 

泛型应用

class Demo
{
    public <T> void show(T t)
    {
        System.out.println("show:"+t);
    }
    public <Q> void print(Q q)
    {
        System.out.println("print:"+q);
    }
}

public class GenericDemo4
{
    public static void main(String args[])
    {
        Demo d = new Demo();
        d.show("haha");
        d.show(new Integer(4));
        d.print("heihei");
    }
}

 

 

泛型应用2

package pack;

import java.util.*;

public class xiandingDemoTwo {
    public static void main(String args[]) {
        // InterOne i = new InterOne();
        // i.show("haha");

        InterTwo<Integer> i = new InterTwo<Integer>();
        i.show(4);
    }
}

interface Inter<T> {
    void show(T t);
}

class InterOne implements Inter<String> {
    public void show(String t) {
        System.out.println("show:" + t);
    }
}

//如果T没被替换成对象,那么T还是写T.   T也可以写成上面一样
class InterTwo<T> implements Inter<T> {
    public void show(T t) {
        System.out.println("show:" + t);
    }
}

泛型应用3

package pack;
class Worker
{
}

class Student
{
}


//泛型前做法
class Tool
{
    private Object obj;
    public void setObject(Object obj)
    {
        this.obj = obj;
    }
    public Object getObject()
    {
        return obj;
    }
}


//泛型类
class Utils<QQ>
{
    private QQ q;
    public void setObject(QQ q)
    {
        this.q = q;
    }
    public QQ getObject()
    {
        return q;
    }
}


public class Demo
{
    public static void main(String args[])
    {
    /*    Tool t = new Tool();
        t.setObject(new Student());    //出现类型转换异常
        Worker w = (Worker)t.getObject();
    */
        
        Utils<Worker> u = new Utils<Worker>();
        u.setObject(new Worker());
        Worker w = u.getObject(); 
    }
}

 

泛型应用3

package pack;
/**
 * 泛型类,泛型方法,3种泛型重合
 */

class Demo<T>
{
    public void show(T t)
    {
        System.out.println("show:"+t);
    }
    public <Q> void print(Q q)
    {
        System.out.println("method:"+q);
    }
    public static <W> void method(W w)// 这里<w>一定要房子啊static后面 void前面
    {
        System.out.println("method:"+w);
    }
}

public class GenericDemo5
{
    public static void main(String args[])
    {
        Demo<String> d = new Demo<String>();
        d.show("haha");
        d.print(4);
        d.print("hehe");
        d.method("hahahaha");
    }
}

 

 通配符的应用

package pack;

import java.util.*;

public class xiandingDemo
{
    public static void main(String args[])
    {
        ArrayList<String> al = new ArrayList<String>();
        al.add("abc1");
        al.add("abc2");
        al.add("abc3");
        
        ArrayList<Integer> al1 = new ArrayList<Integer>();
        al1.add(5);
        al1.add(2);
        al1.add(6);
        
        printColl1(al);
        printColl2(al1);
    }

    public static void printColl1(ArrayList<?> al)
    {
        Iterator<?> it = al.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
    }
    
//    printColl1和printColl2的区别是?代表未知 是占位符 T是具体的类型
    
    public static <T> void printColl2(ArrayList<T> al)
    {
        Iterator<T> it = al.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
    }
}