泛型
概念：泛型就是参数化类型，使用广泛的类型。
起因：数据类型不明确：
- 装入的数据类型都被当作Object对待，从而丢失自己的实际类型
- 获取数据时往往需要转型，效率低，容易产生错误
作用：
- 安全：在编译的时候检查类型安全
- 省心：所有的强制转换都是自动和隐式的，提高代码的重用率
泛型类：
package fanxing;
//116 泛型 -->泛型类
/**
* 注意： 1.泛型只能使用引用类型，不能基本类型
* 2.泛型声明时字母不能使用在静态属性，方法上
* （泛型是在使用时候确定的，而静态属性和方法出现在编译时）
*/
public class Student<T1, T2> {
private T1 javascore;
private T2 pyscore;
public T1 getJavascore() {
return javascore;
}
public void setJavascore(T1 javascore) {
this.javascore = javascore;
}
public T2 getPyscore() {
return pyscore;
}
public void setPyscore(T2 pyscore) {
this.pyscore = pyscore;
}
public static void main(String[] args) {
// 使用时候指定类型（引用类型）
Student<String, Integer> s1 = new Student<String, Integer>();
// 1.安全：类型检查
s1.setJavascore("优秀");
s1.setPyscore(88);
// 2.省心：类型转换
String java=s1.getJavascore();
int py = s1.getPyscore();
System.out.println(java);
System.out.println(py);
}
}
泛型接口
package fanxing;
/*
* 116 泛型 -->泛型接口
* 接口中泛型字母只能用在方法中，不能用在全局常量中
*
* */
public interface Fanxingjiekou<T> {
void jiekou(T t);
}
泛型方法
package fanxing;
/*
* 116 泛型 -->泛型方法
* 修饰符 <> 返回值类型
* 只能访问对象信息，不能修改
* */
public class Test {
public static void main(String[] args) {
test(123);
test("aaa");
}
public static <T> void test(T a) {
System.out.println(a);
}
}
泛型的继承
继承|实现
1.保留 -->泛型子类
2不.保留 -->按需实现，可以是泛型子类，也可以非泛型子类
属性和方法：随声明位置而定
擦除：使用继承实现 没有指定类型，类似于Object
package fanxing;
//117 泛型的继承
public abstract class Father<T1, T2> {
T1 age;
public abstract void test(T2 name);
}
// * 保留 -->泛型子类
// 1.全部保留
class C1<T2, T1, A, B> extends Father<T1, T2> {
@Override
public void test(T2 name) {
}
}
// 2.部分保留
class C2<T2> extends Father<Integer, T2> {
@Override
public void test(T2 name) {
}
}
// * 不保留
// 1.具体类型 -->按需实现
class C3 extends Father<Integer, String> {
@Override
public void test(String name) {
}
}
// 2.没有类型 擦除
class C4 extends Father {
@Override
public void test(Object name) {
}
}
泛型通配符
package fanxing;
import java.util.ArrayList;
import java.util.List;
//118 通配符，类型不确定，用于声明变量，形参上
//不能用在
//1.创建对象
//2.创建泛型类，泛型方法，泛型接口上
//也即只能用来声明，而不能创建（不能使用的时候都不知道是什么类型）
public class Tongpeifu {
public static void main(String[] args) {
//声明
List<?> list =new ArrayList<Integer>();
list=new ArrayList<String>();
list=new ArrayList<Object>();
test(list);
//编译错误不能用在创建对象
// list =new ArrayList<?>();
}
public static void test(List<?> list){}
class Test<T>{}
//编译错误不能用在创建泛型类
//class Test2<?>{}
//编译错误不能用在创建泛型方法
//public static <?> void name() {}
}
泛型的上限
package fanxing;
import java.util.ArrayList;
import java.util.List;
/*
* extends:泛型的上限
* 1.一般用于限制操作
* 2.不能使用在添加数据上面，一般是读取操作
*
* */
public class TestExtends {
public static void main(String[] args) {
// extends为上限
Test<Fruit> t1=new Test<Fruit>();
Test<Apple> t2=new Test<Apple>();
List<? extends Fruit> list=new ArrayList<Fruit>();
test(list);
List<Fruit> list2=new ArrayList<Fruit>();
test(list2);
List<Apple> list3=new ArrayList<Apple>();
test(list3);
}
//? extends Fruit
public static void test(List<? extends Fruit> list) {
//不能用于添加数据
// list.add(new Apple());
// list.add(new FushiApple());
// list.add(new Pear());
list.add(null);
}
//泛型类
static class Test<T extends Fruit>{}
}
泛型的下限
package fanxing;
import java.util.ArrayList;
import java.util.List;
public class TestSuper {
/*
* 118 泛型的下限
* */
public static void main(String[] args) {
List<Apple> list1=new ArrayList<Apple>();
test(list1);
List<Fruit> list2=new ArrayList<Fruit>();
test(list2);
List<Object> list3=new ArrayList<Object>();
test(list3);
//规则
List<? super Apple> list4=new ArrayList<Apple>();
test(list4);
List<? super Apple> list5=new ArrayList<Object>();
test(list5);
List<? super FushiApple> list6=new ArrayList<Object>();
//test(list6);
}
public static void test(List<? super Apple> list){
//能用于添加数据，不能添加父对象
list.add(new Apple());
list.add(new FushiApple());
//list.add(new Fruit());
}
}
泛型没有多态,数组
package fanxing;
import java.util.ArrayList;
import java.util.List;
//泛型没有多态,数组
public class Meiduotai {
public static void main(String[] args) {
Fruit f1=new Apple();
Fruit[] f2=new Fruit[5];
//List<Fruit> list=new ArrayList<Apple>();
List<? extends Fruit> list=new ArrayList<Apple>();
}
}