简单理解泛型及其特性

桃扇骨 2022-06-16 08:08 138阅读 0赞

## 泛型概述 ##

Collection<E>,  E - 在此 collection 中保持的元素的类型

## 泛型好处 ##

* 提高安全性(将运行期的错误转换到编译期) 
    	* 省去强转的麻烦

## 泛型基本使用 ##

* <>中放的必须是引用数据类型

## :泛型使用注意事项 ##

* 前后的泛型必须一致,或者后面的泛型可以省略不写(1.7的新特性菱形泛型)

import java.util.ArrayList;
    import java.util.Iterator;
    import bean.Student;
    public class c {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		ArrayList list = new ArrayList();
    		list.add(10);
    		list.add(true);
    		list.add(new Student("张三", 23));
    		list.add(new Student("李四", 24));
    		Iterator it = list.iterator();
    		while(it.hasNext()) {
    			System.out.println(it.next());
    			//Student p = (Student) it.next();	向下转型		
    			//System.out.println(p.getName() + "..." + p.getAge());
    			//java.lang.ClassCastException
    			}
    		/*10
    		true
    		Student [name=张三, age=23]
    		Student [name=李四, age=24]*/
    		
    		
    		ArrayList<Student> list1 = new ArrayList<Student>();
    		//list1.add(10);
    		//The method add(int, Student) in the type ArrayList<Student> is not applicable for the arguments (int)
    		//list.add(true);
    		list1.add(new Student("张三", 23));
    		list1.add(new Student("李四", 24));
    		Iterator<Student> it1 = list1.iterator();
    		while(it1.hasNext()) {
    			//Student p = it1.next();	//不用强转		
    			//System.out.println(p.getName() + "..." + p.getAge());
    			/*张三...23
    			李四...24*/
    			
    			//System.out.println(it1.next().getName() + "..." + (it1.next()).getAge());
    			//next方法只能调用一次,如果调用多次会将指针向后移动多次
    		}
    		
    		
    		//int[] arr = new byte[5];	//数组要保证前后的数据类型一致
    		//ArrayList<Object> list = new ArrayList<Person>();	//集合的泛型要保证前后的数据类型一致
    		//ArrayList<Object> list = new ArrayList<>();		//1.7版本的新特性,菱形泛型
    		ArrayList<Object> list2 = new ArrayList<>();//泛型最好不要定义成Object,没有意义
    		list2.add("aaa");
    		list2.add(true);
    			
    			
    	}
    
    }

## 泛型集合的遍历 ##

import java.util.ArrayList;
    import java.util.Iterator;
    import bean.Student;
    public class d {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		ArrayList<String> list = new ArrayList<>();	//创建集合对象
    		list.add("a");
    		list.add("b");
    		list.add("c");
    		list.add("d");
    		//list.add(arg0)
    		Iterator<String> it = list.iterator();
    		while(it.hasNext()) {
    			System.out.println(it.next());//a b c d
    		}
    		
    		
    		ArrayList<Student> list1 = new ArrayList<>();
    		list1.add(new Student("张三", 23));
    		list1.add(new Student("李四", 24));
    		list1.add(new Student("王五", 25));
    		list1.add(new Student("赵六", 26));
    		Iterator<Student> it1 = list1.iterator();
    		while(it1.hasNext()) {
    			Student p = it1.next();	//将集合中的每一个元素用Student记录
    			System.out.println(p.getName() + "..." + p.getAge());
    		}
    	}
    }

## 泛型的由来 ##

泛型的由来:通过Object转型问题引入
      早期的Object类型可以接收任意的对象类型，
      但是在实际的使用中，会有类型转换的问题。也就存在这隐患，
      所以Java提供了泛型来解决这个安全问题。
      早期的Object类型可以接收任意的对象类型，
      但是在实际的使用中，会有类型转换的问题。也就存在这隐患，
      所以Java提供了泛型来解决这个安全问题。

## 泛型类概述<T> ##

* 把泛型定义在类上
    	定义格式
    	* public class 类名<泛型类型1,…>
    	注意事项	
    	* 泛型类型必须是引用类型

## 泛型方法概述 ##

* 把泛型定义在方法上
    	定义格式	
    	* public <泛型类型> 返回类型 方法名(泛型类型 变量名)

## 泛型接口概述 ##

* 把泛型定义在接口上
    	定义格式	
    	* public interface 接口名<泛型类型>

public class e {
    	public static void main(String[] args) {
    		/*Demo d = new Demo<String>();
    		d.show("a");*/
    		Demo dd = new Demo();
    		dd.show("aa");
    		System.out.println("接口");
    	}
    }
    //
    interface Inter<T> {
    	public void show(T t);
    }
    
    class Demo implements Inter<String> {//推荐用这种
    	@Override
    	public void show(String t) {
    		System.out.println("接口 String");	
    	}
    }
    
    /*class Demo<T> implements Inter<T> {//没有必要在实现接口的时候给自己类加泛型
    	@Override
    	public void show(T t) {
    		System.out.println("接口T");
    	}
    	
    }*/

## 泛型高级之通配符<?> ##

* 任意类型，如果没有明确，那么就是Object以及任意的Java类了
     ? extends E
     * 向下限定，E及其子类
     ? super E
     * 向上限定，E及其父类

Collection类中的一个add方法
    boolean addAll(Collection<? extends E> c)
     将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。
     如果在进行此操作的同时修改指定的 collection，那么此操作行为是不确定的。
     （这意味着如果指定的 collection 是此 collection，并且此 collection 为非空，那么此调用的行为是不确定的。） 
     参数：
     c - 包含要添加到此 collection 的元素的 collection 
     返回：
     如果此 collection 由于调用而发生更改，则返回 true

import java.util.ArrayList;
    import java.util.List;
    import bean.Person;
    import bean.Student;
    public class f {
    	public static void main(String[] args) {
    		//List<?> list = new ArrayList<Integer>();//当右边的泛型是不确定时,左边可以指定为?
    		ArrayList<Student> list1 = new ArrayList<>();
    		list1.add(new Student("张三", 23));
    		list1.add(new Student("李四", 24));
    		list1.add(new Student("王五", 25));
    		
    		ArrayList<Person> list2 = new ArrayList<>();
    		list2.add(new Person("赵六", 26));
    		list2.add(new Person("周七", 27));
    		
    		System.out.println(list2);
    		list1.addAll(list2);//person是student的子类，自动类型提升
    		System.out.println(list1);
    		
    		//list2.addAll(list1);
    
    	}
    
    }

还有一个person类，继承于student

package bean;
    public class Person extends Student {
    	public Person() {
    		super();	
    	}
    	public Person(String name, int age) {
    		super(name ,age);
    	}
    }