目录
1.什么是泛型
其实我们再使用集合时就用过泛型List<T> 创建一个List对象List<Student> list=new ArrayList();
<T>它就是泛型。
所谓的泛型就是在类定义时,不为类中属性和方法指定数据类型,而是在类对象创建时为其指定相应的数据类型。
2.为什么使用泛型
例子: 要求定义一个Point点类,该类中属性有x坐标和y坐标。
要求: x和y的值可以都是整数类型。
x和y的值可以都是小数类型。
x和y的值可以都是字符串类型。
如何定义该类呢? 如何确定属性的类型。----Object类型
package demo04;
public class point {
private Object x;
private Object y;
public Object getX() {
return x;
}
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 void setX(Object x) {
this.x = x;
}
public Object getY() {
return y;
}
public void setY(Object y) {
this.y = y;
}
}
package demo04;
public class Test {
public static void main(String[] args) {
point p1 = new point(1,1);
p1.show();
point p2 = new point(1.5,1.5);
p2.show();
point p3 = new point("东京","北纬");
p3.show();
point p4 = new point(1,"北纬");
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;
}
}
package demo05;
public class Test {
public static void main(String[] args) {
Point<Integer> p1 = new Point<Integer>(1,1);
p1.show();
Point<String> p2 = new Point<String>("1","2");
p2.show();
Point<Double> p3 = new Point<>(1.5, 1.5);
p3.show();
Point<Object> p4 = new Point<Object>(1.5,"hello");
p4.show();
}
}
注意: 上面的泛型类型必须都是引用类型。不能是基本类型。
使用泛型就保证了数据类型安全问题。
3.如何定义泛型
泛型可以定义在类上,接口上,方法上。 泛型类,泛型接口以及泛型方法。
泛型可以解决数据类型的安全性问题,其主要原理是在类声明时通过一个==标识表示类中某个属性的数据类型或者是某个方法的返回值及参数类型==。这样在类声明或者实例化时只要指定好需要的类型即可。
格式:
public class 类名<泛型标志,泛型标志....>{
//类成员
}
public class Test03 {
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<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;
}
}
4.通配符
在开发中对象的==引用传递==是最常见的,但是如果在泛型类的操作中,在进行==引用传递时泛型类型必须匹配才可以传递,否则是无法传递的==。如果想传递,可以定义泛型为?通配符。
package demo06;
import static java.awt.SystemColor.info;
public class Test {
public static void main(String[] args) {
// Info<Integer> i1 = new Info<>();
// i1.setVar(250);
// fun(i1);
// Info<Double> i2 = new Info<>();
// i2.setVar(2.50);
// fun(i2);
// Info<String> i3 = new Info<>();
// i3.setVar("王腾");
// fun(i3);
Info<Integer> i1 = new Info<>();
i1.setVar(250);
fun2(i1);
}
public static void fun(Info<?> info){
info.show();
}
public static void fun2(Info<? extends Number> info){
info.show();
}
}
//当创建该类对象时,泛型必须为Number的子类以及Number类型
class fun1<T extends Number>{
}
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 Test04 {
public static void main(String[] args) {
Info<Number> i=new Info<>();
fun2(i);
Info<Object> i3=new Info<>();
fun2(i3);
Info<Integer> i4=new Info<>();
fun2(i4);
}
//传递的参数泛型类型必须为Number的父类或者Number类型
public static void fun2(Info<? super Number> info){
info.show();
}
//传递的参数泛型类型必须为Number的子类或者Number类型
public static void fun(Info<? extends Number> info){
info.show();
}
}
//当创建该类对象时,泛型必须为Number的子类以及Number类型
class People<T extends Number> {
}
//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;
}
}
6.泛型接口
在jdk1.5以后,泛型也可以定义在接口上了,定义接口的泛型和定义泛型类语法相似。
public interface 接口名<泛型标志,泛型标志....>{
//静态常量
//抽象方法。
}
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>{
@Override
public String fun() {
return "hello world";
}
}
//子类也实现泛型和父类名相同的泛型
class Mouse<T> implements USB<T>{
@Override
public T fun() {
return null;
}
}
7.泛型方法
前面学习的所有泛型操作都是将整个类进行泛型化,但同样也可以在类中定义泛型化的方法。泛型方法的定义与其所在的类是否是泛型类是没有任何关系的,所在的类可以是泛型类,也可以不是泛型类。
【泛型方法的简单定义】
[访问权限] ==<泛型标识>== 泛型标识 方法名称(泛型标识 参数名称)
ackage demo07;
public class Test {
public static void main(String[] args) {
String hhh = Student.fun("hhh");
Integer fun = Student.fun(250);
Double fun1 = Student.fun(2.5);
}
}
class Student{
//泛型方法: static静态成员,随着类的加载而被加载到JVM内存中。常量池
public static <T> T fun(T t){
return t;
}
}