Java第十五天，泛型

一、定义

泛型是一种未知的数据类型，即当我们不知道该使用哪种数据类型的时候，可以使用泛型。

泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

在定义类或者方法或者接口的时候，是无法指定需要的参数类型的。这时候，我们需要将参数类型设置为一个参数。这就是所谓的参数化类型。

二、基本使用

1.存在泛型参数的类

注：含有泛型的类只有在创建对象的时候，才能确定泛型的数据类型。

（1）定义

修饰符 class genericClass<E>{

修饰符 genericClass(){ //不带参构造函数

}

修饰符 genericClass(E e){ //带参构造函数

}

（2）创建泛型类对象

genericClass<E> obj = new genericClass<>(); //无参构造函数创建对象

或

E e = new E();

genericClass<E> obj = new genericClass<>(e); //带参构造函数创建对象

2.含有泛型的方法

注：只有在调用方法的时候，才能确定泛型的数据类型。

（1）定义

修饰符 <E> 返回值类型方法名（E或者普通参数）｛

｝

（2）代码：

泛型类：

package com.lanyue.day12;

public class genericLearn{

    public <E> String getName(E e){

        if(e instanceof Stu){

            return ((Stu) e).getName();

        }else{

            return "数据类型转换错误";

        }

    }

}

泛型类测试需要的类：

package com.lanyue.day12;

public class Stu {

    private int age;

    private String name;

    public Stu(int age, String name) {

        this.age = age;

        this.name = name;

    }

    public int getAge() {

        return age;

    }

    public String getName() {

        return name;

    }

}

运行代码：

package com.lanyue.day12;

public class Demo {

    public static void main(String[] args) {

        Stu stu = new Stu(20,"胡海");

        genericLearn stuOne = new genericLearn();

        System.out.println(stuOne.getName(stu));

    }

}

3.含有泛型的接口

（1）定义含有泛型的接口

修饰符nterface<E>{

}

（2）定义实现泛型接口的实现类

方法①：指定实现类接受参数类型

修饰符 class 类名 implements 接口<指定数据类型>{

}

方法②：让实现类接受的参数类型继续为泛型

修饰符 class 类名<泛型> implements 接口<泛型>｛

｝

（3）代码：

USB接口代码：

package com.lanyue.day13;

public interface Usb<E> {

    public abstract void inPut(E e);

    public abstract void outPut(E e);

}

USB接口实现类一：

package com.lanyue.day13;

public class UsbImpl implements Usb<String>{

    @Override

    public void inPut(String info) {

        System.out.println("正在往优盘传输数据" + info);

    }

    @Override

    public void outPut(String info) {

        System.out.println("正在从优盘拷贝数据" + info);

    }

}

USB接口实现类二：

package com.lanyue.day13;

public class UsbImplTwo<E> implements Usb<E> {

    @Override

    public void inPut(E e) {

        if(e instanceof Stu){

            System.out.println("正在拷贝" + ((Stu) e).getName() + "同学的信息到优盘");

        }else{

            System.out.println("数据解析失败");

        }

    }

    @Override

    public void outPut(E e) {

        if(e instanceof Stu){

            System.out.println("正在从优盘拷贝" + ((Stu) e).getName() + "同学的信息");

        }else{

            System.out.println("数据解析失败");

        }

    }

}

中间自定义类：

package com.lanyue.day13;

public class Stu {

    public String name;

    public Stu(String name) {

        this.name = name;

    }

    public String getName() {

        return name;

    }

}

运行类：

package com.lanyue.day13;

public class Demo {

    public static void main(String[] args) {

        UsbImpl usbOne = new UsbImpl();

        usbOne.inPut("Java");

        usbOne.outPut("C++");

        Stu stu = new Stu("蓝月");

        UsbImplTwo usbTwo = new UsbImplTwo();

        usbTwo.inPut(stu);

        usbTwo.outPut(stu);

        usbTwo.inPut("蓝月");

        usbTwo.outPut("蓝月");

    }

}

4.泛型通配符

当使用泛型类或者泛型接口时，传递的数据中，泛型类型不确定。可以通过通配符<?>表示。但是一旦使用泛型通配符之后，只能使用Object类中的共性方法。集合中元素的特有方法无法使用。且只能接受数据，而不能往该集合中存储数据。

（1）注意

① 被泛型通配符修饰的类或接口的实现类不能创建对象使用，只能作为方法的参数使用。

② 泛型是没有继承概念的。

③ 受限泛型

1）.泛型的上限：只能接受该类型和其子类

定义格式：

类名 <? extends 类> 对象名称

2）泛型的下限：只能接受该类型和其父类

定义格式：

类名 <? super 类> 对象名称

3）代码：

整体框架简介：

为了测试泛型通配符的用法，我们需要一个父类Person，两个子类Stu和Worker分别继承了父类。在Usb接口的实现类UsbImpl中，我们完成了对泛型通配符的利用。

Person类：

package com.lanyue.day14;

public class Person {

    public static int ID = 1;

    public String name;

    public Person(){

        ID++;

    }

    public void setName(String name) {

        this.name = name;

    }

    public String getName() {

        return name;

    }

}

Stu类：

package com.lanyue.day14;

public class Stu extends Person{

    public String workPlace = "石家庄职业技术学院";

    public String getWorkPlace(){

        return workPlace;

    }

}

Worker类：

package com.lanyue.day14;

public class Worker extends Person{

    public String workPlace = "富士康";

    public String getSP() {

        return workPlace;

    }

    public String getWorkPlace() {

        return workPlace;

    }

}

Usb接口：

package com.lanyue.day14;

import java.util.ArrayList;

public interface UsbInt {

    public abstract void getInfo(ArrayList<? extends Person> list);

}

Usb接口实现类——UsbImpl类:

package com.lanyue.day14;

import java.util.ArrayList;

import java.util.Iterator;

public class UsbImpl implements UsbInt {

    @Override

    public void getInfo(ArrayList<? extends Person> list) {

        Iterator<? extends Person> iterator = list.iterator();

        while(iterator.hasNext()){

            Person person = iterator.next();

            System.out.println("已在数据库中查找到 " + person.getName() + " 同学");

        }

    }

}

运行代码：

package com.lanyue.day14;

import java.util.ArrayList;

public class Demo {

    public static void main(String[] args) {

        Stu one = new Stu();

        one.setName("蓝月");

        Worker two = new Worker();

        two.setName("天行");

        Person three = new Person();

        three.setName("逍遥");

        UsbImpl usb = new UsbImpl();

        ArrayList<Stu> stus = new ArrayList<>();

        stus.add(one);

        ArrayList<Worker> works = new ArrayList<>();

        works.add(two);

        ArrayList<Person> persons = new ArrayList<>();

        persons.add(three);

        usb.getInfo(stus);

        usb.getInfo(works);

        usb.getInfo(persons);

    }

}

巴特西

Java第十五天，泛型

最新文章

热门文章