Java之泛型

痛定思痛。 2022-11-27 07:24 147阅读 0赞

### 文章目录 ###

*   *  泛型
     *  泛型类
     *  泛型方法
     *  泛型接口
     *  泛型限定
     *  注意——静态

## 泛型 ##

JDK1.5版本以后出现的新特性，用于解决安全问题，是一个安全机制  
**优点**

1.  将运行时期可能出现的问题（ClassCastException），转移到了编译时期，方便我们解决问题，让运行时期问题减少
2.  提高了程序的安全性
3.  避免了类型强制转换的麻烦
4.  优化了程序设计

**泛型格式**  
通过<>来定义操作的引用数据类型  
通常在集合框架中很常见  
其实<>就是用来接收类型的  
当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可

**泛型实例**  
实例1

import java.util.*;
    class GenericDemo{ 
    	public static void main(String[] args) { 
    		//Arraylist al = new Arraylist();
    		//提前声明
    		ArrayList<String> al = new ArrayList<String>();
    		al.add("aaa");
    		al.add("bbb");
    		//al.add(3);
    		Iterator<String> it = al.iterator();
    		while(it.hasNext()){ 
    			//String s = (String)it.next();
    			//避免了强转
    			String s = it.next();
    			System.out.println(it.next());
    		}
    	}
    }

实例2

import java.util.*;
    class GenericDemo2{ 
    	public static void main(String[] args) { 
    		TreeSet<String> ts = new TreeSet<String>(new LengthComp());
    		ts.add("aaa");
    		ts.add("bbbb");
    		ts.add("cc");
    		//ts.add(4);
    		Iterator<String> it = ts.iterator();
    		while(it.hasNext()){ 
    			System.out.println(it.next());
    		}
    	}
    }
    class LengthComp implements Comparator<String>
    { 
    	public int compare(String o1,String o2){ 
    		int num = new Integer(o1.length()).compareTo(o2.length());
    		if(num==0)
    			return o1.compareTo(o2);
    		return num;
    	}
    }

## 泛型类 ##

当类中要操作的引用数据类型不确定的时候，早起定义Object来处理，现在可以定义泛型类型来完成扩展  
泛型类定义的泛型，在整个类中有效。泛型类对象明确要操作的具体对象之后，所有操作的类型就已固定。  
**实例**

//泛型类
    class Utils<T>
    { 
    	private T t;
    	public void setObject(T t){ 
    		this.t = t;
    	}
    	public T getObject(){ 
    		return t;
    	}
    }
    class Worker{ 
    
    }
    class Student{ 
    
    }
    class GenericDemo3{ 
    	public static void main(String[] args) { 
    		Utils<Worker> u = new Utils<Worker>();
    		//如果传入的类型不是指定类型，则会提示类型冲突
    		//u.setObject(new Student());
    		u.setObject(new Worker());
    		Worker w = u.getObject();
    	}
    }

![在这里插入图片描述][20200814142820125.png_pic_center]

## 泛型方法 ##

为了让不同方法可以操作不同类型，而且类型还不确定，可以将泛型定义在方法上  
**实例**

//泛型方法
    class Util{ 
    	public <T> void show(T t){ 
    		System.out.println("show---"+t);
    	}
    	public <T> void print(T t){ 
    		System.out.println("print---"+t);
    	}
    }
    
    Util ul = new Util();
    String str = "aaa";
    ul.show(str);
    Integer num = 4;
    ul.print(num);

## 泛型接口 ##

interface Inter<T>{ 
    	void show(T t);
    }
    class InterImpl<T> implements Inter<T>{ 
    	public void show(T t){ }
    }
    InterImpl<String> it = new InterImpl<String>;

## 泛型限定 ##

用于扩展泛型

<?> 类型不确定，通配符，也可以理解为占位符
    <? extends E>可以接收E类型或者E的子类型，上限 
    <? super E>可以接收E类型或者E的父类型，下限

上限实例

import java.util.*;
    class GenericDemo5{ 
    	public static void main(String[] args) { 
    		ArrayList<Student> al = new ArrayList<Student>();
    		al.add(new Student("aaa"));
    		al.add(new Student("bbb"));
    		al.add(new Student("ccc"));
    		printCall(al);
    	}
    	public static void printCall(ArrayList<? extends Person> al){ 
    		Iterator<? extends Person> it = al.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 this.name;
    	}
    }
    class Student extends Person{ 
    	Student(String name){ 
    		super(name);
    	}
    }

父类泛型

import java.util.*;
    class GenericDemo4{ 
    	public static void main(String[] args) { 
    		TreeSet<Person> ts = new TreeSet<Person>(new Comp());
    		ts.add(new Student("aaa"));
    		ts.add(new Student("bbb"));
    		ts.add(new Student("ccc"));
    		ts.add(new Worker("wcc"));
    		ts.add(new Worker("wbb"));
    		Iterator<Person> it = ts.iterator();
    		while(it.hasNext()){ 
    			System.out.println(it.next().getName());
    		}
    	}
    }
    class Comp implements Comparator<Person>
    { 
    	public int compare(Person p1,Person p2){ //内部只能用父类中声明的方法
    		return p1.getName().compareTo(p2.getName());
    	}
    }
    class Person{ 
    	private String name;
    	Person(String name){ 
    		this.name = name;
    	}
    	public String getName(){ 
    		return this.name;
    	}
    }
    class Student extends Person{ 
    	Student(String name){ 
    		super(name);
    	}
    }
    class Worker extends Person{ 
    	Worker(String name){ 
    		super(name);
    	}
    }

## 注意——静态 ##

静态方法不可以访问类上定义的泛型，类上的泛型需要创建对象的时候去指定，而静态优先于对象存在  
如果静态方法操作的应用数据类型不确定，可已将泛型定义在方法上

public static <T> void method(T t){ }

[20200814142820125.png_pic_center]: /images/20221124/f9d5fd250cb047379828adbd82117d21.png