package com.zjw.泛型;
import lombok.Data;
public class PointTest {
public static void main(String[] args) {
/*
* 1.了解泛型 没有使用泛型
*/
//新建一个对象 没有泛型 对象中属性为Object
//1.传入两个 String 类型
Point point1 = new Point("x轴坐标", "y轴坐标");
String x1 = (String) point1.getX(); //正常获取
//2.传入两个 Integer 类型
Point point2 = new Point(12, 13);
Integer x2 = (Integer) point2.getX();
//3.传入一个 Integer 类型,一个 String 类型
Point point3 = new Point(12, "y轴坐标");
Integer x3 = (Integer) point3.getX();
String y3 = (String) point3.getY();
//Integer y3 = (Integer) point3.getY(); //写的时候不会报错，编译时会有类型不安全异常
/*
* 1.1所以使用泛型来要求类的属性为指定类型 --类名<泛型,泛型...>
* 1.2定义泛型类
*/
//新建一个泛型对象 添加泛型
PointT<String> stringPointT = new PointT<>("x轴坐标1", "y轴坐标2");
System.out.println(stringPointT);
PointT<Integer> integerPointT = new PointT<>(12, 13);
System.out.println(integerPointT);
//PointT<Integer> integerPointT1 = new PointT<>("x轴坐标1", 13); //未按泛型要求 报错
//两个不同类型的泛型 String , Integer
PointTE<String, Integer> stringIntegerPointTE = new PointTE<>("x轴坐标1",15);
System.out.println(stringIntegerPointTE);
/*
* 2.通配符 ?
*/
Info<Integer> info = new Info<>();
info.setVar(14);
Info<String> info1 = new Info<>();
info1.setVar("通配符是?");
//fun(info);
fun(info1); //泛型方法只接收相同类 泛型相同 的类
fun1(info); //使用通配符可以接受任意泛型的类
fun1(info1);
/*
* 3.受限泛型
* 泛型上限 <? extends 类>
* 泛型下限 <? super 类>
*/
//泛型上限
Info<Integer> info2 = new Info<>();
fun2(info2); //满足泛型上限 Integer 是 Number 子类
Info<Object> info21 = new Info<>();
Info<String> info22 = new Info<>();
//fun2(info21); //超出泛型上限 Object 为 Number 父类 需要其为子类
//fun2(info22); //超出泛型上限 String 不为 Number 类 需要其为子类
//泛型下限
Info<Integer> info3 = new Info<>();
//fun3(info3); // Integer 为 Number 子类 不到泛型下限 泛型需要为其父类
Info<Object> info31 = new Info<>();
Info<String> info32 = new Info<>();
fun3(info31); // Object 为 Number 父类 满足泛型下限
//fun3(info32); // String 不为 Number 类 不满足泛型下限
/*
* 4.泛型接口 USB<T>
* 4.1 类实现泛型接口时为其指定泛型类型 class Mouse implements USB<String>{}
* 4.2 类实现接口时同时也设置类为泛型类 泛型标识符要一致 class Upan<T> implements USB<T> {}
*/
//4.1 类实现泛型接口时为其指定泛型类型
Mouse mouse = new Mouse();
mouse.use("鼠标");
//4.2 类实现接口时同时也设置类为泛型类 泛型标识符要一致
Upan<String> stringUpan = new Upan<String>();
stringUpan.use("U盘");
/*
* 5.泛型方法 public <T> T fun4(T a) {return a;}
*/
PointTest pointText = new PointTest();
Integer i = pointText.fun4(15);
String s = pointText.fun4("15 String");
}
/**
* 2.通配符 ?
*/
//不推荐的方法
public static void fun(Info<String> info) {
info.show();
}
//使用通配符的方法
public static void fun1(Info<?> info) { //能够让泛型接受任意泛型类型 必须使用通配符 ? 是泛型的通配符
info.show();
}
/**
* 3.受限泛型
*/
//泛型上限 <? extends 类>
public static void fun2(Info<? extends Number> info) {
info.show();
}
//泛型下限 <? super 类>
public static void fun3(Info<? super Number> info) {
info.show();
}
/**
* 5.泛型方法 fun4
*/
public <T> T fun4(T a) {
System.out.println("---------------"+a);
return a;
}
}
/**
* 定义泛型类
*/
@Data
class Info<T> {
private T var;
public void show() {
System.out.println("var===" + var);
}
}
/**
* 4.泛型接口 USB<T>
*/
interface USB<T> {
public abstract void use(T s);
}
//4.1 类实现泛型接口时为其指定泛型类型 Mouse
class Mouse implements USB<String> {
@Override
public void use(String s) {
System.out.println("s===" + s);
}
}
//4.2 类实现接口时同时也设置类为泛型类 泛型标识符要一致 Upan<T>
class Upan<T> implements USB<T> {
@Override
public void use(T s) {
System.out.println("s===" + s);
}
}
