java基础入门-泛型（1）

为什么需要使用泛型？

1.代码复用

2.保证类型安全

3.编程的便利

第一部分，先说说代码复用

1）建立一个Animal的父类

package com.ray.test;

public class Animal {
	private String name="Animal";

	public String getName() {
		return name;
	}

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

}

2）建立连个Animal的子类Cat和Dog

package com.ray.test;

public class Cat extends Animal {
	private String name="Cat";

	public String getName() {
		return name;
	}

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

package com.ray.test;

public class Dog extends Animal {
	private String name="Dog";

	public String getName() {
		return name;
	}

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

3）建立一个测试类

使用泛型前：

package com.ray.test;

public class Test2 {

	private Animal animal;
	private Cat cat;
	private Dog dog;

	public Test2(Animal animal, Cat cat, Dog dog) {
		this.animal = animal;
		this.cat = cat;
		this.dog = dog;
	}

	public Animal getAnimal() {
		return animal;
	}

	public void setAnimal(Animal animal) {
		this.animal = animal;
	}

	public Cat getCat() {
		return cat;
	}

	public void setCat(Cat cat) {
		this.cat = cat;
	}

	public Dog getDog() {
		return dog;
	}

	public void setDog(Dog dog) {
		this.dog = dog;
	}

	public static void main(String[] args) {
		Test2 test2 = new Test2(new Animal(), new Cat(), new Dog());
		System.out.println(test2.getAnimal().toString());
		System.out.println(test2.getCat().toString());
		System.out.println(test2.getDog().toString());
	}
}

使用泛型后：

package com.ray.test;

public class Test<T> {

	private T t;

	public Test(T t) {
		this.t = t;
	}

	public T getT() {
		return t;
	}

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

	public static void main(String[] args) {
		Test<Animal> test = new Test<Animal>(new Animal());
		Test<Cat> test2 = new Test<Cat>(new Cat());
		Test<Dog> test3 = new Test<Dog>(new Dog());
		System.out.println(test.getT().toString());
		System.out.println(test2.getT().toString());
		System.out.println(test3.getT().toString());
	}
}

前后对比，代码简洁了不少，而且如果以后我不是使用Animal、Dog、Cat这些类，而是使用其他的类，我们也可以再次复用Test<T>这个类

第二部分，我们说说类型安全

没有使用泛型之前，list里面可以增加任何东西，下面就是其中一个例子，大家注意最后add的那个object，其实跟上面的那些完全不一样，但是没有报错

这样为我们使用这个list带来巨大的不变，因为很容易手贱就加了一个不是原来想要的东西进去

package com.ray.test;

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

public class Test2 {
	public static void main(String[] args) {
		List list=new ArrayList();
		list.add(new Animal());
		list.add(new Dog());
		list.add(new Cat());
		list.add(new Test2());
	}
}

使用泛型后，最后一个直接报错，这样对于代码在编译期间就可以识别出错误来，编程效率提高不少。

package com.ray.test;

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

public class Test2 {
	public static void main(String[] args) {
		List<Animal> list=new ArrayList();
		list.add(new Animal());
		list.add(new Dog());
		list.add(new Cat());
		//下面直接报错
		list.add(new Test2());
	}
}

第三部分，我们承接上面的代码继续说下去，泛型对于编程的便利

因为确定了类型，我们使用这个list的时候，可以直接调用类型里面的方法，而且不需要强转，在1.4之前，是需要强转的

package com.ray.test;

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

public class Test2 {
	public static void main(String[] args) {
		List<Animal> list=new ArrayList();
		list.add(new Animal());
		list.add(new Dog());
		list.add(new Cat());

		for (int i = 0; i < list.size(); i++) {
			Animal animal = list.get(i);
			animal.toString();
		}
	}
}

暂时泛型的第一节讲到这里，后面部分请继续关注