Java基础之泛型

泛型genericity

格式：

<自定义泛型无意义大写英文字母占位符>

例：<T> Type <E> Element <K> Key <V> value

泛型可以在方法,类,接口中使用

泛型在方法中使用

使用静态方法的泛型格式:

public static <T> 返回值类型[自定义泛型] 方法名(必须存在一个对应泛型的参数) {
    方法体内可以使用泛型
}

package cn.ocean888;

public class Demo1 {
	public static void main(String[] args) {
		Integer test = test(123);
		String test2 = test("你好");
		Demo1 test3 = test(new Demo1());
	}
	
	/**
	 * 带有自定义泛型的声明方法
	 * @param <T> 自定义泛型无意义占位符
	 * @param t 指定的泛型数据类型，由用户约束
	 * @return 对应的T类型，具体数据类型由用户约束
	 */
	public static <T> T test(T t) {
		return t;
	}
}

整型时

字符串型

总结：

1. 自定义泛型声明在返回值之前，以保证方法的参数和返回值都可以使用对应的泛型
2. 方法声明的泛型，在方法中的参数中必须有一个参数是对应声明的自定义泛型，当前参数是用于约束方法内所用使用到泛型的位置对应的具体数据类型是什么

package cn.ocean888;

public class Demo1 {
   public static void main(String[] args) {
   	Integer test = test(123);
   	String test2 = test("你好");
   	Demo1 test3 = test(new Demo1());
   	
   	Integer[] arr1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
   	String[] arr2 = {"one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
   	printArray(arr1);
   	printArray(arr2);
   }
   
   /**
    * 带有自定义泛型的声明方法
    * @param <T> 自定义泛型无意义占位符
    * @param t 指定的泛型数据类型，由用户约束
    * @return 对应的T类型，具体数据类型由用户约束
    */
   public static <T> T test(T t) {
   	return t;
   }
   
   public static <T> void printArray(T[] arr) {
   	for (int i = 0; i < arr.length; i++) {
   		System.out.println(arr[i]);
   	}
   }
}

泛型在类中使用

格式

class 类名<自定义泛型无意义大写字母占位符> {
    在类内的成员变量和成员方法都可以使用自定义泛型
    建议:成员变量不建议使用自定义泛型
}

package cn.ocean888;

import java.awt.Window.Type;

/**
 * 定义一个自定义泛型类
 * @author Ocean
 *
 * @param <T>
 */
class TypeA<T> {
	/**
	 * 使用和类名一致的自定义泛型，需要通过 类对象 来约束
	 * @param t 对应泛型具体数据类型的参数
	 * @return 对应泛型具体数据类型的返回值
	 */
	public T test1(T t) {
		return t;
	}
	
	public void test2(T t1, T t2) {
		System.out.println(t1);
		System.out.println(t2);
	}
}

public class Demo2 {
	public static void main(String[] args) {
		/*
		 * 创建带有自定义泛型类的对象
		 * TypeA<String> typeA = new TypeA<String>(); Eclipse标准写法
		 * TypeA<String> typeA = new TypeA<>(); IDEA写法
		 */
		
		// 明确告诉编译器,这里泛型对应的具体数据类型是String类型
		// 类内所有使用到泛型占位符的位置都是T类型
		TypeA<String> typeA = new TypeA<String>();
		String test1 = typeA.test1("Paking duck");
		System.out.println(test1);
		typeA.test2("meat", "fruit");
		
		// 明确告诉编译器,这里泛型对应的具体数据类型是Demo2类型
		TypeA<Demo2> typeA2 = new TypeA<Demo2>();
		Demo2 test2 = typeA2.test1(new Demo2());
		System.out.println(test2);
		
	}
}

不推荐这种方法

注意：

1. 类声明自定义泛型，需要通过创建对象的方式来约束

   TypeA<String> typeA = new TypeA<String>(); Eclipse标准写法
   TypeA<String> typeA = new TypeA<>(); IDEA写法
   

2. 类声明泛型约束之后，在类内的所有成员方法中使用的泛型都是类约束的泛型具体数据类型

3. 如果没有约束类声明泛型，所有使用到泛型的位置都是object（不推荐使用）

4. 类声明的自定义泛型不能用于类内的静态方法

   因为静态成员方法是在类文件的加载阶段准备完毕，已经可以明确的保证该方法是可以执行的

   如果使用类声明的自定义泛型，对应泛型的具体数据类型需要在创建类对象之后才可以明确

   当前静态方法在类文件加载阶段无法明确泛型数据类型是哪一个，也就无法保证执行，因为没有对象

泛型在接口中使用

interface 接口名<自定义泛型无意义占位符> {
    
}

package cn.ocean888;

interface A<T> {
	void test(T t);
}

/**
 * 自由方式，类名之后和接口同名自定义泛型，泛型对应的数据类型是需要在创建当前对象时进行约束使用
 * 
 * @author Ocean
 *
 * @param <T> 遵从接口和接口一致的泛型
 */
class TypeB<T> implements A<T> {
	@Override
	public void test(T t) {
		System.out.println("自由模式");
	}
}

/**
 * 规矩模式，遵从接口时，接口使用泛型对应的具体数据类型已经明确
 * 在类内使用接口中缺省属性为public abstract方法时，泛型已经确认
 * @author Ocean
 */
class TypeC implements A<String> {
	@Override
	public void test(String t) {
		System.out.println("规矩模式");
	}
}


public class Demo3 {
	public static void main(String[] args) {
		/*
		 * 自由模式
		 */
		TypeB<Integer> typeB = new TypeB<Integer>();
		typeB.test(10);
		
		TypeB<Character> typeB2 = new TypeB<Character>();
		typeB2.test('A');
		
		/*
		 * 规矩模式
		 */
		TypeC typeC = new TypeC();
		typeC.test("test");
	}
}

1. 接口声明的泛型，只能用于类内的成员方法

2. 遵从带有自定义泛型的接口的类，一种可以遵从过程中明确告知泛型具体类型（规矩模式），一种是在创建类对象时明确泛型具体数据类型（自由模式）