package com.atguigu.javase.generic;

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

import org.junit.Test;

// 自定義泛型類, A只能是類型別
class Person<A> { // A在這裡表示它是某種型別, 型別的形參, 在本類中就可以直接使用A這個型別.
	// A型別在建立物件時指定.
	// 如果A型別在建立物件時,並未確定的指定, 它就是Object型別, 型別不安全了
	// 泛型型別隸屬於物件的, 不同的物件在建立時指定的泛型型別可以不一樣
	
	private String name;
	private A info;
	
	public Person() {
	}

	public Person(String name, A info) {
		super();
		this.name = name;
		this.info = info;
	}
	
	public void setInfo(A info) {
		this.info = info;
	}
	
	public A getInfo() {
		return info;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public String getName() {
		return name;
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", info=" + info + "]";
	}
	
	/* 靜態成員不可以使用泛型型別
	public static void test(A a) {
		
	}*/
	
	/**
	 * 泛型方法, 方法中的泛型型別在方法的返回值之前宣告<泛型的型別引數>
	 * 泛型方法必須在形參中指定好特定的型別, 否則泛型方法中的泛型型別永遠是Object
	 * 泛型方法中的泛型型別究竟是什麼, 由實參來決定.所以是在方法的每一次呼叫時才能確定的.
	 * 如果實參是null, 則無法確定泛型型別, 只能是Object型別了.
	 * @return
	 */
	public <B> B testB(B b) {
		return null;
	}
}

class A<X> {
	X x;
	
	public X getX() {
		return x;
	}
}
class B extends A {} // 子類在繼承時並未指定X的具體型別, 所以永遠是Object
class C extends A<String> {} // 子類在繼承時直接寫死父類的泛型型別, 在子類中X型別永遠是一致,不變的
class C2 extends A<Double> {}
class D<X> extends A<X> {} // 子類在繼承父類時仍然保持泛型型別的不確定性.

public class GenericTest {
	
	@Test
	public void test6() {
		B b = new B();
		Object x = b.getX();
		
		C c = new C();
		String x2 = c.getX();
		
		D d = new D();
		Object x3 = d.getX();
		D<Integer> d2 = new D<Integer>();
		Integer x4 = d2.getX();
		String x5 = new D<String>().getX();
	}
	
	@Test
	public void test5() {
		List<Integer> list = new ArrayList<Integer>();
		for (int i = 0; i < 10; i++) {
			list.add((int)(Math.random() * 20));
		}
		System.out.println(list);
		
		Object[] array = list.toArray();
		for (Object object : array) {
			System.out.println(object);
		}
		
		System.out.println("**********************");
		
		Integer[] array2 = list.toArray(new Integer[] {});
		for (Integer integer : array2) {
			System.out.println(integer);
		}
	}
	
	@Test
	public void test4() {
		Person<String> person = new Person<String>("張三", "北京");
		Integer testB = person.testB(30);
		String testB2 = person.testB("男");
		Boolean testB3 = person.testB(false);
		Object testB4 = person.testB(null); // 當實參的型別無法確定時, 泛型方法中的型別就是Object
	}
	
	@Test
	public void test3() {
		List<Integer> list1 = new ArrayList<Integer>();
		List<Double> list2 = new ArrayList<Double>();
	}
	
	@Test
	public void test2() {
		// 在這個物件中的A型別就固定是String型別
		Person<String> person = new Person<String>("張三", "北京"); // String在建立物件時,會作為類中的A型別的具體型別
		String info = person.getInfo();
		System.out.println(info);
		
		//person.setInfo(30);
		
		//new Person<Integer>("李四", "上海");
		Person<Integer> person2 = new Person<Integer>("李四", 40);
		Integer info2 = person2.getInfo();
		System.out.println(info2);
	}
	
	@Test
	public void test1() {
		Person person = new Person("張三", 30); // 理論上A型別就是Integer了, 但是沒有指定
		Object info = person.getInfo();
		System.out.println(info);
		person.setInfo("男"); // 在這裡體現了型別不安全, 因為理論上型別是Integer,但是實際給定的是String
		
		Person person2 = new Person("李四", "女");
		Object info2 = person2.getInfo();
		System.out.println(info2);
	}
}	
 

靜態方法不能使用泛型，因為靜態方法隸屬於類，而泛型是繫結到物件上的

對於更精確的型別確定，可以使用泛型方法

相關推薦