目录
1.什么是泛型（概念）
所谓的泛型就是在类定义时,不为类中属性和方法指定数据类型，而是在类对象创建时为其指定相应的数据类型.
2.数据类型安全问题
案例：
定义一个Point点类，该类中属性有x坐标和y坐标。
要求: x和y的值可以都是整数类型。
x和y的值可以都是小数类型。
x和y的值可以都是字符串类型。
如何定义该类呢? 如何确定属性的类型。
首先想到的是将其定义为object类型
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;
}
//get 和 set 方法省略
}测试：
public class Test {
public static void main(String[] args) {
Point p1=new Point(10,20);//坐标为整数int--自动装箱->Integer--->Object(向上转型)
p1.show();
Point p2=new Point(25.5,36.6);//坐标为小数
p2.show();
Point p3=new Point("东经180度","北纬25度");//坐标为字符串
p3.show();
}
}此时并不会出现什么问题，当我们将x轴坐标定义为Integer类型 y轴坐标定义为字符串类型时，编译器就会报错，这种错误就是数据类型安全问题，所以我们可以使用泛型来解决
3.如何定义泛型
泛型可以定义在类上，接口上，方法上。 泛型类，泛型接口以及泛型方法。
泛型可以解决数据类型的安全性问题，其主要原理是在类声明时通过一个==标识表示类中某个属性的数据类型或者是某个方法的返回值及参数类型==。这样在类声明或者实例化时只要指定好需要的类型即可。
语法：
public class 类名<泛型标志,泛型标志....>{
//类成员
}解决上述数据安全问题：
自定义泛型
public class Point<T> {
//x坐标----
private T x;
//y坐标
private T y;
//输出坐标的值
public void show(){
System.out.println("x坐标:"+x+";y坐标:"+y);
}
public Point() {
}
public Point(T x, T y) {
this.x = x;
this.y = y;
}
//get set 方法省略
}当我们再次实现x轴为Integer,y轴为String类型时就不会出现错误。
4.通配符
在开发中对象的==引用传递==是最常见的，但是如果在泛型类的操作中，在进行==引用传递时泛型类型必须匹配才可以传递，否则是无法传递的==。如果想传递，可以定义泛型为?通配符。
public class Test04 {
public static void main(String[] args) {
Info<Integer> i=new Info<>();
i.setVar(250);
fun(i);
Info<String> i2=new Info<>();
i2.setVar("刘德华");
fun(i2);
Info<Double> i3=new Info<>();
i3.setVar(25.5);
fun(i3);
}
//该方法的参数为Info而且它的泛型为任意类型
//如果为泛型类型:调用时不但要求数据类型相同之外还要求泛型类型也匹配。
public static void fun(Info<?> info){
info.show();
}
}
//T标志可以任意起名.----> 那么在创建对象时，必须为每个泛型指定数据类型。
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;
}
}
5.受限泛型
在引用传递中，在泛型操作中也可以设置一个泛型对象的==范围上限==和==范围下限==。范围上限使用extends关键字声明，表示参数化的类型可能是所指定的类型或者是此类型的子类，而范围下限使用super进行声明，表示参数化的类型可能是所指定的类型或者此类型的父类型。
语法：
[设置上限]
声明对象: 类名称<? extends 类> 对象名称;
定义类: [访问权限] 类名称<泛型标识 extends 类>{}
[设置下限]
声明对象: 类名称<? super 类> 对象名称;
定义类: [访问权限] 类名称<泛型标识 super 类>{}使用：
public class Text05 {
public static void main(String[] args) {
inFor<Number> inFor = new inFor<>();
inFor.setVar(20);
fun(inFor);
inFor<Integer> inFor1 = new inFor<>();
inFor1.setVar(16);
fun(inFor1);
//当泛型大于Numberl类型时会报错
inFor<Object> inFor2 = new inFor<>();
inFor2.setVar("80");
fun(inFor2);//此时报错了
}
//指定该方法的参数的泛型上线为Number,表示调用该方法时参数的泛型必须为Number或者Number的子级
public static void fun(inFor<? extends Number> inFor){
inFor.show();
}
//定义一个类指定泛型
static class inFor<T>{
private T var;
public void show(){
System.out.println(var);
}
public T getVar() {
return var;
}
public void setVar(T var) {
this.var = var;
}
}
}6.泛型接口
上面那些例子都是使用泛型类。而在jdk1.5以后，泛型也可以定义在接口上了，定义接口的泛型和定义泛型类语法相似。
语法：
public interface 接口名<泛型标志,泛型标志....>{
//静态常量
//抽象方法。
}类如何实现泛型接口
public class Text06 {
public static void main(String[] args) {
Upan<Integer> upan = new Upan<>();
Integer fun = upan.fun();
USB usb = new USB();
String fun1 = usb.fun();
}
//接口
interface InFor<T>{
//抽象方法
T fun();
}
//子类1指定泛型类型
static class USB implements InFor<String>{
@Override
public String fun() {
return null;
}
}
//子类2，实现类的泛型类型和接口的泛型类型一致
static class Upan<T> implements InFor<T>{
@Override
public T fun() {
return null;
}
}
}7.泛型方法
前面学习的所有泛型操作都是将整个类进行泛型化，但同样也可以在类中定义泛型化的方法。泛型方法的定义与其所在的类是否是泛型类是没有任何关系的，所在的类可以是泛型类，也可以不是泛型类。
语法
[访问权限] ==<泛型标识>== 泛型标识 方法名称(泛型标识 参数名称)定义
public class Test {
public static void main(String[] args) {
String hello = Student.fun("hello");
Integer fun = Student.fun(250);
Double fun1 = Student.fun(250.0);
}
}
class Student{
//泛型方法: static静态成员，随着类的加载而被加载到JVM内存中。常量池
public static <T> T fun(T t){
return t;
}
}8.注解
注释: java不会编译注释的内容，注释给程序员看的。
注解: 它是程序看，当程序看到这个注解时，就应该解析它。
譬如: @Controller @Override
8.1.注解的分类
1. 预定义注解
2. 自定义注解
3. 元注解
8.2.预定义注解
预定义注解就是JDK自带的一些注解，该注解被JVM而解析。
1. @Override: 重写得注解。符合重写得规则。
2. @Deprecated: 表示已过时。
3. @SuppressWarnings: 表示压制警告。
4. @FunctionInterface: 表示函数式接口。表示该接口中有且仅有一个抽象方法。
8.3.自定义注解（初级）
语法：
public @interface 注解名{
//注解属性
}使用：
public class Test {
public static void main(String[] args) {
Info i=new Info();
i.name="刘德华";
i.show();
}
}
//定义好注解了
@interface My{
//注解属性
}
//使用注解
@My
class Info{
@My
public String name;
@My
public void show(){
System.out.println("show================="+name);
}
}注意：注解本身没有任何意义，它只有被解析了，才会赋予真正的意义。
8.4.自定义注解高级
为注解是指属性，类似于 @RequestMapping("/hello")
@interface 注解名{
数据类型 属性名() default 默认值;
}注意：
数据类型: 基本类型，字符串类型，枚举类型【常量】，注解类型，数组类型【必须是上面这些类型的数组】
8.5.元注解
概念：定义在注解上的注解称为元注解。
1. @Target(value=可以取下面这些内容): 作用限制注解使用得位置。
/** 表示可以作用在类,接口,枚举 */
TYPE,
/** 属性 */
FIELD,
/** 普通方法上 */
METHOD,
/** 方法参数 */
PARAMETER,
/** 构造方法上 */
CONSTRUCTOR,
/** 局部变量 */
LOCAL_VARIABLE
2. @Retention: 注解什么时候生效。默认时源码 java经历了那些阶段。
源码阶段-->字节码阶段--->运行阶段
/**
* 源码时生效
*/
SOURCE,
/**
* 字节码时生效
*/
CLASS,
/**
* 运行时生效。
* 在JVM内存中还有该注解。
都会被设置为运行时有效
*/
RUNTIME
3. @Documented 当生产API文档时该注解还存在。
4. @Inherited 是否运行被子类继承。
159
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
