泛型

一:什么是泛型

1.1泛型的本质是泛型的参数化  是jdk5 中引入的一种新特性
泛型是提供了编译时类型安全监测机制,该机制允许我们在编译时监测到非法的类型数
据结构。泛型的本质就是参数化类型,也就是所操作的数据类型被指定为一个参数。


1.2泛型 带来的好处


1)类型的安全
2)消除了强制类型的转换(因为我们创建的时候已经指定了数据类型)

3)代码健壮

二:泛型类、接口

2.1泛型类定义语法

 

class类名称<泛型标识,泛型标识,...>}

private 泛型标识 变量名:

...

}

2.2常用的泛型标识:T 、E 、K、 V

2.3定义一个泛型类

package Four;

/**泛型类的定义
 * @author Administrator
 * @param <T> 泛型标识--类型形参
 *           T创建对象的时候里指定具体的数据类型。
 */
class BigTest<T> {
    //T是由外部指定的类的时候固定的。
    private T key;

    public T getKey() {
        return key;
    }

    public void setKey(T key) {
        this.key = key;
    }

    public BigTest() {
    }

    public BigTest(T key) {
        this.key = key;
    }

    @Override
    public String toString() {
        return "BigTest{" +
                "key=" + key +
                '}';
    }
}

2.4使用方法

使用语法 

类名<具体的数据类型>  对象名 = new 类名<集体的数据类型>();

Java1.7版本之后,后面的<>中具体的数据类型可以不用写了;

类名<具体的数据类型>  对象名 = new 类名<>();

泛型类注意事项

1)泛型类,如果没有指定的数据类型,返回的是Object类型;

2)泛型的类型参数只是类类型,不能是基本数据行;

3)泛型类型在逻辑上可以看成是多个不同的类型,但实际上是相同的类型 ,占用的空间相同。

默认情况下的泛型

 

泛型参数只能是类类型 不能是参数类型

 

同一泛型不同的数据类型,占用的空间大小相同

 

2.5泛型类的继承情况

从泛型类派生子类
1.子类也是泛型类,子类和父类的泛型类型要一致
class ChildGeneric<T> extends Generic<T>
2.子类不是泛型类 ,父类要明确泛型的数据类型
class ChildGeneric extends Generic <String>

创建一个父类

package Four;

/**
 * @author Administrator
 */
public class Parent<E> {
    private E value;

    public void setValue(E value) {
        this.value = value;
    }

    public E getValue(){
        return value;
    }
}

写一个类继承父类
 

package Four;

/**
 * @author Administrator
 * 1.泛型类派生子类。子类也是泛型类,那么子类的泛型标识要和父类一致
 */
public class ChildFirst<T> extends Parent <T>{
    
    @Override
    public T getValue() {
        return super.getValue();
    }

    @Override
    public void setValue(T value) {
        super.setValue(value);
    }
}

2.52在写一个没有指定类型的子类

package Four;

/**
 * @author Administrator
 * 泛型类派生紫烈,如果子类不是泛型类,那么要明确数据类型
 */
public class ChildSecond extends Parent<Integer>{
  

    @Override
    public void setValue(Integer value) {
        super.setValue(value);
    }

    @Override
    public Integer getValue() {
        return super.getValue();
    }
}

在main里面测试

2.6泛型接口

2.61泛型接口的使用

  1)实现列不是泛型类,接口要明确数据类型

2)实现类也是泛型类,实现类和接口的泛型类型要一致

代码 定义一个泛型接口 然后实现泛型接口的例子

第二种实现泛型接口  还是实现上图的接口(提高了泛型接口的灵活性)

三泛型方法

1)泛型类实在实例化类的时候指定说明泛型的具体数据类型

2)泛型方法,实在调用方法的时候指明泛型的具体类型

3.1语法结构

修饰符<T ,E...>返回值类型 方法名 (形参列表)

{

形参列表

}

3.2常用泛型定义形式

package Demo;

/**
 * 定义一个泛型接口
 * @author Administrator
 * 定义公共的方法
 */
public interface  Generator <T> {
    T getKey();
}
package Demo;

/**
 * @author Administrator
 * 在这里可以重写接口公共的方法 和一些自己特定的方法
 */
public class Im  implements Generator{
    @Override
    public Object getKey() {
        return null;
    }

    public Object AddAge() {
        return null;
    }

}
package Demo;

/**
 * @author Administrator
 * 在这里具体调用实现
 */
public class Ex extends Im {
    public static void main(String[] args) {
        Im im = new Im();
        im.AddAge();
        im.getKey();
    }
}

首先定义一个泛型接口 ,然后在各自的类里面去定义各自特有的方法,最后实现,各自的具体方法。

 

四:泛型通配符;

什么是类型通配符;

1)类型通配符一般使用?号 代替具体的类型实参;

2) 类型通配符是实行参数,而不是类型形参;

定义一个泛型类

package Demo;

/**定义一单行类
 * @author Administrator
 */
public class Box<T> {
    private T number;

    public T getNumber() {
        return number;
    }

    public void setNumber(T number) {
        this.number = number;
    }
}

package Demo;

/**
 * @author Administrator
 */
public class BoxTest {
    public static void showBox(Box<?> box){
        Object number = box.getNumber();
        System.out.println(number);
    }
//    public static void showBox(Box<String> box){
//
//    }

    public static void main(String[] args) {
        Box <Integer> box = new Box<>();
        box.setNumber(100);
        showBox(box);
        Box<String> box1 = new Box<>();
        box1.setNumber("十五");
        showBox(box1);
    }
}

 

4.2:通配符的上限问题 建立三个类 分别是 爷爷 父亲 孙子的 类

package Demo;

/**
 * 爷爷辈分的类
 * @author Administrator
 */
public class GrandDad {

}

package Demo;

/**父亲辈分的类
 * @author Administrator
 */
public class Father extends GrandDad{

}
package Demo;

import java.util.ArrayList;

/**孙子辈分的类
 * @author Administrator
 */
public class Son extends Father {
    public static void main(String[] args) {
        ArrayList<GrandDad> arrayList = new ArrayList<>();
        ArrayList<Father> arrayList1 = new ArrayList<>();
        ArrayList<Son> arrayList2 = new ArrayList<>();
        AddPerson(arrayList);
        AddPerson(arrayList1);
        AddPerson(arrayList2);

    }
    public static void AddPerson(ArrayList<? extends Father> list){

    }
}

上限的问题 可以理解为 我和我extends的那一层  ;换言之,extends 后面的(类)的 所有子类 都能使用该方法;

4.3通配符的下限问题 ,下限问题使用super来实现(同样是上面那些类)

 

五:类型的擦除

泛型是java1.5版本才引进的概念,在之前是没有泛型的,但是,泛型代码能够很好地和之前版本的代码兼容。那是因为,泛型信息只存在于代码编译阶段,在进入jvm之前,与泛型相关的信息会被擦除掉,我们称之为--类型擦除

 

 

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值