java基础学习日志15

泛型

public class Animal {
	String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Animal(String name) {
		this.name = name;
	}

	public Animal() {

	}
}

class Dog extends Animal {

	public Dog(String name) {
		super(name);
		this.name = name;
	}

	public Dog() {
	}
}

class Courser extends Dog {
	public Courser(String name) {
		super(name);
		this.name = name;
	}

}

/**
 * 通过泛型的继承，可以对箱子中放置的对象进行限制，只能是extends后的类型以及其子类类型
 * 
 * @author 孙勇
 * @date 2018年1月31日上午9:52:53
 * @param <T>
 */
public class Box1<T> {
	T t;

	public T getT() {
		return t;
	}

	public void setT(T t) {
		this.t = t;
	}

	public static void main(String[] args) {
		// Box1<Dog> dogBox=new Box1<Dog>();
		// 不支持协变,类型由子类类型想父类类型进制转换的时候这种是协变，java的泛型是不支持的
		// Box1<Animal> animalBox=dogBox;
		// Box1<Animal> animalBox2=new Box1<Dog>();
		// 不支持逆变 类型由父类类型向子类类型进制转换的时候这种是逆变，java的泛型是不支持的
		// Box1<Course> courserBox=new Box1<Animal>();
		// Animal[] animals=new Dog[3];
		// animals[0]=new Animal();
		// Dog[] dogarr = (Dog[]) new Animal[3];
		// dogarr[0]=new Dog();

//		Box1<Dog> dogBox = new Box1<Dog>();
//		dogBox.setT(new Dog("狗狗"));
//		Dog dog = dogBox.getT();
//		Box1<Animal> animalBox = new Box1<Animal>();
//		animalBox.setT(new Animal("lisi"));
//		
//		System.out.println("dogBox.getClass==animalBox.getClass()=" + (dogBox.getClass() == animalBox.getClass())); // true
//		System.out.println("dogBox.getClass==Box.class=" + (dogBox.getClass() == Box1.class)); // true
//
//		if (dogBox instanceof Box1) {
//			System.out.println("dogBox就是Box"); // 输出：dogBox就是Box
//		}

		Box1<Dog> dogBox=new Box1<Dog>();
		//java泛型只存在于编译期，运行期没有类型信息，类型参数被擦除为Object类型
		//两个引用指向同一个箱子
//		Box1 box=dogBox;
//		//成功的在运行期讲一个动物对象放入了狗箱子
//		box.setT(new Animal("hello"));
//		//成功的在运行期将字符串对象放入了狗箱子
//		box.setT("hello world");
//		System.out.println(box.getT());
//		
//		Box1<? extends Animal> animalBox=new Box1<Dog>();
//		Box1<Courser> courserB=new Box1<Courser>();
//		courserB.setT(new Courser("hh")); //赋值为猎狗的箱子也可以，因为course继承Dog
//		animalBox=courserB;
		animalBox.setT(new Dog("aa"));
		animalBox.setT(new Courser("hh"));
//		Courser c = (Courser) animalBox.getT();
//		System.out.println(c.name);
		
		//使用带super的通配符后，类似逆变
		Box1<? super Courser> courserBox=new Box1<Courser>();
		courserBox=new Box1<Animal>();
		//可以放入
		courserBox.setT(new Courser("hh"));
		//但是取出的类型推断的是Object,又需要强制类型转换了，丢失类类型信息
		Courser object=(Courser)courserBox.getT();
		System.out.println(object.name);

	}

}

public interface GenericInterface<T> {
	T generatObj();
}

public class Flower {

}

public class Box<T,K> {
	T t;
	K k;
	public T getT() {
		return t;
	}
	public void setT(T t) {
		this.t = t;
	}
	public K getK() {
		return k;
	}
	public void setK(K k) {
		this.k = k;
	}
	
	
}

public class Test {
	public static void main(String[] args) {
//		Box<Animal,Flower> b1 = new Box<Animal,Flower>();
//		Animal ani = new Animal();
//		Flower f = new Flower();
//		b1.setK(f);
//		b1.setT(ani);
//		Animal ain1 = b1.getT();
		
//		通过泛型可以对箱子内放置的对象进行限定，放置的对象只能是标签类型以及子类类型
//		Box1<Animal> ba1 = new Box1<Animal>();
//		Box1<Animal> ba2 = new Box1<Animal>();
//		Box1<Animal> ba3 = new Box1<Animal>();
//		Box1<Animal> ba4 = new Box1<Animal>();
//		
		Animal ani = new Animal();
		Dog d = new Dog();
		Courser c = new Courser();
//		ba1.setT(ani);
//		ba2.setT(d);
//		ba3.setT(c);
//		String str = new String("tom");
//		Courser ani1 = (Courser) ba1.getT();
//		Dog d1 = (Dog) ba2.getT();
//		Courser c1 = (Courser) ba3.getT();
		
		Box1<Dog> dogBox=new Box1<Dog>();
		Box1<Animal> animalBox=new Box1<Animal>();
		dogBox.setT(c);
		animalBox.setT(d);
		Courser c1 = (Courser) dogBox.getT();
		
	}
}