限制泛型可用类型，类型通配符声明，泛型方法

一、限制泛型可用类型

①   在定义泛型类型时，默认在实例化泛型类的时候可以使用任何类型，但是如果想要限制使用泛型类型时，只能用某个特定类型或者是其子类型才能实例化该类型时，可以在定义类型时，使用extends关键字指定这个类型必须是继承某个类，或者实现某个类;

②   当没有指定泛型继承的类型或接口时，默认使用extends Object，所以默认情况下任何类型都可以作为参数传入;

继承抽象类

public class GenericDemo3{
    public static void main(String []args){
        GenericClass<Dog> dogClass=new GenericClass<Dog>();
        dogClass.setObj(new Dog());
        dogClass.getObj().eat();
        
        
        GenericClass<Cat> catClass=new GenericClass<Cat>();
        catClass.setObj(new Cat());
        catClass.getObj().eat();
    }
}

//泛型类所接受的参数做了限制，只能接收Animal类型或者Animal类的子类
class GenericClass<T extends Animal>{
    private T obj;
    public void setObj(T obj){
        this.obj=obj;
    }
    public T getObj(){
        return obj;
    }
}

abstract class Animal{
    public abstract void eat();
}

class Dog extends Animal{
    public void eat(){
        System.out.println("啃骨头");
    }
}
class Cat extends Animal{
    public void eat(){
        System.out.println("吃鱼肉");
    }
}

继承接口

public class GenericDemo3{
    public static void main(String []args){
        GenericClass<Dog> dogClass=new GenericClass<Dog>();
        dogClass.setObj(new Dog());
        dogClass.getObj().eat2();
        
        
        GenericClass<Cat> catClass=new GenericClass<Cat>();
        catClass.setObj(new Cat());
        catClass.getObj().eat2();
    }
}

//泛型类所接受的参数做了限制，只能接收Animal类型或者Animal类的子类
class GenericClass<T extends Animal2>{
    private T obj;
    public void setObj(T obj){
        this.obj=obj;
    }
    public T getObj(){
        return obj;
    }
}

interface Animal2{
    public abstract void eat2();
}

class Dog implements Animal2{
    public void eat2(){
        System.out.println("啃骨头2");
    }
}
class Cat implements Animal2{
    public void eat2(){
        System.out.println("吃鱼肉2");
    }
}

 

二、类型通配符声明

①   同一泛型类，如果实例化时给定的实际类型不同，则这些实例的类型是不兼容的，不能相互赋值;

Generic<Boolean> f1=new Generic<Boolean>();

Generic<Integer> f2=new Generic<Integer>();

f1=f2;//发生编译错误

Generic<Object> f=f1;//f1和f类型并不兼容，发生编译错误

f=f2;//f2和f类型同样不兼容，也会发生编译错误

②   泛型类实例之间的不兼容性会带来使用的不便。我们可以使用泛型通配符(?)声明泛型类的变量就可以解决这个问题;

③   泛型通配符的方式

“?”代表任意一个类型;

Generic<Boolean> f1=new Generic<Boolean>();

Generic<?> f=f1;

和限制泛型的上限相似，同样可以使用extends关键字限定通配符匹配类型的上限;

Generic<Dog> f1=new Generic<Dog>();

Generic<? extends Animal> f=f1;

还可以使用super关键字将通配符类型限定为某个类型及其父类型;

Generic<Animal> f1=new Generic<Animal>();

Generic<? super Dog> f=f1;

public class GenericDemo4{
    public static void main(String []args){
        GenericClass<Dog> dogClass=new GenericClass<Dog>();
        dogClass.setObj(new Dog());
        dogClass.getObj().eat();
        
        GenericClass<Cat> catClass=new GenericClass<Cat>();
        catClass.setObj(new Cat());
        catClass.getObj().eat();
        
        GenericClass<String> StringClass=new GenericClass<String>();
        
        //dogClass=catClass;//编译出错
        
        //无限定通配符的使用
        GenericClass<?> gClass=null;
        gClass=dogClass;
        ((Dog)gClass.getObj()).eat();//因父类为object类型，所以要强制转换
        
        gClass=StringClass;
        
        //上边界限定通配符
        GenericClass<? extends Animal> subclass=null;
        subclass=dogClass; //Animal a=dog;
        subclass.getObj().eat();
        
        //下边界限定通配符
        GenericClass<? super Dog> sclass=null;
        GenericClass<Animal> cClass=new GenericClass<Animal>();
        //sclass=catClass; //编译错误，类型不兼容
        sclass=cClass;//可以通过编译
    }
}


class GenericClass<T>{
    private T obj;
    public void setObj(T obj){
        this.obj=obj;
    }
    public T getObj(){
        return obj;
    }
}

interface Animal{
    public abstract void eat();
}

class Dog implements Animal{
    public void eat(){
        System.out.println("啃骨头");
    }
}
class Cat implements Animal{
    public void eat(){
        System.out.println("吃鱼肉");
    }
}

 

三、泛型方法

①   不仅类可以声明泛型，类中的方法也可以声明仅用于自身的泛型，这种方法叫做泛型方法。其定义格式为：

 

访问修饰符<泛型列表> 返回类型 方法名(参数列表){

           实现代码

}

②   在泛型列表中声明的泛型，可用于该方法的返回类型声明、参数类型声明和方法代码中的局部变量的类型声明;

③   类中其它方法不能使用当前方法声明的泛型;

注：是否拥有泛型方法，与其所在的类是否泛型没有关系。要定义泛型方法，只需将泛型参数列表置于返回值前;

④   什么时候使用 泛型方法，而不是泛型类？

添加类型约束只作用于一个方法的多个参数之间，而不涉及到类中的其它方法;

施加类型约束的方法为静态方法，只能将其定义为泛型方法，因为静态方法不能使用其所在类的类型参数;

public class GenericDemo5{
    public static void main(String []args){
        GenericClass2 gen=new GenericClass2();
        gen.println("abc");
        gen.println(true);
        gen.println(10);
        gen.println(10.5);
        gen.println(new Dog());
        gen.println(new Cat());
        GenericClass2.print("哈哈");
    }
}

class GenericClass2{
    //泛型方法
    public <T> void println(T content){
        System.out.println(content);
    }
    //泛型方法的重载
    public <T extends Animal> void println(T animal){
        animal.eat();
    }
    
    public static <T> void print(T content){
        System.out.println(content);
    }
}

interface Animal{
    public abstract void eat();
}

class Dog implements Animal{
    public void eat(){
        System.out.println("啃骨头");
    }
}
class Cat implements Animal{
    public void eat(){
        System.out.println("吃鱼肉");
    }
}