泛型机制：JDK1.5之后引入的一个概念 A:泛型概述:是一种把类型明确的工作推迟到创建对象或调用方法时，才去明确的一种机制。 或者调用方法的时候才去明确的特殊的类型。 参数化类型，把类型当作参数一样的传递。 B:泛型的格式 : <数据类型，数据类型> 这里的数据类型只能是引用数据类型 C:泛型好处 (1): 把运行时期的问题提前到了编译期间 (2): 避免了强制类型转换 (3):优化了程序设计，解决了黄色警告线，提高程序的扩展性 注意：泛型只在编译期有效 但在运行期就擦除了 //JDK1.7之前 泛型前面后面都得写上，JDK1.7可以省略右半边不写 D:泛型基本使用
案例一：
public class MyTest { public static void main(String[] args) { //泛型机制：JDK1.5之后引入的一个概念 //把类型明确工作，推迟到创建对象，或调用方法时，才去明确的一种机制。 //泛型的语法：<数据类型,数据类型> //泛型可以加在 接口上，类型，方法上 //泛型的好处：1.避免了向下转型，2.将问题提前到了编译期 //泛型的特点：泛型只在编译期有效，在运行期就擦除了。 //泛型可以限定，我这个集合中存储什么样的引用数据类型 //JDK1.7之前 泛型前面后面都得写上，JDK1.7可以省略右半边不写 ArrayList<Integer> list = new ArrayList<Integer>(); list.add(100); list.add(100); list.add(100); list.add(100); list.add(100); list.add(100); list.add(100); list.add(100); //泛型可以避免向下转型 ArrayList list2 = new ArrayList(); list2.add("aaaaa"); list2.add("bbbb"); list2.add("ccc"); list2.add("ddd"); Object obj = list2.get(0); String string= (String) obj; int length = string.length(); ArrayList<String> list3= new ArrayList(); list3.add("aaaaa"); list3.add("bbbb"); list3.add("ccc"); list3.add("ddd"); String s = list3.get(0); System.out.println(s); } }注意：集合都会去使用泛型，明确我集合中，该添加何种数据类型的元素
案例二：
import java.util.ArrayList; import java.util.Iterator; public class MyTest2 { public static void main(String[] args) { //泛型的使用，就避免了向下转型 ArrayList<Integer> list= new ArrayList(); list.add(100); list.add(100); list.add(100); list.add(100); list.add(100); list.add(100); list.add(100); list.add(100); list.add(100); list.add(100); list.add(100); list.add(100); // Integer integer = list.get(0); Iterator<Integer> iterator = list.iterator(); while (iterator.hasNext()){ Integer ele = iterator.next(); System.out.println(ele); } } }注意： 泛型的使用，就避免了向下转型
案例一：
import java.util.ArrayList; public class MyTest { public static void main(String[] args) { ArrayList<Student> list = new ArrayList<>(); list.add(new Student("张三",23)); list.add(new Student("张三", 23)); list.add(new Student("张三", 23)); list.add(new Student("张三", 23)); list.add(new Student("张三", 23)); list.add(new Student("张三", 23)); list.add(new Student("张三", 23)); list.add(new Student("张三", 23)); list.add(new Student("张三", 23)); for (int i = 0; i < list.size(); i++) { Student student = list.get(i); System.out.println(student.getName()+"=="+student.getAge()); } } } public class Student { private String name; private int age; public Student() { } public Student(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "Student{" + "name='" + name + '\'' + ", age=" + age + '}'; } }案例二：
public class MyTest { public static void main(String[] args) { MyObject myObject = new MyObject(); myObject.setObj("abc"); Object obj = myObject.getObj(); String str= (String) obj; System.out.println(str.length()); System.out.println("-----------------"); MyObject myObject1 = new MyObject(); myObject1.setObj(100); Object obj1 = myObject1.getObj(); Integer integer= (Integer) obj1; System.out.println(integer.intValue()); } } public class MyTest { public static void main(String[] args) { MyObject myObject = new MyObject(); myObject.setObj("abc"); Object obj = myObject.getObj(); String str= (String) obj; System.out.println(str.length()); System.out.println("-----------------"); MyObject myObject1 = new MyObject(); myObject1.setObj(100); Object obj1 = myObject1.getObj(); Integer integer= (Integer) obj1; System.out.println(integer.intValue()); } }A:泛型类概述: 把泛型定义在类上 B:定义格式: public class 类名<泛型类型1,…> C:注意事项: 泛型类型必须是引用类型
格式: public class 类名<数据类型 , …> {} */ public class ObjectTools {
private K k ;
public K getK() { return k; }
public void setK(K k) { this.k = k; }
}
案例一：
public class MyObject<M, U> { //泛型类 ，将泛型加在类上面 private M m; private U u; //private int a; //private String b; public M getM() { return m; } public void setM(M m) { this.m = m; } public U getU() { return u; } public void setU(U u) { this.u = u; } } public class MyTest { public static void main(String[] args) { //泛型机制：是JDK1.5之后，引入的一种机制 // 泛型，是把类型明确工作，推迟到，创建对象，或调用方法时，再去明确的一种机制 MyObject<String, Integer> object = new MyObject<>(); object.setM("abc"); object.setU(100); String m = object.getM(); Integer u = object.getU(); } }A:泛型方法概述: 把泛型定义在方法上 B:定义格式: public <泛型类型> 返回类型 方法名(泛型类型 变量名) C:案例演示: 泛型方法的使用 public class Phone {
/**
泛型方法 */ public void show(E e){ System.out.println(e); } } 案例一：
public class MyDemo { //public void show(Integer num){ // System.out.println(num); //} // //public void show(String num) { // System.out.println(num); //} // //public void show(Double num) { // System.out.println(num); //} // //public void show(Character num) { // System.out.println(num); //} //public void show(Object num) { // // // System.out.println(num); //} //泛型方法 public <T> void show(T num) { System.out.println(num); } } public class MyTest { public static void main(String[] args) { // //泛型机制：是JDK1.5之后，引入的一种机制 // // 泛型，是把类型明确工作，推迟到，创建对象，或调用方法时，再去明确的一种机制 MyDemo myDemo = new MyDemo(); myDemo.show(2.1); myDemo.show(100); myDemo.show("abc"); } }A:泛型接口概述: 把泛型定义在接口上 B:定义格式: public interface 接口名<泛型类型> C:案例演示: 泛型接口的使用 public interface Inter {
public abstract void show(T t) ; } /**
泛型接口的子类: 第一种情况: 就是在定义子类的时候我们已经可以明确数据类型了 / //public class InterImpl implements Inter { // // @Override // public void show(String t) { // System.out.println(t); // } // //} /*
泛型接口的子类: 第二种情况: 就是在定义子类的时候我们还不知道到底使用神马数据类型.这个时候我们就需要将这个子类定义
成泛型 */ public class InterImpl implements Inter {
@Override public void show(T t) { System.out.println(t); }
}
案例一：
public interface MyInterface<Y,M,E> {//泛型接口 Y set(M m,E e); } //接口上的泛型，在具体的实现类上 就可以明确 public class MyClass implements MyInterface<Integer,Integer,Integer>{ @Override public Integer set(Integer integer, Integer integer2) { return 100; } } public class MyTest { public static void main(String[] args) { //使用匿名内部类，在创建接口的子类对象时，如果接口上加有泛型，那么需要明确泛型的具体类型 new MyInterface<String, String, String>() { @Override public String set(String s, String s2) { return null; } }; } }A:泛型通配符<?>: 任意类型，如果没有明确，那么就是Object以及任意的Java类了 B:? extends E: 向下限定，E及其子类 C:? super E: 向上限定，E及其父类 D:案例演示: 泛型高级之通配符的基本使用 /**
泛型如果明确了数据类型以后,那么要求左右两边的数据类型必须一致 */ Collection col1 = new ArrayList() ; Collection col2 = new ArrayList() ;//报错 // ? 表示任意的数据类型 Collection<?> col5 = new ArrayList<Object>() ; Collection<?> col6 = new ArrayList<Animal>() ; // ? extends E : 向下限定 , ? 表示的是E或者E的子类 // Collection<? extends Animal> col9 = new ArrayList<Object>() ;//报错 Collection<? extends Animal> col10 = new ArrayList<Animal>() ; Collection<? extends Animal> col11 = new ArrayList<Dog>() ; // ? super E: 向上限定 , ? 表示的是E或者E的父类 Collection<? super Animal> col13 = new ArrayList<Object>() ; Collection<? super Animal> col14 = new ArrayList<Animal>() ;// Collection<? super Animal> col15 = new ArrayList() ;//报错
案例一：
import java.util.ArrayList; public class MyTest { public static void main(String[] args) { //泛型通配符 ArrayList<?> objects = new ArrayList<Dog>(); //向上限定 ArrayList<? super Animal> objects2 = new ArrayList<Object>(); ArrayList<? super Animal> objects3 = new ArrayList<Animal>(); //ArrayList<? super Animal> objects4 = new ArrayList<Dog>(); 错误的 //向下限定 ArrayList<? extends Animal> objects5 = new ArrayList<Animal>(); ArrayList<? extends Animal> objects6 = new ArrayList<Dog>(); ArrayList<? extends Animal> objects7 = new ArrayList<Cat>(); // ArrayList<? extends Animal> objects8 = new ArrayList<Object>(); 错误的 ArrayList<Integer> integers = new ArrayList<>(); integers.add(100); ArrayList<Integer> integers2 = new ArrayList<>(); integers2.add(10); integers.addAll(integers2); } } class Animal { } class Dog extends Animal { } class Cat extends Animal { }A:增强for概述 简化数组和Collection集合的遍历 B:格式： for(元素数据类型 变量 : 数组或者Collection集合) { 使用变量即可，该变量就是元素 } C:案例演示 数组，集合存储元素用增强for遍历 D:好处和注意事项 简化遍历 注意事项：增强for的目标要判断是否为null
案例一：
import java.util.ArrayList; public class MyTest { public static void main(String[] args) { ArrayList<Integer> list = new ArrayList(); list.add(100); list.add(100); list.add(100); list.add(100); list.add(100); list.add(100); list.add(100); list.add(100); list.add(100); list.add(100); list.add(100); list.add(100); //list.iterator(); //list.listIterator(); //遍历 //for (int i = 0; i < list.size(); i++) { // //} // //JDK1.5引入一种新的循环方式，可以用来遍历数组和集合 int[] arr={1,4,6,9,5}; //for (int i = 0; i < arr.length; i++) { // System.out.println(arr[i]); //} // //第一点：先确定你容器中的元素的数据类型 // 第二个就是容器的名字 //for(int a:arr){ // System.out.println(a); //} //for(Integer ele:list){ // System.out.println(ele); //} //for (Integer integer : list) { // //} //for (int i = 0; i < list.size(); i++) { // //} //for (Integer integer : list) { // //} } }注意几种遍历方式： 迭代器：iterator//listIterator for 新式for循环
注意使用新式for循环在遍历集合的途中，如果你往集合中添加，或删除元素时，会报并发修改异常
案例一：
import java.util.ArrayList; import java.util.ConcurrentModificationException; public class MyTest2 { public static void main(String[] args) { ArrayList<Integer> list = new ArrayList(); list.add(100); list.add(100); list.add(100); list.add(100); list.add(100); list.add(100); list.add(100); list.add(100); list.add(100); list.add(200); list.add(100); list.add(100); //注意使用新式for循环在遍历集合的途中，如果你往集合中添加，或删除元素时，会报并发修改异常 //for (Integer integer : list) { // if(integer.equals(200)){ // //list.remove(integer); // // ConcurrentModificationException // //list.add(10000); // } // //System.out.println(integer); //} for (int i = 0; i < list.size(); i++) { if (list.get(i).equals(200)) { //list.remove(integer); // ConcurrentModificationException list.add(10000); } } System.out.println(list); } }A:可变参数概述: 定义方法的时候不知道该定义多少个参数 B:格式: 修饰符 返回值类型 方法名(数据类型… 变量名){} C:注意事项： a: 这里的变量其实是一个数组 b: 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个
案例一：
public class MyTest { public static void main(String[] args) { int sum1 = add(1, 2); int sum2 = add(1, 2, 3); int sum3 = add(1, 2, 3, 4); //可变参数: 数据类型 ... 参数名 //可变参数其实就是个数组 System.out.println(sum1); System.out.println(sum2); System.out.println(sum3); } //C:注意事项： //a:这里的变量其实是一个数组 //b:如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个 private static int add(double num, int... a) { int sum = 0; for (int i : a) { sum += i; } return sum; } //private static int add(int i, int i1) { // return 0; //} // //private static int add(int i, int i1,int i2) { // return 0; //} // //private static int add(int i, int i1,int i2,int i3) { // return 0; //} }结果： 2 5 9
A:案例演示: Arrays工具类的asList(T… t)方法的使用: 将数组转换成集合 注意事项: 得到的集合长度是不可变的 你不能往这个转换后的集合中 添加元素（add） 和 删除元素(remove) 只能获取元素(get)
案例一：
import java.util.Arrays; import java.util.List; public class MyTest3 { public static void main(String[] args) { List<Integer> integers = Arrays.asList(100, 200, 300, 400, 500, 600); //当我们通过 Arrays.asList(100, 200, 300, 400, 500, 600);获取一个转换过来的集合 //那么这个集合的长度是固定的，你只能从里面取出元素用，而不能去增删元素 Integer integer = integers.get(0); //integers.remove(0); //integers.add(1); // Object[] objects = integers.toArray(); } }案例二：
import java.util.ArrayList; import java.util.Arrays; import java.util.List; public class MyTest2 { public static void main(String[] args) { //static <T > List < T > // asList(T...a) //把多个元素转换成集合 // List<Integer> integers = Arrays.asList(100, 200, 300, 400, 500, 600); int[] arr = {1, 2, 3}; Integer[] integers1 = {1, 2, 3}; Integer[] integers2 = {1, 2, 3}; Integer[] integers3 = {1, 2, 3}; //当我们使用 Arrays.asList()这个方法来转换集合的时候，如果我们传入一个或多个int[] 数组的时候，集合里面放的是数组的引用 List<int[]> ints = Arrays.asList(arr, new int[]{10}, new int[]{1, 6, 7}); System.out.println(ints); //当我们使用 Arrays.asList()这个方法来转换集合的时候，如果我们传入一个Integer[] 数组，那么他会把数组的元素取出来放到集合中 List<Integer> integers99992 = Arrays.asList(integers1); //当我们使用 Arrays.asList()这个方法来转换集合的时候，如果我们传入多个Integer[] 数组的时候，集合放的是每个Integer[] 数组的引用 List<Integer[]> integers9999 = Arrays.asList(integers1, integers2, integers3); System.out.println(integers9999); } }A:需求： 我们班有学生，每一个学生是不是一个对象。所以我们可以使用一个集合表示我们班级的学生。ArrayList 但是呢，我们旁边是不是还有班级，每个班级是不是也是一个ArrayList。 而我现在有多个ArrayList。也要用集合存储，怎么办呢? 集合嵌套之ArrayList嵌套ArrayList
// 定义大的集合 ArrayList<ArrayList<Student>> allClassList = new ArrayList<ArrayList<Student>>() ; // 创建每一个班的集合 ArrayList<Student> jcClassList = new ArrayList<Student>() ;案例一： //A: //需求： //我们班有学生，每一个学生是不是一个对象。所以我们可以使用一个集合表示我们班级的学生。ArrayList //但是呢，我们旁边是不是还有班级，每个班级是不是也是一个ArrayList。 //而我现在有多个ArrayList。也要用集合存储，怎么办呢 ? // 集合嵌套之ArrayList嵌套ArrayList
public class Student { private String name; private int age; public Student() { } public Student(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "Student{" + "name='" + name + '\'' + ", age=" + age + '}'; } } import com.sun.media.sound.SoftTuning; import java.util.ArrayList; public class MyTest { public static void main(String[] args) { //A: //需求： //我们班有学生，每一个学生是不是一个对象。所以我们可以使用一个集合表示我们班级的学生。ArrayList<Student> //但是呢，我们旁边是不是还有班级，每个班级是不是也是一个ArrayList<Student>。 //而我现在有多个ArrayList<Student>。也要用集合存储，怎么办呢 ? // 集合嵌套之ArrayList嵌套ArrayList ArrayList<Student> javaList = new ArrayList<>(); javaList.add(new Student("张三1", 23)); javaList.add(new Student("张三2", 23)); javaList.add(new Student("张三3", 23)); ArrayList<Student> webList = new ArrayList<>(); webList.add(new Student("张三4", 23)); webList.add(new Student("张三5", 23)); webList.add(new Student("张三6", 23)); ArrayList<Student> linuxList = new ArrayList<>(); linuxList.add(new Student("张三7", 23)); linuxList.add(new Student("张三8", 23)); linuxList.add(new Student("张三9", 23)); //创建一个大的集合，大的集合放小的集合 ArrayList<ArrayList<Student>> maxList = new ArrayList<>(); maxList.add(javaList); maxList.add(webList); maxList.add(linuxList); // //遍历：普通for循环 for (int i = 0; i < maxList.size(); i++) { ArrayList<Student> minList = maxList.get(i); for (int j = 0; j < minList.size(); j++) { Student student = minList.get(j); System.out.println(student.getName() + "===" + student.getAge()); } } System.out.println("----------------------------------------------------------"); //新式for循环遍历 for (ArrayList<Student> students : maxList) { for (Student student : students) { System.out.println(student.getName() + "===" + student.getAge()); } } } }