1. java高级--泛型

1. 什么是泛型?
2. 为什么使用泛型?
3. 如何使用泛型?
4. 泛型类
5. 泛型的通配符
6. 泛型的上限和下限
7. 泛型接口
8. 泛型方法

2.什么是泛型?

其实我们再使用集合时就用过泛型List<T> 创建一个List对象List<Student> list=new ArrayList();

<T>它就是泛型。

所谓的泛型就是在类定义时,不为类中属性和方法指定数据类型，而是在类对象创建时为其指定相应的数据类型。

3. 为什么使用泛型?

例子: 要求定义一个Point点类，该类中属性有x坐标和y坐标。

要求: x和y的值可以都是整数类型。

x和y的值可以都是小数类型。

x和y的值可以都是字符串类型。

如何定义该类呢? 如何确定属性的类型。----Object类型

package demo1;/*** @author: jh* @create: 2022/7/13*/
public class Point {/*x坐标*/private Object x;/*y坐标*/private Object y;/*输出坐标的值*/public void show(){System.out.println("x坐标:"+x+"；y坐标:"+y);}public Point(){}public Point(Object x, Object y) {this.x = x;this.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;}
}

package demo1;/*** @author: jh* @create: 2022/7/13*/
public class Test {public static void main(String[] args){Point p1=new Point(2,5);p1.show();Point p2=new Point(12.1,23.2);p2.show();Point p3=new Point("东经120度","北纬23度");p3.show();Point p4=new Point(21,"东京喰种");p4.show();}
}

但是:如果我们为坐标一个赋值整数，一个赋值为字符串，这时会不会报错。

Point p4=new Point(21,"东京喰种");p4.show();

但是它违背了我们设计的要求，这就是我们提到的数据类型安全问题。如何解决数据类型安全问题?

可以使用泛型来解决。

package demo2;/*** @author: jh* @create: 2022/7/13*/
public class Point<P> {private P x;private P y;public void show(){System.out.println("x坐标:"+x+"；y坐标"+y);}public Point(){}public Point(P x, P y) {this.x = x;this.y = y;}public P getX() {return x;}public void setX(P x) {this.x = x;}public P getY() {return y;}public void setY(P y) {this.y = y;}
}

package demo2;/*** @author: jh* @create: 2022/7/13*/
public class Test {public static void main(String[] args){Point<Integer> p1 = new Point<Integer>(10,20);//坐标为整数int--自动装箱->Integer--->Object(向上转型)p1.show();Point<Double> p2=new Point<Double>(12.1,23.2);p2.show();Point<String> p3= new Point<String>("东经120度","北纬38度");p3.show();}
}

注意: 上面的泛型类型必须都是引用类型。不能是基本类型。

使用泛型就保证了数据类型安全问题。

4. 如何定义泛型

泛型可以定义在类上，接口上，方法上。泛型类，泛型接口以及泛型方法。

泛型可以解决数据类型的安全性问题，其主要原理是在类声明时通过一个==标识表示类中某个属性的数据类型或者是某个方法的返回值及参数类型==。这样在类声明或者实例化时只要指定好需要的类型即可。

格式:

public class 类名<泛型标志,泛型标志....>{
//类成员
}

package demo3;/*** @author: jh* @create: 2022/7/13*/
public class Test {public static void main(String[] args) {Info<String> info = new Info<>();info.setVar("hello");info.show();Info<Integer> info1 = new Info<>();info1.setVar(15);info1.show();/*如果没有指定泛型类型默认为Object*/Info info2 = new Info();info2.setVar("啦啦啦啦啦");String o = (String) info2.getVar();System.out.println(o);}
}
//T标志可以任意起名.----> 那么在创建对象时，必须为每个泛型指定数据类型。class Info <I>{private I var;public void show(){System.out.println("var====="+var);}public I getVar() {return var;}public void setVar(I var) {this.var = var;}}

5. 通配符

在开发中对象的==引用传递==是最常见的，但是如果在泛型类的操作中，在进行==引用传递时泛型类型必须匹配才可以传递，否则是无法传递的==。如果想传递，可以定义泛型为?通配符。

package demo4;/*** @author: jh* @create: 2022/7/13*/
public class Test {public static void main(String[] args){Info<Integer> info = new Info<>();info.setVar(200);fly(info);Info<String> info1 = new Info<>();info1.setVar("lalalala");//如果为泛型类型:不但要求数据类型相同之外还要求泛型类型也匹配。fly(info1);Info<Double> info2 = new Info<>();info2.setVar(12.3);fly(info2);}//该方法的参数为Info而且它的泛型为Integer类型public static void fly(Info<?> info){info.show();}
}class Info<I>{private I var;public void show(){System.out.println("var======="+var);}public I getVar() {return var;}public void setVar(I var) {this.var = var;}
}

6. 受限泛型

在引用传递中，在泛型操作中也可以设置一个泛型对象的==范围上限==和==范围下限==。范围上限使用extends关键字声明，表示参数化的类型可能是所指定的类型或者是此类型的子类，而范围下限使用super进行声明，表示参数化的类型可能是所指定的类型或者此类型的父类型。

语法:

[设置上限]

声明对象: 类名称<? extends 类> 对象名称;

定义类: [访问权限] 类名称<泛型标识 extends 类>{}

[设置下限]

声明对象: 类名称<? super 类> 对象名称;

定义类: [访问权限] 类名称<泛型标识 super 类>{}

package demo5;/*** @author: jh* @create: 2022/7/13*/
public class Test {public static void main(String[] args){Info<Number> i = new Info<>();fun1(i);Info<Object> i1 = new Info<>();fun1(i1);Info<Integer> i2 = new Info<>();}//传递的参数泛型类型必须为Number的父类或者Number类型public static void fun(Info<? extends Number> info){info.show();}//传递的参数泛型类型必须为Number的子类或者Number类型public static void fun1(Info<? super Number> info){info.show();}
}//当创建该类对象时，泛型必须为Number的子类以及Number类型
class People<I extends Number>{}class Info<I>{private I var;public void show(){System.out.println("var======"+var);}public I getVar() {return var;}public void setVar(I var) {this.var = var;}
}

7. 泛型接口

上面那些例子都是使用泛型类。而在jdk1.5以后，泛型也可以定义在接口上了，定义接口的泛型和定义泛型类语法相似。

语法:

public interface 接口名<泛型标志,泛型标志....>{   //静态常量   //抽象方法。 }

类如何实现泛型接口:

package demo6;/*** @author: jh* @create: 2022/7/13*/
public class Test {public static void main(String[] args){Upan u = new Upan();Mouse<Integer> mouse = new Mouse<>();}
}/*泛型接口*/
interface USB<T>{public static final String NAME="";T fun();
}/*子类在实现接口时，确定泛型类型*/
class Upan implements USB<String>{@Overridepublic String fun(){return "hello world";}
}/*子类也实现泛型和父类名相同的泛型*/
class Mouse<T> implements USB<T>{@Overridepublic T fun(){return null;}
}

8. 泛型方法

前面学习的所有泛型操作都是将整个类进行泛型化，但同样也可以在类中定义泛型化的方法。泛型方法的定义与其所在的类是否是泛型类是没有任何关系的，所在的类可以是泛型类，也可以不是泛型类。

【泛型方法的简单定义】

[访问权限] ==<泛型标识>== 泛型标识方法名称(泛型标识参数名称)

package demo7;/*** @author: jh* @create: 2022/7/13*/
public class Test {public static void main(String[] args){String hello = Student.fun("hello");Integer fun = Student.fun(200);Double fun1 = Student.fun(20.1);}
}class Student{public static <T> T fun(T t){return t;}
}

9. 作业

第一题：开发一个泛型Apple类，要求有一个重量属性weight在测试类中实例化不同的泛型对象，要求对象a1的这一属性是String类型，对象a2的这一属性是Integer型，a3的这一属性是Double型。分别为a1，a2，a3的重量属性赋值为：”500克”，500,500.0，在测试类中通过对象调用访问器得到属性值并输出。

package test;/*** @author: jh* @create: 2022/7/13*/
public class Test1 {public static void main(String[] args){Apple<String> a1 = new Apple<>();a1.setWeight("500克");a1.show();Apple<Integer> a2 = new Apple<>();a2.setWeight(500);a2.show();Apple<Double> a3 = new Apple<>();a3.setWeight(500.0);a3.show();}
}class Apple<T>{private T weight;public void show(){System.out.println("重量是："+weight);}public T getWeight() {return weight;}public void setWeight(T weight) {this.weight = weight;}
}

第二题：自己定义一个泛型接口，其中有一个eat方法。用一个Person类实现这个接口，传入的泛型实参是String类型，实现的方法内容自己定义，最后在main中调用eat方法。

package test;/*** @author: jh* @create: 2022/7/13*/
public class Test2 {public static void main(String[] args){Person<String> person = new Person<>();person.eat("吃鱼");}
}/*泛型接口*/
interface USB<T>{void eat(T t);
}class Person<T> implements USB<T>{@Overridepublic void eat(T t){System.out.println("要吃什么？"+t);}
}

练习三：定义个泛型类 DAO，在其中定义一个 Map 成员变量，Map 的键为 String 类型，值为 T 类型。分别创建以下方法：public void save(String id,T entity)：保存 T 类型的对象到 Map 成员变量中public T get(String id)：从 map 中获取 id 对应的对象public void update(String id,T entity)：替换 map 中 key 为 id 的内容,改为 entity 对象public List list()：返回 map 中存放的所有 T 对象public void delete(String id)：删除指定 id 对象定义一个 User 类：该类包含：private 成员变量（int 类型） id，age；（String 类型）name。定义一个测试类：创建 DAO 类的对象，分别调用其 save、get、update、list、delete 方法来操作 User 对象，使用 Junit 单元测试类进行测试。

package test;import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;/*** @author: jh* @create: 2022/7/13*/
public class Test3 {public static void main(String[] args){user user1 = new user(1,12,"张三");user user2 = new user(2,23,"王五");user user3 = new user(3,34,"李四");user user4 = new user(4,21,"赵六");DAO<user> dao= new DAO<>(new HashMap<>());dao.save("1",user1);dao.save("2",user2);dao.save("3",user3);System.out.println(dao.get("3"));dao.update("3",user4);System.out.println(dao.list());dao.delete("1");System.out.println(dao.list());}
}class DAO<T>{private HashMap<String,T> hashMap;public void save(String id,T entity){hashMap.put(id,entity);}public T get(String id){return hashMap.get(id);}public void update(String id,T entity){this.save(id,entity);}public List list(){return new ArrayList<>(hashMap.values());}public void delete(String id){hashMap.remove(id);}public HashMap<String,T> getHashMap(){return hashMap;}public DAO(HashMap<String,T> hashMap){this.hashMap = hashMap;}
}class user{private Integer id;private Integer age;private String name;@Overridepublic String toString() {return "user{" +"id=" + id +", age=" + age +", name='" + name + '\'' +'}';}public user(Integer id, Integer age, String name) {this.id = id;this.age = age;this.name = name;}
}

2. java高级--注解

注释: java不会编译注释的内容，注释给程序员看的。

注解: 它是程序看，当程序看到这个注解时，就应该解析它。

譬如: @Controller @Override

注解的分类:

1. 预定义注解
2. 自定义注解
3. 元注解

2.1 预定义注解---了解

预定义注解就是JDK自带的一些注解，该注解被JVM而解析。

1. @Override: 重写得注解。符合重写得规则。
2. @Deprecated: 表示已过时。
3. @SuppressWarnings: 表示压制警告。
4. @FunctionInterface: 表示函数式接口。表示该接口中有且仅有一个抽象方法。

2.2 自定义注解。---初级

语法:

public @interface 注解名{//注解属性
}

使用自定义注解:

类 方法  属性 加@注解名

public class Test {public static void main(String[] args) {Info i=new Info();i.name="张三";i.show();}
}
//定义好注解了
@interface My{//注解属性
}

//使用注解
@My
class Info{@Mypublic String name;
@Mypublic void show(){System.out.println("show================="+name);}
}

注意: 使用注解和不使用注解没有区别？

注解本身没有任何意义，它只有被解析了，才会赋予真正的意义。

我们后会使用反射来对象注解进行解析。

像:@Override 它被JVM解析，从而使其具有相应的意义。

@Controller @RequestMapping 它被Spring框架解析，所以具有相应的意义。

2.3 元注解

定义在注解上的注解称为元注解。

@Controller它只能加在类上 @Override它只能加在方法上。

原因它使用了元注解可以设置注解使用的位置。

1. @Target(value=可以取下面这些内容): 作用限制注解使用得位置。/** 表示可以作用在类,接口,枚举 */TYPE,
/** 属性 */FIELD,
/** 普通方法上 */METHOD,
/** 方法参数 */PARAMETER,
/** 构造方法上 */CONSTRUCTOR,
/** 局部变量 */LOCAL_VARIABLE

2. @Retention:  注解什么时候生效。默认时源码 java经历了那些阶段。源码阶段-->字节码阶段--->运行阶段/*** 源码时生效*/SOURCE,
/*** 字节码时生效*/CLASS,
/*** 运行时生效。* 在JVM内存中还有该注解。都会被设置为运行时有效*/RUNTIME3. @Documented 当生产API文档时该注解还存在。

4. @Inherited 是否运行被子类继承。

2.4 自定义注解---高级

思考: @RequestMapping("/hello") 因为它定义@RequestMaping注解中有属性。

@interface 注解名{数据类型 属性名() default 默认值;
}

数据类型: 基本类型，字符串类型，枚举类型【常量】，注解类型，数组类型【必须是上面这些类型的数组】

java高级--泛型相关推荐

java 高级泛型_java泛型的高级应用
展开全部在上面的例子中,由于没有限制class GenericsFoo类型持有者T的范围,实际上这里32313133353236313431303231363533e59b9ee7ad9431333 ...
Java高级 —— 泛型
目录泛型概念泛型可设置多个类型参数泛型继承泛型接口限制泛型可用类型泛型通配声明泛型方法泛型方法限制泛型可用类型泛型概念问题引入:如果我们需要产生多个对象,每个对象的逻辑完全一样,只 ...
java 高级泛型_Java 泛型高级
1.限制泛型可用类型在定义泛型类别时,预设可以使用任何的类型来实例化泛型中的类型,但是如果想要限制使用泛型的类别时,只能用某个特定类型或者其子类型才能实例化该类型时,使用extends关键字指定这个 ...
java实现泛型检索_高级Java泛型：检索泛型类型参数
java实现泛型检索在JDK5中引入Java泛型之后, Java泛型Swift成为许多Java程序的组成部分. 但是,乍一看似乎很简单的Java泛型,程序员很快就会迷失此功能. 大多数Java程序员 ...
java高级之泛型详解
定义:在java1.5之后推出的. 泛型又叫参数化类型或者类型参数化,在不创建新的类型的情况下,通过泛型指定不同类型来控制形参具体限制的类型,姑且把声明在类上的泛型也叫形参. 泛型应用的意义: 在编译 ...
java高级教程_高级Java教程
java高级教程课程大纲学习Java基础很容易. 但是,真正钻研该语言并研究其更高级的概念和细微差别将使您成为一名出色的Java开发人员. 网络上充斥着"软","便宜 ...
java使用泛型后消除泛型_如何以及何时使用泛型
java使用泛型后消除泛型本文是我们名为" 高级Java "的学院课程的一部分. 本课程旨在帮助您最有效地使用Java. 它讨论了高级主题,包括对象创建,并发,序列化,反射等. ...
高级java开发_我最喜欢的Java高级开发人员书籍
高级java开发我上一篇博客文章 (我对高级Java开发人员的十个最喜欢的在线资源)的想法,是由Xiaoran Wang发表的"面向高级Java开发人员的十大网站"的启发. Wa ...
我最喜欢的Java高级开发人员书籍
我上一篇博客文章 (我对高级Java开发人员的十个最喜欢的在线资源)的想法是由Xiaoran Wang发表的针对高级Java开发人员的十大网站的启发. Wang还写了一篇名为<面向Java高级开 ...

java高级--泛型