JAVASE基础模块二十四（泛型）
泛型的引出
- 我们这样定义一个obj类的时候 使用的时候需要向下转型 会很麻烦
public class Fananan {
public static void main(String[] args) {
Dec dec = new Dec();
//向下转型太麻烦
dec.setU(200);
Integer d= (Integer) dec.getU();
System.out.println(d);
}
}
class Dec{
private Object u;
public Dec(Object u) {
this.u = u;
}
public Dec() {
}
public Object getU() {
return u;
}
public void setU(Object u) {
this.u = u;
}
}
运行结果：
200
进程已结束,退出代码0
泛型的概念
public class Ffffff {
public static void main(String[] args) {
Fanxd<String> stringFanxd = new Fanxd<>();
stringFanxd.setT("ddddd");
String r=stringFanxd.getT();
System.out.println(r);
Fanxd<Integer> integerFanxd = new Fanxd<>();
integerFanxd.setT(200);
Integer y=integerFanxd.getT();
System.out.println(y);
}
}
class Fanxd<T> {
private T t;
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
}
运行结果：
ddddd
200
Process finished with exit code 0
-
泛型机制：JDK1.5之后引入的一种机制
-
泛型机制：就是把数据类型明确工作 推迟到创建对象或调用方法时 才去明确的一种机制
-
泛型的好处，能够提高代码的扩展性 避免了向下转型 可以将问题提前到编译期
-
泛型 只在编译期 有效在运行期 就擦除了
import java.util.ArrayList; import java.util.Objects; public class Fanx { public static void main(String[] args) { ArrayList e=new ArrayList<String>(); e.add("fghdsfssd"); e.add(100); e.add("fgh"); e.add(3.215); Object u=e.get(0); String s=(String)u; System.out.println(s.length()); System.out.println(s); System.out.println("-----------"); ArrayList<String> ee=new ArrayList<String>(); ee.add("fghdsfssd"); ee.add("sgsfgh"); ee.add("fgh"); ee.add("fsggdfsh"); String uu=ee.get(0); System.out.println(uu.length()); System.out.println(uu); } } 运行结果： 9 fghdsfssd ----------- 9 fghdsfssd- 学生类的泛型类型添加
import java.util.ArrayList; import java.util.Iterator; import java.util.Objects; public class Fanx { public static void main(String[] args) { ArrayList<Studentx> d=new ArrayList<Studentx>(); d.add(new Studentx("JayZhou", 26)); d.add(new Studentx("JayZhou", 26)); d.add(new Studentx("JayZhou", 26)); d.add(new Studentx("sanwa",26)); d.add(new Studentx("wanwa",26)); d.add(new Studentx("lucis",26)); d.add(new Studentx("sanwa",26)); Iterator<Studentx> fff = d.iterator(); while (fff.hasNext()){ System.out.println(fff.next()); } } } class Studentx { private String name; private int age; public Studentx() { } public Studentx(String name, int age) { this.name = name; this.age = age; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Studentx studentx = (Studentx) o; return age == studentx.age && Objects.equals(name, studentx.name); } @Override public int hashCode() { return Objects.hash(name, age); } @Override public String toString() { return "Studentx{" + "name='" + name + '\'' + ", age=" + age + '}'; } } 运行结果： Studentx{name='JayZhou', age=26} Studentx{name='JayZhou', age=26} Studentx{name='JayZhou', age=26} Studentx{name='sanwa', age=26} Studentx{name='wanwa', age=26} Studentx{name='lucis', age=26} Studentx{name='sanwa', age=26} 进程已结束,退出代码0 -
类的泛型
public class Demo { public static void main(String[] args) { num s1 = new num<>(); s1.show("xxxx"); s1.show("cccc"); s1.show(3.14); s1.show(5.55588); s1.show(555); s1.show(777); } } class num<A> { public void show(A a) { System.out.println(a); } } 运行结果： xxxx cccc 3.14 5.55588 555 777 Process finished with exit code 0 -
接口的泛型
- 使用匿名内部类 创建接口的子类对象的时候 可以明确接口的泛型类型
- 子类实现接口时 可以明确接口的泛型类型
public class JieKou { public static void main(String[] args) { new Gui<String>(){ @Override public void test(String s) { } }; } } interface Gui<A>{ public abstract void test(A a); } class Dei implements Gui<Integer> { @Override public void test(Integer integer) { } }
泛型通配符 与向上限定 .向下限定
public class Tee {
public static void main(String[] args) {
//?泛型通配符
ArrayList<?> ss = new ArrayList<Animal>();
ArrayList<?> ssx = new ArrayList<Dog>();
ArrayList<?> ssc = new ArrayList<Cat>();
System.out.println("-----------------------------");
//向上限定
ArrayList<? super Cat> sscc = new ArrayList<Cat>();
ArrayList<? super Animal> sscx = new ArrayList<Animal>();
ArrayList<? super Animal> ssxx = new ArrayList<Object>();
//向下限定
ArrayList<? extends Animal> r = new ArrayList<Animal>();
ArrayList<? extends Animal> rr = new ArrayList<Cat>();
ArrayList<? extends Animal> rrr = new ArrayList<Dog>();
}
}
class Animal {}
class Cat extends Animal {}
class Dog extends Animal {}
可变参数
- 可变参数 一次可以接受多个同类型的参数
- 可变参数 本质是个数组
- 如果一个方法的形参有多个参数 可变参数应该是最后一个
public class KeBian {
public static void main(String[] args) {
int sum=add(10,33,77);
int sum1=add(10,33,77,77,33);
int sum2=add(10,33,77,777,333);
System.out.println(sum);
System.out.println(sum1);
System.out.println(sum2);
}
public static int add(int m,int... a){
System.out.println(a.length);
int sum=m;
for (int i : a) {
sum+=i;
}
return sum;
}
}
运行结果：
2
4
4
120
230
1230
进程已结束,退出代码0
数组集合转换
-
数组转换集合
- 传入的是基本类型的数组 把这个数组对象放到集合里
- 传入的是包装类型的数组 把这个数组中的元素 取出来放到集合里
- 传入多个包装类型的数组 把多个数组对象 取出来放到集合里
import java.util.Arrays; import java.util.List; public class ZhuanHuan { public static void main(String[] args) { int[] a={11,22,33,44,55,66}; List<int[]> s = Arrays.asList(a); System.out.println(a); System.out.println(s.get(0)[0]); Integer[] a1={111,222,333,444,555,666}; List<Integer> s1 = Arrays.asList(a1); System.out.println(s1); Integer[] a3={111,222,333,444,555,666}; Integer[] a4={1,2,3,4,5,6}; List<Integer[]> s2 = Arrays.asList(a3,a4); System.out.println(s2.get(1)[5]); } } 运行结果： [I@723279cf 11 [111, 222, 333, 444, 555, 666] 6 进程已结束,退出代码0 -
注意事项
- 通过 Arrays.asList(a3,a4)得到的集合 不能再次改变集合长度
- 也就是不能再增删元素
- 会出现UnsupportedOperationException
- 因为此方法返回的是Arrays的一个内部类 定义了一个底层数组
- 底层数组长度一旦确定无法再改变
public class Cuowu { public static void main(String[] args) { List<Integer> s1 = Arrays.asList(111,222,333,444,555,666); s1.remove(0);}} 运行结果： Exception in thread "main" java.lang.UnsupportedOperationException
List集合嵌套循环
- 学生 班级 嵌套
import java.util.ArrayList;
public class LianXi {
public static void main(String[] args) {
Cl cl = new Cl();
cl.setName("JAVA");
Student xx8 = new Student("xx", 10);
Student xx1 = new Student("xx", 10);
Student xx2 = new Student("xx", 10);
Cl cl1 = new Cl();
cl.setName("PYTHON");
Student xx4 = new Student("cc", 33);
Student xx5 = new Student("cc", 33);
Student xx6 = new Student("cc", 33);
ArrayList<ArrayList<Student>> cls = new ArrayList<>();
ArrayList<Student> xx = new ArrayList<>();
ArrayList<Student> xa = new ArrayList<>();
cls.add(xx);
xx.add(xx8);
xx.add(xx1);
xx.add(xx2);
cls.add(xa);
xx.add(xx4);
xx.add(xx5);
xx.add(xx6);
for (int i = 0; i < cls.size(); i++) {
for (int i1 = 0; i1 < cls.get(i).size(); i1++) {
System.out.println(cls.get(i).get(i1));
}
}
System.out.println("----------------");
for (ArrayList<Student> students : cls) {
for (Student student : students) {
System.out.println(student);
}
}
}
}
class Cl {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Cl{" +
"name='" + name + '\'' +
'}';
}
}
class Student extends Cl {
private String namec;
private int age;
public Student() {
}
public Student(String namec, int age) {
this.namec = namec;
this.age = age;
}
public String getNamec() {
return namec;
}
public void setNamec(String namec) {
this.namec = namec;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"namec='" + namec + '\'' +
", age=" + age +
'}';
}
}
运行结果：
Student{namec='xx', age=10}
Student{namec='xx', age=10}
Student{namec='xx', age=10}
Student{namec='cc', age=33}
Student{namec='cc', age=33}
Student{namec='cc', age=33}
----------------
Student{namec='xx', age=10}
Student{namec='xx', age=10}
Student{namec='xx', age=10}
Student{namec='cc', age=33}
Student{namec='cc', age=33}
Student{namec='cc', age=33}
Process finished with exit code 0
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
