Java泛型-1

一个简单的泛型实例:

 

class Automobile(){}

public class Holder<T> {

    private T a;

    public  Holder(T a){this.a = a;}
    public  void set(T a){this.a = a;}
    public  T get(){return this.a;}    

    public static void main(string[]args){
        Holder<Automobile> h1 = new Holder<Automobile>(new Automobile());
        Automobile = h1.get();
    }

}

 

元组类库:

   概念:

       1.将一组对象直接打包存储于其中的一个单一对象中。这种容器对象允许读取其中元素,但不允许向其中存放新的对象。

通常元素具有任意长度,同时,元组中的对象可以是任何不同的类型。

   目的:

       1.一次调用返回多个对象。

       2.在编译期保证类型的安全。

 

一个二维元祖示例:

package net.mindview.util
public TwoTuple<A ,B> {
    public final A first;
    public final B second;
    public TwoTuple<A a, B b> {
        first = a;
        second = b;
    }
    public String toString(){
        return "(" + first + " ," + second  + ")";
    } 

}

利用继承机制实现长度更长的元组.将上述二元组扩展为三元组代码形式可以如下所示:

public class ThreeTuple<A, B, C> extends TwoTuple<A, B>{

    public final C third;

    public ThreeTuple(A a, B b, C c) {
        super(a, b);
        third = c;
    }

    public String toString(){
        return "(" + first + "," + second + "," + third + ")";
    }

}
public class FourTuple<A, B, C, D> extends ThreeTuple<A,B,C>{

    public final D fourth;

    public FourTuple(A a, B b, C c, D d) {
        super(a, b, c);
        fourth = d;
    }

    public String toString(){
        return "(" + first + "," + second + "," + third + "," + fourth + ")";
    }

}

为了使用元组,你只需定义一个长度适合的元组,将其作为方法的返回值,然后在return语句中创建该元组,并返回即可.例如下面使用方式:

/**
 * 由于有了泛型,你可以很容易的创建元组,令其返回一组任意类型的对象,而你所要做的,只是编写表达式而已.
 */
public class TupleTest {

    static TwoTuple<String, Integer> f(){
        //Autoboxing conveerts the int to Integer;
        return new TwoTuple<String, Integer>("hi", 47);
    }

    static ThreeTuple<Amphibian, String, Integer> g(){
        return new ThreeTuple<Amphibian, String, Integer>(new Amphibian(), "hi", 47);
    }

    static FourTuple<Vehicle, Amphibian, String ,Integer> h(){
        return new FourTuple<Vehicle, Amphibian, String, Integer>(new Vehicle(), new Amphibian(), "hi", 47);
    }

    public static void main(String[] args) {
        TwoTuple<String, Integer> ttsi = f();
        System.out.println(ttsi);
        System.out.println(g());
        System.out.println(h());
    }

}

class Amphibian {}

class Vehicle {}

 

Java中,泛型是一种强类型机制,它可以让你在编译时检查类型错误,从而提高代码的安全性和可读性。在使用泛型时,我们经常会遇到父类和子类的泛型转换问题。 首先,我们需要明确一点:子类泛型不能转换成父类泛型。这是因为Java中的泛型是不协变的。例如,如果有一个类A和它的子类B,那么List<A>和List<B>之间是不存在继承关系的。 下面我们来看一个例子: ```java public class Animal { //... } public class Dog extends Animal { //... } public class Test { public static void main(String[] args) { List<Animal> list1 = new ArrayList<>(); List<Dog> list2 = new ArrayList<>(); list1 = list2; // 编译错误 } } ``` 在这个例子中,我们定义了Animal类和它的子类Dog。然后我们定义了两个List,分别是List<Animal>和List<Dog>。如果将List<Dog>赋值给List<Animal>,会出现编译错误。这是因为List<Animal>和List<Dog>之间不存在继承关系。 那么,如果我们想要让子类泛型转换成父类泛型,应该怎么办呢?这时我们可以使用通配符来解决问题。通配符可以表示任意类型,包括父类和子类。例如,我们可以将List<Dog>赋值给List<? extends Animal>,这样就可以实现子类泛型转换成父类泛型了。 下面我们来看一个使用通配符的例子: ```java public class Animal { //... } public class Dog extends Animal { //... } public class Test { public static void main(String[] args) { List<Animal> list1 = new ArrayList<>(); List<Dog> list2 = new ArrayList<>(); list1 = list2; // 编译错误 List<? extends Animal> list3 = new ArrayList<>(); list3 = list2; // 正确 } } ``` 在这个例子中,我们定义了List<? extends Animal>来表示任意继承自Animal的类型。然后我们将List<Dog>赋值给List<? extends Animal>,这样就可以实现子类泛型转换成父类泛型了。 总结一下,Java中的泛型是不协变的,子类泛型不能转换成父类泛型。如果需要实现子类泛型转换成父类泛型,可以使用通配符来解决问题。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值