Java 泛型

目录

• 泛型的好处
• 泛型类
• 通配符
• 设置泛型的上限
• 设置泛型的下限
• 泛型接口
• 泛型方法

泛型的好处

• 提高代码的重用性（减少重载）
• 防止类型转换异常，提高代码的安全性

泛型类

注意

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");
    }
}