认识泛型
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);
}
}
因为前面的数组是空的，所以执行没有结果；
-
练习：
要求：
