java中的泛型

认识泛型

package cn.ArrayListDemo.com;

import java.util.ArrayList;
import java.util.Iterator;

/*
 * 泛型在哪些地方使用呢？
 * 如果类，接口，抽象类后面跟有<E>就说要使用泛型，一般来说就是在集合中使用
 */
public class ArrayListDemo {
    public static void main(String[] args) {
        //用ArrayList存储字符串元素，并遍历，用泛型改进代码
        ArrayList<String> arrayList=new ArrayList<String>();
        
        //添加元素
        arrayList.add("hello");
        arrayList.add("world");
        arrayList.add("java");
        
        //遍历一
        Iterator<String> iterator=arrayList.iterator();
        while (iterator.hasNext()) {
            String s1 = iterator.next();
            System.out.println(s1);
            
        }
        System.out.println("----------");
        //遍历二
        for (int x = 0; x < arrayList.size(); x++) {
            String s2=arrayList.get(x);
            System.out.println(s2);
        }
    }
}

之前我们在写代码的时候都会提示<E>,有这种的类或者接口，都是泛型；

• 存储自定义对象并遍历；

package cn.ArrayListDemo.com;

import java.util.ArrayList;
import java.util.Iterator;

import cn.manman.com.Student;

public class ArrayListDemo1 {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<Student> arrayList=new ArrayList<Student>();
        
        //创建集合对象
        Student student1=new Student("李四",1);
        Student student2=new Student("王五",2);
        Student student3=new Student("张三",3);
        
        //添加元素
        arrayList.add(student1);
        arrayList.add(student2);
        arrayList.add(student3);
        
        //遍历
        Iterator<Student> it=arrayList.iterator();
        while (it.hasNext()) {
            Student s = it.next();
            System.out.println(s.getName()+"-->"+s.getAge());
            
        }
        //遍历二
        for (int x = 0; x < arrayList.size(); x++) {
            Student s1 = arrayList.get(x);
            System.out.println(s1.getName()+"-->"+s1.getAge());
        }
        
    }
}

泛型的应用

• 泛型类
  1、把泛型定义在类上
  2、格式：public class 类名<泛型类型1，....>
  3、注意：泛型类型必须是引用类型

package cn.itcast_01;

public class ObjectTool<T> {
    public void show(T t){
        System.out.println(t);
    }
}

前面的案例都是将泛型定义在类上，所以比较简单的；

• 泛型方法
  1、把泛型定义在方法上
  2、格式：public <泛型类型> 返回类型 方法名（泛型类型...）

package cn.itcast_02;
/*
 * 泛型定义在方法上
 * 好处是:方法可以接收任意类型
 */
public class ObjectTool {
    public <T> void show(T t) {
        System.out.println(t);
    }
}

package cn.itcast_02;
/*
 * 测试类
 */
public class ObjectToolDemo {
    public static void main(String[] args) {
        ObjectTool ot=new ObjectTool();
        ot.show("张三");
        ot.show(100);
        ot.show(true);
        //System.out.println(ot);
    }
}

• 泛型接口

package cn.itcast_03;
/*
 * 泛型接口
 */
public interface Inter<T> {
    public abstract void show(T t);
}

package cn.itcast_03;
/*
 * 实现接口
 * 在实现时的第一种情况：已经知道类型
 * 第二种：不知道类型
 */
public class InterImpl implements Inter<String>{

    @Override
    public void show(String t) {
        // TODO Auto-generated method stub
        System.out.println(t);
    }
    
}

package cn.itcast_03;
/*
 * 测试
 */
public class InterDemo {
    public static void main(String[] args) {
        //第一种的测试
        Inter<String> i=new InterImpl();
        i.show("hello");
    }
}

这种的并不常用，下面是第二种情况：

public class InterImpl<T> implements Inter<T>{

    @Override
    public void show(T t) {
        // TODO Auto-generated method stub
        System.out.println(t);
    }
    
}

//第二种测试
        Inter<String> i=new InterImpl<String>();
        i.show("hello");
        Inter<Integer> ii=new InterImpl<Integer>();
        ii.show(100);
        Inter<Boolean> iii=new InterImpl<Boolean>();
        iii.show(true);

• 泛型高级
  1、泛型通配符<?>

  
  
  
  

  2、?extends E:向下限定，E及其子类

  
  
  ？是Animal的子类或者本身，而第一个Object是Animal的父类；
  3、？super E：向上限定，E及其父类
  
  与上面的恰好相反；
• 增强for

package cn.itcast_04;

import java.util.ArrayList;
import java.util.Iterator;

/*
 * 增强for:是for循环的一种
 * 好处：简化了数组和集合的遍历；
 */
public class ForDemo {
    public static void main(String[] args) {
        //定义一个int数组
        int[] arr={1,2,3,4,5};
        //普通的遍历
        for (int x = 0; x < arr.length; x++) {
            System.out.println(arr[x]);
        }
        System.out.println("------");
        //增强for
        for(int x:arr){
            System.out.println(x);
        }
        System.out.println("-------");
        //定义一个字符串数组
        String[] strArray={"李六","王五","李四","张三"};
        //增强for
        for(String x:strArray){
            System.out.println(x);
        }
        System.out.println("-------");
        //定义一个集合
        ArrayList<String> arrayList=new ArrayList<String>();
        arrayList.add("hello");
        arrayList.add("world");
        arrayList.add("java");
        //增强for
        for(String x:arrayList){
            System.out.println(x);
        }
    }
}

下面是她的弊端：

List<String> list=null;
        for(String s:list){
            System.out.println(s);
        }

说明增强for循环不能为空，但是怎么解决呢？就是先判断，再执行：

List<String> list=null;
        if (list!=null) {
            for(String s:list){
                System.out.println(s);
            }
        }

因为前面的数组是空的，所以执行没有结果；

• 练习：
  要求：