泛型的好处
- 提高代码的重用性（减少重载）
- 防止类型转换异常，提高代码的安全性
泛型类
注意
1、泛型只能使用引用类型
2、不同泛型类型对象之间不能相互赋值
package com.test;
class Point<T>//实例化的时候指明T的类型
{
private T x ;
private T 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;
}
@Override
public String toString() {
return "Point [x=" + x + ", y=" + y + "]";
}
public Point(T x, T y) {
super();
this.x = x;
this.y = y;
}
public Point() {}
}
public class Test01
{
public static void main(String[] args)
{
Point<Integer> p1 = new Point<>();//jdk1.7后第二个尖括号不需要指明类型
p1.setX(2);
p1.setY(1);
int strx =p1.getX() ;
int a =p1.getY();
System.out.println(strx+a);
}
}
通配符
class Message<T>
{
private T message ;
public T getMessage() {
return message;
}
public void setMessage(T message) {
this.message = message;
}
}
public class Test01
{
public static void main(String[] args)
{
Message<Integer> m = new Message<>();
m.setMessage(100);
fun(m);
Message<String> m2 = new Message<>();
m2.setMessage("Hello");
fun(m2);
}
public static void fun(Message<?> m)//由于不知道要传入的类型，所以用通配符
{
Object o = m.getMessage();
System.out.println(o.getClass());
}
}
class java.lang.Integer
class java.lang.String
设置泛型的上限
class Message<T extends Number>
{
private T message ;
public T getMessage() {
return message;
}
public void setMessage(T message) {
this.message = message;
}
}
public class Test01
{
public static void main(String[] args)
{
Message<Integer> m = new Message<>();
m.setMessage(100);
fun(m);
Message<String> m2 = new Message<>();//由于String不是Number的子类,这里会报错
m2.setMessage("Hello");
fun(m2);
}
public static void fun(Message<?> m)//由于不知道要传入的类型，所以用通配符
{
Object o = m.getMessage();
System.out.println(o.getClass());
}
}
设置泛型的下限
class Message<T>
{
private T message ;
public T getMessage() {
return message;
}
public void setMessage(T message) {
this.message = message;
}
}
public class Test01
{
public static void main(String[] args)
{
Message<String> m = new Message<>();
m.setMessage("Hello World");
fun(m);//String不是Integer的父类，会报错
Message<Integer> m2 = new Message<>();
m2.setMessage(123);
fun(m2);
}
public static void fun(Message<? super Integer> m)//设置泛型的下限
{
System.out.println(m.getMessage());
}
}
泛型接口
/**
* 泛型接口
* @param <T>
*/
interface IMessage<T>
{
public void print(T t);
}
/**
* 实现泛型接口方法一：
* 实现类上不知名泛型类型，在实例化的时候指明类型
* @param <T>
*/
class MessageImp<T> implements IMessage<T>
{
@Override
public void print(T t) {
System.out.println(t);
}
}
/**
* 实现泛型接口方法二：
* 在实现类上直接指明泛型类型
*/
class MessageImp2 implements IMessage<String>
{
@Override
public void print(String s) {
System.out.println(s);
}
}
public class Test01
{
public static void main(String[] args)
{
IMessage<String> m = new MessageImp<>();
m.print("Hello World!");
IMessage<String> m2 = new MessageImp2();
m2.print("我是方式2");
}
}
泛型方法
/**
* 泛型方法
* 语法：
* 权限修饰符 <泛型1...> 返回值 方法名（参数列表）{
* 方法体
* }
* 在权限修饰符和返回值之间声明该方法为泛型方法。返回值，参数列表，方法体中可以使用已经声明的泛型
*/
class Message
{
//声明为泛型方法
public <T> void print(){
System.out.println("print");
}
//参数列表，方法体中使用泛型
public <T> void print2(T t){
System.out.println("print2-"+t);
}
//返回值使用泛型
public <T> T print3(T t){
return t;
}
//可以使用多个泛型
public <T,K> void print4(T t , K k){
System.out.println(t+","+k);
}
}
public class Test01
{
public static void main(String[] args)
{
Message message = new Message();
//使用泛型方法
message.print();
//有参数的泛型方法
message.print2("Hello World");
//有返回值
Integer integer = message.print3(123);
System.out.println(integer);
//有多个泛型
message.print4("Hello","World");
}
}