目录
一.泛型
1.什么是泛型
其实我们在使用集合时就用过泛型List<T> 创建一个List对象List<Student> list=new ArrayList();
<T>它就是泛型。
所谓的泛型就是在类定义时,不为类中属性和方法指定数据类型，而是在类对象创建时为其指定相应的数据类型。
2.为什么使用泛型
例子: 要求定义一个Point点类，该类中属性有x坐标和y坐标。
要求: x和y的值可以都是整数类型。
x和y的值可以都是小数类型。
x和y的值可以都是字符串类型。
如何定义该类呢? 如何确定属性的类型。----Object类型
Point类
package demo01;
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 demo01;
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();
}
}但是:如果我们为坐标一个赋值整数，一个赋值为字符串，这时会不会报错。
Point p4=new Point(25,"北纬50度");
p4.show();答案是不会，但是它违背了我们设计的要求，这就是我们提到的数据类型安全问题。如何解决数据类型安全问题?
可以使用泛型来解决。
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;
}
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;
}
}
Point<Integer> p1=new Point<Integer>(10,20);//坐标为整数int--自动装箱->Integer--->Object(向上转型)
p1.show();
Point<Double> p2=new Point<Double>(25.5,36.6);//坐标为小数
p2.show();
Point<String> p3=new Point<String>("东经180度","北纬25度");//坐标为字符串
p3.show();注意: 上面的泛型类型必须都是引用类型。不能是基本类型。
使用泛型就保证了数据类型安全问题。
3.如何定义泛型
泛型可以定义在类上，接口上，方法上。 泛型类，泛型接口以及泛型方法。
泛型可以解决数据类型的安全性问题，其主要原理是在类声明时通过一个标识表示类中某个属性的数据类型或者是某个方法的返回值及参数类型。这样在类声明或者实例化时只要指定好需要的类型即可。
注意：
- 标识可以任意起名，在创建对象时，必须为每个泛型指定数据类型。
- 在类声明或实例化时，如果没有指定泛型的类型，那么默认类型为Object.
- 如果不声明类型，想使用真正的类型接收，则必须进行强转。
格式:
public class 类名<泛型标志,泛型标志....>{
//类成员
}
package demo04;
/**
* @ProjectName: java高级篇---泛型0713
* @Package: demo04
* @ClassName: Info
* @Author: 王振华
* @Description:
* @Date: 2022/7/13 19:06
* @Version: 1.0
*/
//T标志可以任意起名.----->那么在创建对象时，必须为每个泛型指定数据类型
public class Info<T> {
private T name;
public void show(){
System.out.println("姓名为:"+name);
}
public T getName() {
return name;
}
public void setName(T name) {
this.name = name;
}
}
class Test1{
public static void main(String[] args) {
Info<String> info = new Info<>();
info.setName("张三");
info.show();
Info<Integer> info1 = new Info<>();
info1.setName(12);
//不需要类型转换
Integer name1 = info1.getName();
info1.show();
//如果没有指定泛型类型默认为Object
Info info2 = new Info();
info2.setName("王五");
//如果想使用真正的类型，那么必须进行强制类型转换
String name = (String) info2.getName();
info2.show();
}
}
如果没有指定泛型类型，那么默认为Object
4.泛型的通配符
在开发中对象的引用传递是最常见的，但是如果在泛型类的操作中，在进行引用传递时泛型类型必须匹配才可以传递，否则是无法传递的。如果想传递，可以定义泛型为 ? 通配符。
package demo04;
/**
* @ProjectName: java高级篇---泛型0713
* @Package: demo04
* @ClassName: Info01
* @Author: 王振华
* @Description:
* @Date: 2022/7/13 19:21
* @Version: 1.0
*/
//T标志可以任意起名.----->那么在创建对象时，必须为每个泛型指定数据类型
public class Info01<T> {
private T name;
public void show(){
System.out.println("姓名为:"+name);
}
public T getName() {
return name;
}
public void setName(T name) {
this.name = name;
}
}
class Test2{
public static void main(String[] args) {
Info01<Integer> info = new Info01<>();
info.setName(666);
//如果为泛型类型,不但要求数据类型相同之外还要求泛型类型也匹配
fun(info);
Info01<String> info01 = new Info01<>();
info01.setName("张三");
fun(info01);
Info01<Double> info02 = new Info01<>();
info02.setName(123.0);
fun(info02);
//不指定泛型默认也是Object
Info01 info03 = new Info01();
info03.setName("李四");
Object name = info03.getName();
fun(info03);
}
//该方法的参数为Info 设置泛型类型可以接受任意的类型可以使用通配符
public static void fun(Info01<?> info){
info.show();
}
}
5.受限泛型
在引用传递中，在泛型操作中也可以设置一个泛型对象的范围上限和范围下限。范围上限使用extends关键字声明，表示参数化的类型可能是所指定的类型或者是此类型的子类，而范围下限使用super进行声明，表示参数化的类型可能是所指定的类型或者此类型的父类型。
语法:
[设置上限]
声明对象: 类名称<? extends 类> 对象名称;
定义类: [访问权限] 类名称<泛型标识 extends 类>{}[设置下限]
声明对象: 类名称<? super 类> 对象名称;
定义类: [访问权限] 类名称<泛型标识 super 类>{}
定义类:
//当创建该类对象时，泛型必须为Number的子类以及Number类型,不能设置下限
class People<T extends Number>{
}
class Test02{
public static void main(String[] args) {
People<Number> people = new People<>();
People<Integer> people1 = new People<>();
}
}声明对象:
package demo04;
/**
* @ProjectName: java高级篇---泛型0713
* @Package: demo04
* @ClassName: Info02
* @Author: 王振华
* @Description:
* @Date: 2022/7/13 19:37
* @Version: 1.0
*/
//T标志可以任意起名.----->那么在创建对象时，必须为每个泛型指定数据类型
public class Info02<T> {
private T name;
public void show(){
System.out.println("姓名为:"+name);
}
public T getName() {
return name;
}
public void setName(T name) {
this.name = name;
}
}
class Test3{
public static void main(String[] args) {
//设置上限,Integer,Double等都是Number的子类
Info02<Number> info = new Info02<>();
fun(info);
Info02<Integer> info01 = new Info02<>();
fun(info01);
Info02<Double> info02 = new Info02<>();
fun(info02);
//设置下限,Object是Number的父类
Info02<Number> info03 = new Info02<>();
fun01(info03);
Info02<Object> info04 = new Info02<>();
fun01(info04);
}
//传递的参数必须为Number的子类或者Number类型 设置上限
public static void fun(Info02<? extends Number> info){
info.show();
}
//传递的参数必须为Number的父类或者Number类型 设置下限
public static void fun01(Info02<? super Number> info){
info.show();
}
}
6.泛型接口
上面那些例子都是使用泛型类。而在jdk1.5以后，泛型也可以定义在接口上了，定义接口的泛型和定义泛型类语法相似。
语法:
public interface 接口名<泛型标志,泛型标志....>{
//静态常量
//抽象方法。
}
类如何实现泛型接口:
1.子类在实现接口时，确定泛型类型
2.子类也实现泛型和服类名相同的泛型
package demo04;
/**
* @ProjectName: java高级篇---泛型0713
* @Package: demo04
* @ClassName: Usb
* @Author: 王振华
* @Description:
* @Date: 2022/7/13 20:01
* @Version: 1.0
*/
//泛型接口
public interface Usb<T> {
public static final String NAME = "张三"; //常量的命名必须全部大写
T fun();//抽象方法
}
//1.子类在实现接口时，确定泛型类型
class Upan implements Usb<String>{
@Override
public String fun() {
return "hello world";
}
}
//2.子类也实现泛型和父类名相同的泛型
class Mouse<T> implements Usb<T>{
@Override
public T fun() {
return null;
}
}
//测试
class Test01{
public static void main(String[] args) {
Upan upan = new Upan();
Mouse<String> mouse = new Mouse<>();
}
}
7.泛型方法
前面学习的所有泛型操作都是将整个类进行泛型化，但同样也可以在类中定义泛型化的方法。泛型方法的定义与其所在的类是否是泛型类是没有任何关系的，所在的类可以是泛型类，也可以不是泛型类。
【泛型方法的简单定义】
[访问权限] <泛型标识> 泛型标识 方法名称(泛型标识 参数名称)
package demo04;
/**
* @ProjectName: java高级篇---泛型0713
* @Package: demo04
* @ClassName: Student
* @Author: 王振华
* @Description:
* @Date: 2022/7/13 20:13
* @Version: 1.0
*/
public class Student {
//泛型方法:static静态成员，随着类的加载而被加载到JVM内存中，常量池
public static <T> T fun(T t){
return t;
}
}
class Test11{
public static void main(String[] args) {
String hello = Student.fun("hello");
Integer i = Student.fun(11);
Double d = Student.fun(15.0);
}
}
二.注解
注释: java不会编译注释的内容，注释给程序员看的。
注解: 它是程序看，当程序看到这个注解时，就应该解析它。
譬如: @Controller @Override
注解的分类:
1. 预定义注解
2. 自定义注解
3. 元注解
1.预定义注解---了解
预定义注解就是JDK自带的一些注解，该注解被JVM而解析。
1. @Override: 重写得注解。符合重写得规则。
2. @Deprecated: 表示已过时。
3. @SuppressWarnings: 表示压制警告。
4. @FunctionInterface: 表示函数式接口。表示该接口中有且仅有一个抽象方法,可以有static静态方法和default默认方法。
package demo08;
import java.util.Date;
public class Test08 {
public static void main(String[] args) {
Info i=new Info();
i.fun();
Date date=new Date();
date.getMonth();
}
}
@FunctionalInterface //函数式接口---那么就可以使用Lambda表达式
interface USB{
public void show();
default void fun(){}
}
class Info{
@Override //重写的注解:特点 该方法必须与父类中的方法名相同，参数相同，返回类型相同，修饰符不能小于父类方法的修饰符，抛出的异常不能大于父类的
public String toString() {
return super.toString();
}
/**
* replace by Info->fun2();
*/
@Deprecated //该方法已过时
public void fun(){
}
public void fun2(){
}
}
package demo08;
@SuppressWarnings(value = "all") //抑制警告 一般不用。
public class Test02 {
public static void main(String[] args) {
int i=15;
}
}2.自定义注解 ---初级
语法:
public @interface 注解名{
//注解属性
}
使用自定义注解:
类 方法 属性 加@注解名
例子：注意，该例子中的自定义注解没有任何意义，因为他没有被解析，只有解析过后才会被赋予真正的意义。解析方法需要用到我们的反射。这个后面我们再讲
package demo;
public class Test {
public static void main(String[] args) {
Info i=new Info();
i.name="wzh";
i.show();
}
}
//定义好注解了
@interface My{
//注解属性
}
//使用注解
@My
class Info{
@My
public String name;
@My
public void show(){
System.out.println("show================="+name);
}
}注意: 使用注解和不使用注解没有区别？
注解本身没有任何意义，它只有被解析了，才会赋予真正的意义。
我们后会使用反射来对象注解进行解析。
像:@Override 它被JVM解析，从而使其具有相应的意义。
@Controller @RequestMapping 它被Spring框架解析，所以具有相应的意义。
3. 元注解
定义在注解上的注解称为元注解。
@Controller它只能加在类上 @Override它只能加在方法上。
原因它使用了元注解可以设置注解使用的位置。
1. @Target(value=可以取下面这些内容): 作用限制注解使用得位置。
/** 表示可以作用在类,接口,枚举 */
TYPE,/** 属性 */
FIELD,/** 普通方法上 */
METHOD,/** 方法参数 */
PARAMETER,/** 构造方法上 */
CONSTRUCTOR,/** 局部变量 */
LOCAL_VARIABLE2. @Retention: 注解什么时候生效。默认时源码 java经历了那些阶段。
源码阶段-->字节码阶段--->运行阶段
/**
* 源码时生效
*/
SOURCE,/**
* 字节码时生效
*/
CLASS,/**
* 运行时生效。
* 在JVM内存中还有该注解。
都会被设置为运行时有效
*/
RUNTIME
3. @Documented 当生产API文档时该注解还存在。4. @Inherited 是否运行被子类继承。
4. 自定义注解---高级
思考: @RequestMapping("/hello") 因为它定义@RequestMaping注解中有属性。
@interface 注解名{
数据类型 属性名() default 默认值;
}
数据类型: 基本类型，字符串类型，枚举类型【常量】，注解类型，数组类型【必须是上面这些类型的数组】
package demo09;
import java.lang.annotation.*;
//定义好注解了
//表示该注解可以使用的位置
@Target(value = {ElementType.TYPE,ElementType.METHOD})
//表示注解什么时候生效--source--class[默认字节码有效]---runtime[反射时验证]
@Retention(value = RetentionPolicy.RUNTIME)
//是否在生成api文档时存在该注解
@Documented
//子类是否能继承该注解，如果注解在定义时使用了下面这个元注解则能被子类继承。
@Inherited
@interface My{
String value(); //如果设置default默认值，那么在使用该注解时可以不为该属性赋值。
int age() default 15;
String[] hobby() default {};//
}
//使用注解 如果使用注解时有且仅有一个属性没有赋值，而且该属性的名字value那么在给该属性赋值值，可以省略value
@My(value = "hello",hobby = "游泳")
class Info{
public String name;
public void show(){
System.out.println("show================="+name);
}
}
class Student extends Info{
}
259
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
