1、什么是泛型？
常见的泛型在集合中，在定义时不给类中成员 [属性 方法返回类型 方法的参数] 的数据类型，而在类对象创建时为其指定相应的数据类型。
2. 为什么使用泛型？
我们在给Point类中属性赋值时可以赋值任意类型，在后面获取相应属性时，会出现数据类型安全问题。
public class Point {
private Object x;
private Object y;
public Point(Object x, Object y) {
this.x = x;//Object是所有类型的父类，任何类型都能自动向上转型
this.y = y;
}
@Override
public String toString() {
return "Test{" +
"x=" + x +
", y=" + y +
'}';
}
public Object getX() {
return x;
}
public void setX(Object x) {
this.x = x;
}
public Object getY() {
return y;
}
public void setY(Object y) {
this.y = y;
}
}
public class Test {
public static void main(String[] args) {
//x y 的值都是字符串类型
Point p1 = new Point("东经145","北纬35");
//x y 都是整型
Point p2 = new Point( 180,25);
//x y 都是小数
Point p3 = new Point(145.6,35.3);
//可以一个为字符串一个为整型
Point p4 = new Point("东经145","35");
//数据不安全问题，我们可以使用泛型来解决上面的数据类型安全问题
String x = (String) p4.getX();
String y = (String) p4.getY();
}
}
3. 如何定义类的泛型？
public class 类名<泛型标志，泛型标志>{
public 泛型标志 属性名;}
泛型标志可以是任意字符。
public class Point<T> {
private T x;
private T y;
@Override
public String toString() {
return "Point{" +
"x=" + x +
", y=" + y +
'}';
}
public Point(T x, T y) {
this.x = x;
this.y = y;
}
public T getX() {
return x;
}
public void setX(T x) {
this.x = x;
}
public T getY() {
return y;
}
public void setY(T y) {
this.y = y;
}
}public class Test {
public static void main(String[] args) {
//全部是字符串类型
Point<String> p1 = new Point<String>("东经159度","北纬35度");
String x = p1.getX();
String y = p1.getY();
//全部是数字类型 有数据类型转换问题 不出现数据类型安全问题
Point<Integer> p2 = new Point<>(175,35);
Integer x1 = p2.getX();
Integer y1 = p2.getY();
}
}4. 通配符
在开发中对象的引用传递是最常见的，但是如果在泛型类的操作中，在进行引用传递时泛型类型必须匹配才可以传递，否则是无法传递的。
static class Info<T>{
private T var;
public void show(){
System.out.println("var的值="+var);
}
public T getVar() {
return var;
}
public void setVar(T var) {
this.var = var;
}
}public class Point {
public static void main(String[] args) {
Info<String> i = new Info<String>();
i.setVar("1111111");
Info<Integer> i1=new Info<Integer>();
i1.setVar(15);
Info<Double> i2=new Info<Double>();
i2.setVar(23.4);
fun(i);
fun(i2);
//引用时类型必须泛型相同、类型相同
}
//<?> 加上通配符可以让他接受任意的泛型类型
public static void fun(Info<?> info){
info.show();
}
//fun该方法的参数为引用类型为泛型
/* public static void fun(Info<String> info){
info.show();
}*/
}4.2受限类型
[设置上限]
声明对象: 类名称<? extends 类> 对象名称;
定义类: [访问权限] 类名称<泛型标识 extends 类>{}[设置下限]
声明对象: 类名称<? super 类> 对象名称;
定义类: [访问权限] 类名称<泛型标识 super 类>{}
public class Test {
public static void main(String[] args) {
Info<Integer> i = new Info<Integer>();
Info<Number> i2 = new Info<Number>();
Info<String> i3 = new Info<String>();
Info<Object> i4 = new Info<Object>();
/*fun01(i);
fun01(i2);
String不属于number的子类
fun01(i3); */
fun02(i4);
}
//泛型的下限类型 不能小于Number 可以是Number类型也可以是Number的父类类型。
public static void fun02(Info<? super Number> info) {
info.show();
}
//泛型上限:泛型类型不能超过Number这个类型 可以是Number类型也可以是Number的子类
public static void fun01(Info<? extends Number> info) {
info.show();
}
}
class Info<T> {
private T var;
public void show() {
System.out.println("var===========" + var);
}
@Override
public String toString() {
return "Info{" +
"var=" + var +
'}';
}
public T getVar() {
return var;
}
public void setVar(T var) {
this.var = var;
}
}泛型通配符：<?>
泛型的上限：<? extends 类>
下限：<? super 类>
5. 如何定义泛型接口
public interface 接口名<泛型标识,....>{
}
接口用来被类实现有两种方式：
1.在实现泛型接口时为泛型接口指定类型。
2. 该类也是一个泛型类，而且该类使用的泛型标志必须和接口的标志一致。
public class Test { public static void main(String[] args) { Asus a =new Computer(); a.hs("华硕"); lenovo<Integer> le=new lenovo<Integer>(); le.hs(1111); } } interface Asus<T>{ public abstract void hs(T t); } //第一种 类实现泛型接口时为其指定泛型类型 class Computer implements Asus<String>{ public void hs(String s){ System.out.println(s); } } //第二种方法类实现接口时该类也设置为泛型类，标志必须和接口的泛型标志一致 class lenovo<T> implements Asus<T>{ public void hs(T t){ System.out.println(t); } }
6. 如何定义泛型方法
前面学习的所有泛型操作都是将整个类进行泛型化，但同样也可以在类中定义泛型化的方法。泛型方法的定义与其所在的类是否是泛型类是==没有任何关系的==，所在的类可以是泛型类，也可以不是泛型类。
【泛型方法的简单定义】
[访问权限] <泛型标识> 泛型标识 方法名称(泛型标识 参数名称){
}
7. 注解
7. 1预定义注解
@Override: 当方法使用该注解时，表示该方法是一个重写的方法，那么该方法必须符合重写的规则【子类重写的方法名必须和父类的方法名一致，参数也要一致，返回值也要一致 访问修饰不能小于父类的<public protected 默认 private> 抛出的异常不能大于父类】。
@Deprecated: 标记该方法已经过时。JVM
@FuncationInterface: 函数式接口.---要求接口钟有且仅有一个抽象方法
7. 2自定义注解
语法：
public @interface 注解名{
}
public class Test {
public static void main(String[] args) {
Hello h = new Hello();
h.show();
}
}
//自定义注解
@interface gtr{
}
@gtr
class Hello{
@gtr
private String name;
@gtr
public void show(){
}
}使用了自定义注解并没有任何意思，要想让他有意义，必须结合后反射来解析这些注解，并赋予相应的作用。
@Override:----JVM解析了该注解
@Controller:---spring框架解析了该注解。
7.3元注解
思考: @Controller只能使用在类上。 @GetMapping只能使用在方法。为什么这些注解可以限制它的使用范围。因为它们用来元注解来限制。
@Retention: 限制注解什么时候生效。【源码---javac---字节码----运行】
//源码时生效
SOURCE,//字节码时生效
CLASS,//运行时生效。反射。
RUNTIME@Target: 该注解可以使用在哪些地方
//使用在类上
TYPE,//使用在属性上
FIELD,//使用在方法上
METHOD,//使用在参数
PARAMETER,//使用在构造方法上
CONSTRUCTOR@Documented: 在生成api文档是是否含有该注解
7.4自定义注解属性
//自定义注解只能使用在类和方法上.默认可以在任何位置使用
@Target(value= {ElementType.TYPE,ElementType.METHOD,ElementType.FIELD,ElementType.PARAMETER})
//默认在字节码生效
@Retention(value = RetentionPolicy.RUNTIME)
@interface My{
String value() default "";
int age() default 22;
String[] hobby() default {};
}
//如只为value赋值，那可以省略value属性名
@My(value = "Hello")
class Hello{
private String name;
public void show( String n){
System.out.println("~~~~~~~~~~~~~~~~~~~"+n);
}
}
}
扫一扫
1173
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
