1.jdk5.0之后退出的新特性：泛型
2.泛型这种机制，只在程序编译阶段起作用，只是给编译器参考的（运行阶段泛型没用）
3.使用泛型的好处：
第一：集合中存储的元素统一了。
第二：从集合中取出的元素类型是泛型指定的类型，不需要进行大量的向下转型了
4.泛型的缺点：
导致集合中的元素缺乏多样性！
package Collection;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class GenericTest {
public static void main(String[] args) {
//不使用泛型机制
//创建集合对象
List mylist=new ArrayList();
//准备对象
Cat c=new Cat();
Bird b=new Bird();
//将集合添加到集合里边
mylist.add(c);
mylist.add(b);
//遍历集合，取出每个Animal,让他run
Iterator it=mylist.iterator();
while(it.hasNext()){
//Animal a=it.next(); 没有这个语法，通过迭代器取出的就是Object
Object ob=it.next();
//Object中没有run方法，无法调用，需要向下转型！！
if(ob instanceof Animal){
Animal a=(Animal)ob;
a.run();
}
}
/*使用泛型
使用泛型List<Animal>之后，表示List集合只允许存储Animal类型的数据
用泛型来指定集合中存储的数据类型
*/
/* List<Animal> mylist=new ArrayList();
//准备对象
Cat c=new Cat();
Bird b=new Bird();
//指定list集合中只能存储Animal，如果存储String就会报错
//这样使用泛型之后，集合中元素的数据类型就更加统一了
// mylist.add("asd");
mylist.add(c);
mylist.add(b);
//获取迭代器，这个迭代器迭代的就是Animal类型
Iterator<Animal> it=mylist.iterator();
while(it.hasNext()){
//使用了泛型之后，每一次迭代返回的数据就是Animal类型
Animal a=it.next();
//这里也不需要进行强制类型转换了，直接调用
a.run();
}
//调用子类型特有的方法还是需要向下转型的
while(it.hasNext()){
Animal a=it.next();
if(a instanceof Cat){
Cat ca=(Cat)a;
ca.eat();
}
if(a instanceof Bird){
Bird bi=(Bird)a;
bi.fly();
}
}*/
}
}
class Animal{
public void run(){
System.out.println("小动物喜欢奔跑");
}
}
class Cat extends Animal{
public void eat(){
System.out.println("猫喜欢吃鱼");
}
}
class Bird extends Animal{
public void fly(){
System.out.println("小鸟喜欢飞");
}
}
使用泛型之后，不需要大量的强制转换啦！！
package Collection;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class GenericTest {
public static void main(String[] args) {
//不使用泛型机制
//创建集合对象
/* List mylist=new ArrayList();
//准备对象
Cat c=new Cat();
Bird b=new Bird();
//将集合添加到集合里边
mylist.add(c);
mylist.add(b);
//遍历集合，取出每个Animal,让他run
Iterator it=mylist.iterator();
while(it.hasNext()){
//Animal a=it.next(); 没有这个语法，通过迭代器取出的就是Object
Object ob=it.next();
//Object中没有run方法，无法调用，需要向下转型！！
if(ob instanceof Animal){
Animal a=(Animal)ob;
a.run();
}
}*/
/*使用泛型
使用泛型List<Animal>之后，表示List集合只允许存储Animal类型的数据
用泛型来指定集合中存储的数据类型
*/
List<Animal> mylist=new ArrayList();
//准备对象
Cat c=new Cat();
Bird b=new Bird();
//指定list集合中只能存储Animal，如果存储String就会报错
//这样使用泛型之后，集合中元素的数据类型就更加统一了
// mylist.add("asd");
mylist.add(c);
mylist.add(b);
//获取迭代器，这个迭代器迭代的就是Animal类型
Iterator<Animal> it=mylist.iterator();
while(it.hasNext()){
//使用了泛型之后，每一次迭代返回的数据就是Animal类型
Animal a=it.next();
//这里也不需要进行强制类型转换了，直接调用
a.run();
}
//调用子类型特有的方法还是需要向下转型的
/* while(it.hasNext()){
Animal a=it.next();
if(a instanceof Cat){
Cat ca=(Cat)a;
ca.eat();
}
if(a instanceof Bird){
Bird bi=(Bird)a;
bi.fly();
}*/
}
}
class Animal{
public void run(){
System.out.println("小动物喜欢奔跑");
}
}
class Cat extends Animal{
public void eat(){
System.out.println("猫喜欢吃鱼");
}
}
class Bird extends Animal{
public void fly(){
System.out.println("小鸟喜欢飞");
}
}
但是调用子类型的方法，还是需要强制转换！！
package Collection;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class GenericTest {
public static void main(String[] args) {
List<Animal> mylist=new ArrayList();
//准备对象
Cat c=new Cat();
Bird b=new Bird();
//指定list集合中只能存储Animal，如果存储String就会报错
//这样使用泛型之后，集合中元素的数据类型就更加统一了
// mylist.add("asd");
mylist.add(c);
mylist.add(b);
//获取迭代器，这个迭代器迭代的就是Animal类型
Iterator<Animal> it=mylist.iterator();
/* while(it.hasNext()){
//使用了泛型之后，每一次迭代返回的数据就是Animal类型
Animal a=it.next();
//这里也不需要进行强制类型转换了，直接调用
a.run();
}*/
//调用子类型特有的方法，还是需要进行向下转型的
while(it.hasNext()){
Animal a=it.next();
if(a instanceof Cat) {
Cat x = (Cat) a;
x.eat();
}
if(a instanceof Bird){
Bird y=(Bird)a;
y.fly();
}
}
}
}
class Animal{
public void run(){
System.out.println("小动物喜欢奔跑");
}
}
class Cat extends Animal{
public void eat(){
System.out.println("猫喜欢吃鱼");
}
}
class Bird extends Animal{
public void fly(){
System.out.println("小鸟喜欢飞");
}
}
自定义泛型
package Collection;
//自定义泛型 <>钻石表达式
/*java源代码中经常出现的是：
<E>和<T>
E是Element单词首字母
T是Type单词首字母
Duan随便写一般写E或T
*/
public class GenericTest01<Duan随便写> {
public void dosome(Duan随便写 d){
System.out.println(d);
}
public static void main(String[] args) {
//new对象的时候指定了泛型是：String类型
GenericTest01<String> ge=new GenericTest01<>();
ge.dosome("吃脆脆鲨");
//类型不匹配
// ge.dosome(123);
}
}
