12. 泛型

一、泛型的概念

??把元素的类型设置成一个参数，这个类型参数叫做泛型；所谓的泛型，就是允许在自定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即传入实际的类型参数，也称类型实参）；

??从JDK1.5以后，Java引入“参数化类型（Parameterized type）”的概念，允许我们在创建集合时在指定集合元素的类型；JDK1.5改写了集合框架中的全部接口和类，为这些接口、类增加了泛型支持，从而可以在声明集合变量、创建集合对象时传入类型实参。

??在实例化（或实现）带有泛型的类（或接口）时，可以指明具体的泛型类型。指明完泛型以后，在带有泛型的类或接口中凡是定义类或接口时，内部结构使用到类的泛型的位置，都指定为实例化的泛型类型；泛型的类型必须是类，不能是基本数据类型。如果需要使用基本数据类型的位置，用包装类替换；如果实例化时，如果实例化时没有指定泛型的类型。默认类型为java.lang.Object类型；

使用泛型之前

import java.util.ArrayList;

public class GenericTest{
    public static void main(String[] args) {
        ArrayList list = new ArrayList();

        list.add(100);
        list.add(73);
        list.add(97);

        //类型不安全
        list.add("Sakura");

        for (Object object : list) {
            //强制类型转换时，可能出现ClassCastException
            if (object instanceof Integer) {
                int score = (int)object;
                System.out.println(score);
            }
        }
    }
}

使用泛型之后

import java.util.ArrayList;
import java.util.Iterator;

public class GenericTest{
    public static void main(String[] args) {
        ArrayList list = new ArrayList();

        list.add(100);
        list.add(73);
        list.add(97);

        //编译时，就会进行类型检查，保证数据的安全
        //list.add("Sakura");

        Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            int score = iterator.next();
            System.out.println(score);
        }
    }
}

二、自定义泛型结构

2.1、自定义泛型类或泛型接口

  • 泛型类可以有多个参数，此时应将多个参数一起放到尖括号内
  • 实例化之后，操作原来泛型位置的结构必须与指定的泛型类型一致
  • 泛型不同的引用不能相互赋值
  • 泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价于Object
  • 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象
  • 泛型的指定中不能使用基本数据类型，可以使用包装类替换
  • 在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型
  • 异常类不能使用类的泛型
  • 不能使用 new 泛型数组
  • 父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：
    • 子类不保留父类的泛型：按需实现
      • 没有类型 擦除
      • 具体类型
    • 子类保留父类的泛型：泛型子类
      • 全部保留
      • 部分保留
  • 子类除了指定或保留父类的泛型，还可以增加自己的泛型
public class GenericTest{
    public static void main(String[] args) {

        //类型推断：使用泛型时，可以只需在前面指定泛型类型
        Order order = new Order<>("美琴",1001,"Order");
        order.orderT = "OrderNumber";
        System.out.println(order);

        //由于子类在继承带泛型的父类时，指明了泛型的类型，则实例化子类对象时，不在需要指明泛型
        SubOrder subOrder = new SubOrder("Sakura",1002,725872);
        subOrder.orderT = 27185;
        System.out.println(subOrder);

        ChildOrder childOrder = new ChildOrder<>("Nanoha",1003,"ChildOrder");
        childOrder.orderT = "ChildOrder";
        System.out.println(childOrder);
    }
}

public class Order {
    String orderName;
    int orderId;

    //类的内部就可以使用类的泛型
    T orderT;

    public Order(){

    }

    public Order(String orderName,int orderId,T orderT){
        this.orderName = orderName;
        this.orderId = orderId;
        this.orderT = orderT;
    }

    public String toString(){
        return "Order{ orderName = " + orderName + " ,orderId = " + orderId + " ,orderT = " + orderT + "}";
    }
}

//SubOrder不再是泛型类
public class SubOrder extends Order{
    public SubOrder(){

    }

    public SubOrder(String SubOrderName,int SubOrderId,int SubOrdererT){
        super(SubOrderName, SubOrderId, SubOrdererT);
    }
}

//ChildOrder仍然是泛型类
public class ChildOrder extends Order{
    public ChildOrder(){

    }

    public ChildOrder(String ChildOrderName,int ChildOrderId,T ChildOrderT){
        super(ChildOrderName, ChildOrderId, ChildOrderT);
    }
}

2.2、自定义泛型方法

??在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何联系。换句话说，泛型方法所属的类是不是泛型类都没有关系。泛型方法可以声明为静态的，这是因为，泛型参数是在调用方法时确定的，并非在实例化类时确定的。

import java.util.List;

public class GenericTest{
    public static void main(String[] args) {

        Person person = new Person<>();
        Integer[] array = new Integer[]{1,2,3,4};

        //泛型方法在调用时，指明泛型参数的类型
        List list = person.copyFromToList(array);
        System.out.println(list);

        String[] strings = new String[]{"Sakura","Kikyou","Kagome"};
        List list2 = Student.copy(strings);
        System.out.println(list2);
    }
}

import java.util.ArrayList;
import java.util.List;

public class Person {
    String name;
    int age;

    //类的内部就可以使用类的泛型
    T id;

    public Person(){

    }

    public Person(String name,int age,T id){
        this.name = name;
        this.age = age;
        this.id = id;
    }

    public  List copyFromToList(E[] array){
        ArrayList list = new ArrayList<>();

        for (E e : array) {
            list.add(e);
        }

        return list;
    }
    
    @Override
    public String toString() {
        return "Person{ name = " + name + ", age = " + age + ", id = " + id +" }";
    }
}

import java.util.ArrayList;
import java.util.List;

public class Student extends Person{

    public Student(){

    }

    public Student(String name,int age,String id){
        super(name, age, id);
    }

    public static  List copy(E[] array){
        ArrayList list = new ArrayList<>();

        for (E e : array) {
            list.add(e);
        }

        return list;
    }

    @Override
    public String toString() {
        return "Person{ name = " + name + ", age = " + age + ", id = " + id +" }";
    }
}

2.3、泛型类和泛型方法的使用情景

import java.util.List;

public class DAOTest {
    public static void main(String[] args) {
        
        CustomerDAO customerDAO = new CustomerDAO();
        customerDAO.add(new Customer("Sakura",10));
        List list = customerDAO.getForList(10);

        StudentDAO studentDAO = new StudentDAO();
        Student student = studentDAO.getIndex(1);
    }
}

import java.util.List;

//操作表的共性操作的DAO
public class DAO {

    public void add(T t){

    }

    public boolean remove(int index){
        return false;
    }

    public void updata(int index,T t){

    }

    public T getIndex(int index){
        return null;
    }

    public List getForList(int index){
        return null;
    } 
    
    //泛型方法
    //举例：获取表中一共有多少条记录？获取最大的员工入职时间
    public  E getValue(){
        return null;
    }
}

//只能操作某一个表的DAO
public class CustomerDAO extends DAO{
    
}

//只能操作某一个表的DAO
public class StudentDAO extends DAO{
    
}


public class Person{
    private String name;
    private int age;

    public Person(){

    }

    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    
    public void setName(String name){
        this.name = name;
    }

    public String getName(){
        return name;
    }

    public void setAge(int age){
        this.age = age;
    }

    public int getAge(){
        return age;
    }

    @Override
    public String toString() {
        return "Person{ name = " + name + ", age = " + age +" }";
    }
}

public class Customer extends Person{

    public Customer(){

    }

    public Customer(String name,int age){
        super(name, age);
    }

    @Override
    public String toString() {
        return "Customer{ name = " + getName() + ", age = " + getAge() +" }";
    }
}

public class Student extends Person{

    public Student(){

    }

    public Student(String name,int age){
        super(name, age);
    }

    @Override
    public String toString() {
        return "Student{ name = " + getName() + ", age = " + getAge() +" }";
    }
}

三、泛型在继承方面的体现

四、通配符的使用

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class WildcardTest {
    public static void main(String[] args) {
        List list1 = new ArrayList<>();

        List list2 = new ArrayList<>();
        list2.add("Sakura");
        list2.add("Fate");
        list2.add("Hayate Yagami");

        List<?> list = null;
        list = list1;
        list = list2;
        //对于List<?>不能像内部添加数据，除了添加null之外
        //list.add("Misaka");
        //list.add('?');
        list.add(null);

        WildcardTest test = new WildcardTest();
        test.print(list1);
        test.print(list2);
        test.print(list);

        //获取（读取）：允许读取数据，读取的数据类型为Object
        Object object = list.get(0);
        System.out.println(object);
    }

    public void print(List<?> list){
        Iterator<?> iterator = list.iterator();
        while(iterator.hasNext()){
            Object object = iterator.next();
            System.out.print(object + "\t");
        }
        System.out.println();
    }
}


4.1、有限制条件的通配符的使用



import java.util.ArrayList;
import java.util.List;

public class WildcardTest {
    public static void main(String[] args) {
        List<? extends Person> list1 = null;
        List<? super Person> list2 = null;

        List list3 = new ArrayList<>();
        List list4 = new ArrayList<>();
        List list5 = new ArrayList<>();

        list1 = list3;
        list1 = list4;
        //list1 = list5;

        //list2 = list3;
        list2 = list4;
        list2 = list5;

        //读取数据
        list1 = list3;
        Person person = list1.get(0);
        //Student student = list1.get(0);

        list2 = list4;
        Object object = list2.get(0);
        //Person person2 = list2.get(0);

        //写入数据
        //list1.add(new Student());

        list2.add(new Person());
        list2.add(new Student());
    }
}

						  
					  
						
							


						

							
							
			01.JavaSEjavaJavaSE基础知识泛型							
						



						

						
						


						

						
					
					

					
					

						
相关

						

				
						
			

																
								

										
JavaWeb的三大作用域

									
									

								 

        

								

							
							

																
								

										
java中常用数组copy方法

									
									

								 

        

								

							
							

																
								

										
6.Java方法

									
									

								 

        

								

							
							

																
								

										
Java web开发：从零到 Run 一个现有的 Spring Boot 前后端分离项目（前端Vue）

									
									

								 

        

								

							
							

																
								

										
javascript基础知识(29) 实现继承的方式

									
									

								 

        

								

							
							

																
								

										
java  正则表达式

									
									

								 

        

								

							
							

																
								

										
JAVA List<Object[]>取值问题

									
									

								 

        

								

							
							

																
								

										
初次接触Java感受

									
									

								 

        

								

							
							

																
								

										
99乘法表   java for循环

									
									

								 

        

								

							
							

																
								

										
基于java.net.socket包的对象传递

									
									

								 

        

								

							
							

																
								

										
Idea Java项目文件夹后面提示百分数怎么去掉

									
									

								 

        

								

							
							

																
								

										
Java8新特性

									
									

								 

        

								

							
							
            
            
            
                                    
           
  			
						

					

					
				

				

														
					
					

					
									

					
									   
标签

										

										
    
										

									

										
										

									

					

					
				


			
		
		
		
			


						





	

	
一品网 冀ICP备14022925号-6