JAVA--泛型(Generic)

目录

1. 泛型概述

1.1 生活中的例子

1.2 泛型的引入

2. 使用泛型举例

2.1 集合中使用泛型

2.1.1 举例

2.2 比较器中使用泛型

2.2.1 举例

2.2.2 练习

2.3 相关使用说明

3. 自定义泛型结构

3.1 泛型的基础说明

3.2 自定义泛型类或泛型接口

3.2.1 说明

3.2.2 注意

3.2.2 举例

3.3 自定义泛型方法

3.3.1 说明

3.3.2 举例

4. 泛型在继承上的体现

5. 通配符的使用

5.1 通配符的理解

5.2 通配符的读与写

5.3 使用注意点

5.4 有限制的通配符

5.5 泛型应用举例


1. 泛型概述

1.1 生活中的例子

  • 举例1:中药店,每个抽屉外面贴着标签

  • 举例2:家庭厨房中:

Java中的泛型,就类似于上述场景中的标签

1.2 泛型的引入

在Java中,我们在声明方法时,当在完成方法功能时如果有未知的数据需要参与,这些未知的数据需要在调用方法时才能确定,那么我们把这样的数据通过形参表示。在方法体中,用这个形参名来代表那个未知的数据,而调用者在调用时,对应的传入实参就可以了。

受以上启发,JDK1.5设计了泛型的概念。泛型即为“类型参数”,这个类型参数在声明它的类、接口或方法中,代表未知的某种通用类型。

举例1:

集合类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象,所以在JDK5.0之前只能把元素类型设计为Object,JDK5.0时Java引入了“参数化类型(Parameterized type)”的概念,允许我们在创建集合时指定集合元素的类型。比如:List<String>,这表明该List只能保存字符串类型的对象。

使用集合存储数据时,除了元素的类型不确定,其他部分是确定的(例如关于这个元素如何保存,如何管理等)。

举例2:

java.lang.Comparable接口和java.util.Comparator接口,是用于比较对象大小的接口。这两个接口只是限定了当一个对象大于另一个对象时返回正整数,小于返回负整数,等于返回0,但是并不确定是什么类型的对象比较大小。JDK5.0之前只能用Object类型表示,使用时既麻烦又不安全,因此 JDK5.0 给它们增加了泛型。

其中<T>就是类型参数,即泛型。

所谓泛型,就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值或参数的类型。这个类型参数将在使用时(例如,继承或实现这个接口、创建对象或调用方法时)确定(即传入实际的类型参数,也称为类型实参)。

2. 使用泛型举例

自从JDK5.0引入泛型的概念之后,对之前核心类库中的API做了很大的修改,例如:JDK5.0改写了集合框架中的全部接口和类、java.lang.Comparable接口、java.util.Comparator接口、Class类等。为这些接口、类增加了泛型支持,从而可以在声明变量、创建对象时传入类型实参。

2.1 集合中使用泛型

2.1.1 举例

集合中没有使用泛型时:

集合中使用泛型时:

Java泛型可以保证如果程序在编译时没有发出警告,运行时就不会产生ClassCastException异常。即,把不安全的因素在编译期间就排除了,而不是运行期;既然通过了编译,那么类型一定是符合要求的,就避免了类型转换。

同时,代码更加简洁、健壮。

把一个集合中的内容限制为一个特定的数据类型,这就是generic背后的核心思想。

举例:

//泛型在List中的使用
 @Test
 public void test1(){
     //举例:将学生成绩保存在ArrayList中
     //标准写法:
     //ArrayList<Integer> list = new ArrayList<Integer>();
     //jdk7的新特性:类型推断
     ArrayList<Integer> list = new ArrayList<>();
 ​
     list.add(56); //自动装箱
     list.add(76);
     list.add(88);
     list.add(89);
     //当添加非Integer类型数据时,编译不通过
     //list.add("Tom");//编译报错
 ​
     Iterator<Integer> iterator = list.iterator();
     while(iterator.hasNext()){
         //不需要强转,直接可以获取添加时的元素的数据类型
         Integer score = iterator.next();
         System.out.println(score);
     }
 }

举例:

 //泛型在Map中的使用
 @Test
 public void test2(){
     HashMap<String,Integer> map = new HashMap<>();
 ​
     map.put("Tom",67);
     map.put("Jim",56);
     map.put("Rose",88);
     //编译不通过
     //        map.put(67,"Jack");
 ​
     //遍历key集
     Set<String> keySet = map.keySet();
     for(String str:keySet){
         System.out.println(str);
     }
 ​
     //遍历value集
     Collection<Integer> values = map.values();
     Iterator<Integer> iterator = values.iterator();
     while(iterator.hasNext()){
         Integer value = iterator.next();
         System.out.println(value);
     }
 ​
     //遍历entry集
     Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
     Iterator<Map.Entry<String, Integer>> iterator1 = entrySet.iterator();
     while(iterator1.hasNext()){
         Map.Entry<String, Integer> entry = iterator1.next();
         String key = entry.getKey();
         Integer value = entry.getValue();
         System.out.println(key + ":" + value);
     }
 ​
 }

2.2 比较器中使用泛型

2.2.1 举例
 
package com.nanchu.generic;
 ​
 public class Circle{
     private double radius;
 ​
     public Circle(double radius) {
         super();
         this.radius = radius;
     }
 ​
     public double getRadius() {
         return radius;
     }
 ​
     public void setRadius(double radius) {
         this.radius = radius;
     }
 ​
     @Override
     public String toString() {
         return "Circle [radius=" + radius + "]";
     }
 ​
 }

使用泛型之前:

 package com.nanchu.generic;
 ​
 import java.util.Comparator;
 ​
 class CircleComparator implements Comparator{
     @Override
     public int compare(Object o1, Object o2) {
         //强制类型转换
         Circle c1 = (Circle) o1;
         Circle c2 = (Circle) o2;
         return Double.compare(c1.getRadius(), c2.getRadius());
     }
 }
 //测试:
 public class TestNoGeneric {
     public static void main(String[] args) {
         CircleComparator com = new CircleComparator();
         System.out.println(com.compare(new Circle(1), new Circle(2)));
 ​
         System.out.println(com.compare("圆1", "圆2"));//运行时异常:ClassCastException
     }
 }

使用泛型之后:

 package com.nanchu.generic;
 ​
 import java.util.Comparator;
 ​
 class CircleComparator1 implements Comparator<Circle> {
 ​
     @Override
     public int compare(Circle o1, Circle o2) {
         //不再需要强制类型转换,代码更简洁
         return Double.compare(o1.getRadius(), o2.getRadius());
     }
 }
 ​
 //测试类
 public class TestHasGeneric {
     public static void main(String[] args) {
         CircleComparator1 com = new CircleComparator1();
         System.out.println(com.compare(new Circle(1), new Circle(2)));
 ​
         //System.out.println(com.compare("圆1", "圆2"));
         //编译错误,因为"圆1", "圆2"不是Circle类型,是String类型,编译器提前报错,
         //而不是冒着风险在运行时再报错。
     }
 }
2.2.2 练习

(1)声明矩形类Rectangle,包含属性长和宽,属性私有化,提供有参构造、get/set方法、重写toString方法,提供求面积和周长的方法。

(2)矩形类Rectangle实现java.lang.Comparable<T>接口,并指定泛型为<Rectangle>,重写int compareTo(T t)方法,按照矩形面积比较大小,面积相等的,按照周长比较大小。

(3)在测试类中,创建Rectangle数组,并创建5个矩形对象

(4)调用Arrays的sort方法,给矩形数组排序,并显示排序前后的结果。

package com.nanchu.genericclass.use;
 ​
 public class Rectangle implements Comparable<Rectangle>{
     private double length;
     private double width;
 ​
     public Rectangle(double length, double width) {
         this.length = length;
         this.width = width;
     }
 ​
     public double getLength() {
         return length;
     }
 ​
     public void setLength(double length) {
         this.length = length;
     }
 ​
     public double getWidth() {
         return width;
     }
 ​
     public void setWidth(double width) {
         this.width = width;
     }
     //获取面积
     public double area(){
         return length * width;
     }
     //获取周长
     public double perimeter(){
         return 2 * (length + width);
     }
 ​
     @Override
     public String toString() {
         return "Rectangle{" +
                 "length=" + length +
                 ", width=" + width +
                 ",area =" + area() +
                 ",perimeter = " + perimeter() +
                 '}';
     }
 ​
     @Override
     public int compareTo(Rectangle o) {
         int compare = Double.compare(area(), o.area());
         return compare != 0 ? compare : Double.compare(perimeter(),o.perimeter());
     }
 }
 ​
package com.nanchu.genericclass.use;

import java.util.Arrays;

public class TestRectangle {
    public static void main(String[] args) {
        Rectangle[] arr = new Rectangle[4];
        arr[0] = new Rectangle(6,2);
        arr[1] = new Rectangle(4,3);
        arr[2] = new Rectangle(12,1);
        arr[3] = new Rectangle(5,4);

        System.out.println("排序之前:");
        for (Rectangle rectangle : arr) {
            System.out.println(rectangle);
        }

        Arrays.sort(arr);

        System.out.println("排序之后:");
        for (Rectangle rectangle : arr) {
            System.out.println(rectangle);
        }
    }
}

2.3 相关使用说明

  • 在创建集合对象的时候,可以指明泛型的类型。

    具体格式为:List<Integer> list = new ArrayList<Integer>();

  • JDK7.0时,有新特性,可以简写为:

    List<Integer> list = new ArrayList<>(); //类型推断

  • 泛型,也称为泛型参数,即参数的类型,只能使用引用数据类型进行赋值。(不能使用基本数据类型,可以使用包装类替换)

  • 集合声明时,声明泛型参数。在使用集合时,可以具体指明泛型的类型。一旦指明,类或接口内部,凡是使用泛型参数的位置,都指定为具体的参数类型。如果没有指明的话,看做是Object类型。

3. 自定义泛型结构

3.1 泛型的基础说明

1、<类型>这种语法形式就叫泛型。

  • <类型>的形式我们称为类型参数,这里的"类型"习惯上使用T表示,是Type的缩写。即:<T>。

  • <T>:代表未知的数据类型,我们可以指定为<String>,<Integer>,<Circle>等。

    • 类比方法的参数的概念,我们把<T>,称为类型形参,将<Circle>称为类型实参,有助于我们理解泛型

  • 这里的T,可以替换成K,V等任意字母。

2、在哪里可以声明类型变量<T>

  • 声明类或接口时,在类名或接口名后面声明泛型类型,我们把这样的类或接口称为泛型类泛型接口

【修饰符】 class 类名<类型变量列表> 【extends 父类】 【implements 接口们】{
    
}
【修饰符】 interface 接口名<类型变量列表> 【implements 接口们】{
    
}
//例如:
public class ArrayList<E>    
public interface Map<K,V>{
    ....
}    
  • 声明方法时,在【修饰符】与返回值类型之间声明类型变量,我们把声明了类型变量的方法,称为泛型方法。

[修饰符] <类型变量列表> 返回值类型 方法名([形参列表])[throws 异常列表]{
    //...
}

//例如:java.util.Arrays类中的
public static <T> List<T> asList(T... a){
    ....
}

3.2 自定义泛型类或泛型接口

当我们在类或接口中定义某个成员时,该成员的相关类型是不确定的,而这个类型需要在使用这个类或接口时才可以确定,那么我们可以使用泛型类、泛型接口。

3.2.1 说明

① 我们在声明完自定义泛型类以后,可以在类的内部(比如:属性、方法、构造器中)使用类的泛型。

② 我们在创建自定义泛型类的对象时,可以指明泛型参数类型。一旦指明,内部凡是使用类的泛型参数的位置,都具体化为指定的类的泛型类型。

③ 如果在创建自定义泛型类的对象时,没有指明泛型参数类型,那么泛型将被擦除,泛型对应的类型均按照Object处理,但不等价于Object。

  • 经验:泛型要使用一路都用。要不用,一路都不要用。

④ 泛型的指定中必须使用引用数据类型。不能使用基本数据类型,此时只能使用包装类替换。

⑤ 除创建泛型类对象外,子类继承泛型类时、实现类实现泛型接口时,也可以确定泛型结构中的泛型参数。

如果我们在给泛型类提供子类时,子类也不确定泛型的类型,则可以继续使用泛型参数。

我们还可以在现有的父类的泛型参数的基础上,新增泛型参数。

3.2.2 注意

① 泛型类可能有多个参数,此时应将多个参数一起放在尖括号内。比如:<E1,E2,E3>

② JDK7.0 开始,泛型的简化操作:ArrayList<Fruit> flist = new ArrayList<>();

③ 如果泛型结构是一个接口或抽象类,则不可创建泛型类的对象。

④ 不能使用new E[]。但是可以:E[] elements = (E[])new Object[capacity];

参考:ArrayList源码中声明:Object[] elementData,而非泛型参数类型数组。

⑤ 在类/接口上声明的泛型,在本类或本接口中即代表某种类型,但不可以在静态方法中使用类的泛型。

⑥ 异常类不能是带泛型的。

3.2.2 举例

举例1:

class Person<T> {
    // 使用T类型定义变量
    private T info;
    // 使用T类型定义一般方法
    public T getInfo() {
        return info;
    }
    public void setInfo(T info) {
        this.info = info;
    }
    // 使用T类型定义构造器
    public Person() {
    }
    public Person(T info) {
        this.info = info;
    }
    // static的方法中不能声明泛型
    //public static void show(T t) {
    //
    //}
    // 不能在try-catch中使用泛型定义
    //public void test() {
        //try {
        //
        //} catch (MyException<T> ex) {
        //
        //}
    //}
}

举例2:

class Father<T1, T2> {
}
// 子类不保留父类的泛型
// 1)没有类型 擦除
class Son1 extends Father {// 等价于class Son extends Father<Object,Object>{
}
// 2)具体类型
class Son2 extends Father<Integer, String> {
}
// 子类保留父类的泛型
// 1)全部保留
class Son3<T1, T2> extends Father<T1, T2> {
}
// 2)部分保留
class Son4<T2> extends Father<Integer, T2> {
}

举例3:

class Father<T1, T2> {
}
// 子类不保留父类的泛型
// 1)没有类型 擦除
class Son<A, B> extends Father{//等价于class Son extends Father<Object,Object>{
}
// 2)具体类型
class Son2<A, B> extends Father<Integer, String> {
}
// 子类保留父类的泛型
// 1)全部保留
class Son3<T1, T2, A, B> extends Father<T1, T2> {
}
// 2)部分保留
class Son4<T2, A, B> extends Father<Integer, T2> {
}

3.3 自定义泛型方法

如果我们定义类、接口时没有使用<泛型参数>,但是某个方法形参类型不确定时,这个方法可以单独定义<泛型参数>。

3.3.1 说明
  • 泛型方法的格式:

[访问权限]  <泛型>  返回值类型  方法名([泛型标识 参数名称])  [抛出的异常]{
    
}
  • 方法,也可以被泛型化,与其所在的类是否是泛型类没有关系。

  • 泛型方法中的泛型参数在方法被调用时确定。

  • 泛型方法可以根据需要,声明为static的。

3.3.2 举例

举例1:

public class DAO {

    public <E> E get(int id, E e) {

        E result = null;

        return result;
    }
}

举例2:

public static <T> void fromArrayToCollection(T[] a, Collection<T> c) {
    for (T o : a) {
        c.add(o);
    }
}

public static void main(String[] args) {
    Object[] ao = new Object[100];
    Collection<Object> co = new ArrayList<Object>();
    fromArrayToCollection(ao, co);

    String[] sa = new String[20];
    Collection<String> cs = new ArrayList<>();
    fromArrayToCollection(sa, cs);

    Collection<Double> cd = new ArrayList<>();
    // 下面代码中T是Double类,但sa是String类型,编译错误。
    // fromArrayToCollection(sa, cd);
    // 下面代码中T是Object类型,sa是String类型,可以赋值成功。
    fromArrayToCollection(sa, co);
}

举例3:

class MyArrays {
    public static <T> void sort(T[] arr){
        for (int i = 1; i < arr.length; i++) {
            for (int j = 0; j < arr.length-i; j++) {
                if(((Comparable<T>)arr[j]).compareTo(arr[j+1])>0){
                    T temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }
}

public class MyArraysTest {
    public static void main(String[] args) {
        int[] arr = {3,2,5,1,4};
//		MyArrays.sort(arr);//错误的,因为int[]不是对象数组

        String[] strings = {"hello","java","song"};
        MyArrays.sort(strings);
        System.out.println(Arrays.toString(strings));

        Circle[] circles = {new Circle(2.0),new Circle(1.2),new Circle(3.0)};
        MyArrays.sort(circles); //编译通过,运行报错,因为Circle没有实现Comparable接口
    }
}

4. 泛型在继承上的体现

如果B是A的一个子类型(子类或者子接口),而G是具有泛型声明的类或接口,G<B>并不是G<A>的子类型!

比如:String是Object的子类,但是List<String>并不是List<Object>的子类。

public void testGenericAndSubClass() {
    Person[] persons = null;
    Man[] mans = null;
    //Person[] 是 Man[] 的父类
    persons = mans;

    Person p = mans[0];

    // 在泛型的集合上
    List<Person> personList = null;
    List<Man> manList = null;
    //personList = manList;(报错)
}

思考:对比如下两段代码有何不同:

片段1:

public void printCollection(Collection c) {
    Iterator i = c.iterator();
    for (int k = 0; k < c.size(); k++) {
        System.out.println(i.next());
    }
}

片段2:

public void printCollection(Collection<Object> c) {
    for (Object e : c) {
        System.out.println(e);
    }
}

5. 通配符的使用

当我们声明一个变量/形参时,这个变量/形参的类型是一个泛型类或泛型接口,例如:Comparator<T>类型,但是我们仍然无法确定这个泛型类或泛型接口的类型变量<T>的具体类型,此时我们考虑使用类型通配符 ? 。

5.1 通配符的理解

使用类型通配符:?

比如:List<?>Map<?,?>

List<?>是List<String>、List<Object>等各种泛型List的父类。

5.2 通配符的读与写

写操作:

将任意元素加入到其中不是类型安全的:

Collection<?> c = new ArrayList<String>();

c.add(new Object()); // 编译时错误

因为我们不知道c的元素类型,我们不能向其中添加对象。add方法有类型参数E作为集合的元素类型。我们传给add的任何参数都必须是一个未知类型的子类。因为我们不知道那是什么类型,所以我们无法传任何东西进去。

唯一可以插入的元素是null,因为它是所有引用类型的默认值。

读操作:

另一方面,读取List<?>的对象list中的元素时,永远是安全的,因为不管 list 的真实类型是什么,它包含的都是Object。

举例1:

public class TestWildcard {
    public static void m4(Collection<?> coll){
        for (Object o : coll) {
            System.out.println(o);
        }
    }
}

举例2:

public static void main(String[] args) {
    List<?> list = null;
    list = new ArrayList<String>();
    list = new ArrayList<Double>();
    // list.add(3);//编译不通过
    list.add(null);

    List<String> l1 = new ArrayList<String>();
    List<Integer> l2 = new ArrayList<Integer>();
    l1.add("南初");
    l2.add(15);
    read(l1);
    read(l2);
}

public static void read(List<?> list) {
    for (Object o : list) {
        System.out.println(o);
    }
}

5.3 使用注意点

注意点1:编译错误:不能用在泛型方法声明上,返回值类型前面<>不能使用?

public static <?> void test(ArrayList<?> list){
}

注意点2:编译错误:不能用在泛型类的声明上

class GenericTypeClass<?>{
}

注意点3:编译错误:不能用在创建对象上,右边属于创建集合对象

ArrayList<?> list2 = new ArrayList<?>();

5.4 有限制的通配符

  • <?>

    • 允许所有泛型的引用调用

  • 通配符指定上限:<? extends 类/接口 >

    • 使用时指定的类型必须是继承某个类,或者实现某个接口,即<=

  • 通配符指定下限:<? super 类/接口 >

    • 使用时指定的类型必须是操作的类或接口,或者是操作的类的父类或接口的父接口,即>=

  • 说明:

    <? extends Number>     //(无穷小 , Number]
    //只允许泛型为Number及Number子类的引用调用
    
    <? super Number>      //[Number , 无穷大)
    //只允许泛型为Number及Number父类的引用调用
    
    <? extends Comparable>
    //只允许泛型为实现Comparable接口的实现类的引用调用
  • 举例1

    class Creature{}
    class Person extends Creature{}
    class Man extends Person{}
    
    class PersonTest {
        public static <T extends Person> void test(T t){
            System.out.println(t);
        }
    
        public static void main(String[] args) {
            test(new Person());
            test(new Man());
            //The method test(T) in the type PersonTest is not 
            //applicable for the arguments (Creature)
            test(new Creature());
        }
    }

  • 举例2:

    public static void main(String[] args) {
        Collection<Integer> list1 = new ArrayList<Integer>();
        Collection<String> list2 = new ArrayList<String>();
        Collection<Number> list3 = new ArrayList<Number>();
        Collection<Object> list4 = new ArrayList<Object>();
        
        getElement1(list1);
        getElement1(list2);//报错
        getElement1(list3);
        getElement1(list4);//报错
      
        getElement2(list1);//报错
        getElement2(list2);//报错
        getElement2(list3);
        getElement2(list4);
      
    }
    // 泛型的上限:此时的泛型?,必须是Number类型或者Number类型的子类
    public static void getElement1(Collection<? extends Number> coll){}
    // 泛型的下限:此时的泛型?,必须是Number类型或者Number类型的父类
    public static void getElement2(Collection<? super Number> coll){}
  • 举例3:

    public static void printCollection1(Collection<? extends Person> coll) {
        //Iterator只能用Iterator<?>或Iterator<? extends Person>.why?
        Iterator<?> iterator = coll.iterator();
        while (iterator.hasNext()) {
            Person per = iterator.next();
            System.out.println(per);
        }
    }
    
    public static void printCollection2(Collection<? super Person> coll) {
        //Iterator只能用Iterator<?>或Iterator<? super Person>.why?
        Iterator<?> iterator = coll.iterator();
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println(obj);
        }
    }

举例4:

@Test
public void test1(){
    //List<Object> list1 = null;
    List<Person> list2 = new ArrayList<Person>();
    //List<Student> list3 = null;

    List<? extends Person> list4 = null;

    list2.add(new Person());
    list4 = list2;

    //读取:可以读
    Person p1 = list4.get(0);

    //写入:除了null之外,不能写入
    list4.add(null);
    //        list4.add(new Person());
    //        list4.add(new Student());

}
@Test
public void test2(){
    //List<Object> list1 = null;
    List<Person> list2 = new ArrayList<Person>();
    //List<Student> list3 = null;

    List<? super Person> list5 = null;
    list2.add(new Person());

    list5 = list2;

    //读取:可以实现
    Object obj = list5.get(0);

    //写入:可以写入Person及Person子类的对象
    list5.add(new Person());
    list5.add(new Student());

}

5.5 泛型应用举例

举例1:泛型嵌套

public static void main(String[] args) {
    HashMap<String, ArrayList<Citizen>> map = new HashMap<String, ArrayList<Citizen>>();
    ArrayList<Citizen> list = new ArrayList<Citizen>();
    list.add(new Citizen("赵又廷"));
    list.add(new Citizen("高圆圆"));
    list.add(new Citizen("瑞亚"));
    map.put("赵又廷", list);

    Set<Entry<String, ArrayList<Citizen>>> entrySet = map.entrySet();
    Iterator<Entry<String, ArrayList<Citizen>>> iterator = entrySet.iterator();
    while (iterator.hasNext()) {
        Entry<String, ArrayList<Citizen>> entry = iterator.next();
        String key = entry.getKey();
        ArrayList<Citizen> value = entry.getValue();
        System.out.println("户主:" + key);
        System.out.println("家庭成员:" + value);
    }
}

举例2:个人信息设计

用户在设计类的时候往往会使用类的关联关系,例如,一个人中可以定义一个信息的属性,但是一个人可能有各种各样的信息(如联系方式、基本信息等),所以此信息属性的类型就可以通过泛型进行声明,然后只要设计相应的信息类即可。

interface Info{		// 只有此接口的子类才是表示人的信息
}
class Contact implements Info{	// 表示联系方式
	private String address ;	// 联系地址
	private String telephone ;	// 联系方式
	private String zipcode ;	// 邮政编码
	public Contact(String address,String telephone,String zipcode){
		this.address = address;
		this.telephone = telephone;
		this.zipcode = zipcode;
	}
	public void setAddress(String address){
		this.address = address ;
	}
	public void setTelephone(String telephone){
		this.telephone = telephone ;
	}
	public void setZipcode(String zipcode){
		this.zipcode = zipcode;
	}
	public String getAddress(){
		return this.address ;
	}
	public String getTelephone(){
		return this.telephone ;
	}
	public String getZipcode(){
		return this.zipcode;
	}
	@Override
	public String toString() {
		return "Contact [address=" + address + ", telephone=" + telephone
				+ ", zipcode=" + zipcode + "]";
	}
}
class Introduction implements Info{
	private String name ;		// 姓名
	private String sex ;		// 性别
	private int age ;			// 年龄
	public Introduction(String name,String sex,int age){
		this.name = name;
		this.sex = sex;
		this.age = age;
	}
	public void setName(String name){
		this.name = name ;
	}
	public void setSex(String sex){
		this.sex = sex ;
	}
	public void setAge(int age){
		this.age = age ;
	}
	public String getName(){
		return this.name ;
	}
	public String getSex(){
		return this.sex ;
	}
	public int getAge(){
		return this.age ;
	}
	@Override
	public String toString() {
		return "Introduction [name=" + name + ", sex=" + sex + ", age=" + age
				+ "]";
	}
}
class Person<T extends Info>{
	private T info ;
	public Person(T info){		// 通过构造器设置信息属性内容
		this.info = info;
	}
	public void setInfo(T info){
		this.info = info ;
	}
	public T getInfo(){
		return info ;
	}
	@Override
	public String toString() {
		return "Person [info=" + info + "]";
	}
	
}
public class GenericPerson{
	public static void main(String args[]){
		Person<Contact> per = null ;		// 声明Person对象
		per = new Person<Contact>(new Contact("北京市","01088888888","102206")) ;
		System.out.println(per);
		
		Person<Introduction> per2 = null ;		// 声明Person对象
		per2 = new Person<Introduction>(new Introduction("李雷","男",24));
		System.out.println(per2) ;
	}
}

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/394471.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

LabVIEW智能监测系统

LabVIEW智能监测系统 设计与实现一个基于LabVIEW的智能监测系统&#xff0c;通过高效的数据采集和处理能力&#xff0c;提高监测精度和响应速度。系统通过集成传感器技术与虚拟仪器软件&#xff0c;实现对环境参数的实时监测与分析&#xff0c;进而优化监控过程&#xff0c;提…

平滑升级旧版nginx,使其支持健康检测模组

nginx是部署在华为欧拉的docker容器中&#xff0c;版本是2203sp1.x86_64 查看旧版nginx的版本与编译配置信息&#xff1a; nginx -Vnginx version: nginx/1.14.1 built by gcc 8.3.1 20191121 (Red Hat 8.3.1-5) (GCC) built with OpenSSL 1.1.1g FIPS 21 Apr 2020 (running …

解决Ubuntu下网络适配器桥接模式下ping网址不通的情况

问题反应&#xff1a;ping不通网址 打开虚拟机中的设置&#xff0c;更改网络适配器为NAT模式 确定保存更改之后&#xff0c;退出输入如下命令。 命令1&#xff1a; sudo /etc/network/inferfaces 命令2&#xff1a; sudo /etc/init.d/network/ restart

SpringCloud-Config:分布式配置

10. Spring Cloud Config 分布式配置 Dalston.RELEASE Spring Cloud Config为分布式系统中的外部配置提供服务器和客户端支持。使用Config Server&#xff0c;您可以在所有环境中管理应用程序的外部属性。客户端和服务器上的概念映射与Spring Environment和PropertySource抽象…

电商云平台系统的设计与实现

随着电商市场的不断发展&#xff0c;越来越多的企业和个人选择通过电商平台开展业务。为了更好地满足电商市场的需求&#xff0c;一个高效、安全、可扩展的电商云平台系统是必不可少的。本文将介绍电商云平台系统的设计与实现。 1. 系统架构设计 电商云平台系统的架构设计主要…

SSTI模板注入漏洞(vulhub 复现)

首先了解模板引擎&#xff1a; 模板引擎&#xff08;这里特指用于Web开发的模板引擎&#xff09;是为了使用户界面与业务数据&#xff08;内容&#xff09;分离而产生的&#xff0c;它可以生成特定格式的文档&#xff0c;利用模板引擎来生成前端的html代码&#xff0c;模板引擎…

JS加密解密之JS广告漂浮代码分析

前言 之前有个客户要求帮忙复刻一份广告漂浮代码&#xff0c;我看了下&#xff0c;目标站的广告代码是通过了JS加密后的&#xff0c;经过我解密还原后分析了一下该代码的作用如下。 ;var _0xodDddd,_0xodD_[_0xodD],_0x1d02[_0xodD,\x73\x54\x69\x6d\x65,\x6c\x6f\x61\x64\x5…

Vue3 provide + inject

provide&#xff1a;提供一个值&#xff0c;可以在应用中的所有后代组件中注入使用。 官方文档&#xff1a;应用实例 API | Vue.js 应用实例 API | Vue.jsVue.js - 渐进式的 JavaScript 框架https://cn.vuejs.org/api/application.html#app-provide 使用示例 祖先组件 <…

『随处指挥』:用这款APP,世界听你的!

在这个科技日新月异的时代&#xff0c;我们的生活被各种手机软件所包围。几乎每个人都有一个甚至多个手机&#xff0c;你是否也有遇到过需要远程操作自己某一台手机的场景呢&#xff1f;今天&#xff0c;我要向大家推荐一款神奇的手机远程操作神器&#xff0c;让你可以随时随地…

【设计模式】4、策略模式

文章目录 一、问题二、解决方案2.1 真实世界的类比2.2 策略模式结构2.3 适用场景2.4 实现方式2.5 优缺点2.6 与其他模式的关系 三、示例代码3.1 go3.2 rust 策略模式是一种行为设计模式&#xff0c;它能定义一系列算法&#xff0c;把每种算法分别放入独立的类中&#xff0c;以是…

[Flask]SSTI1 buuctf

声明&#xff1a;本篇文章csdn要我一天发两篇所以我来水的 跟ssti注入的详细知识我这里写了 https://blog.csdn.net/weixin_74790320/article/details/136154130 上面链接我复现了vulhub的SSTI&#xff0c;其实本质上是一道题 然后我们就用{{.__class__}}看类的类型&#xf…

政安晨:【完全零基础】认知人工智能(三)【超级简单】的【机器学习神经网络】—— 三层神经网络示例

知识准备 咱们还没有演示过使用矩阵进行计算得到经由神经网络馈送的信号&#xff0c;我们也没有演示过多于2层的神经网络示例&#xff0c;在这篇文章里&#xff0c;咱们将构建一个三层神经网络的示例&#xff0c;并观察如何处理中间层的输出以作为最后第三层的输入&#xff0c…

百度智能云分布式数据库 GaiaDB-X 与龙芯平台完成兼容认证

近日&#xff0c;百度智能云的分布式关系型数据库软件 V3.0 与龙芯中科技术股份有限公司的龙芯 3C5000L/3C5000 处理器平台完成兼容性测试&#xff0c;功能与稳定性良好&#xff0c;获得了龙架构兼容互认证证书。 龙芯系列处理器 通用 CPU 处理器是信息产业的基础部件&#xf…

【CSS】设置文字(文本)的渐变色

# 渐变色 文字 第一步 设置渐变颜色 background: linear-gradient(278.83deg, #5022bd 31.42%, #8636d1 75.55%); // 先设置渐变色背景&#xff1b; 第二步 设置颜色的使用范围 background-clip: text; // 背景被裁剪成文字的前景色。 -webkit-background-clip: text; 第三步…

微前端(qiankun)vue3+vite

目录 一、什么是微前端 二、主应用接入 qiankun 1.按照qiankun插件 2.注册微应用引用 3.挂载容器 三、微应用接入 qiankun 1.vite.config.ts 2.main.ts ps&#xff1a;手动加载微应用方式 ps&#xff1a;为什么不用 iframe 一、什么是微前端 微前端是一种多个团队通过独…

MAC电脑系统清理空间免费版软件CleanMyMac X2024

大家好&#xff0c;我是那个总是被苹果电脑“内存已满”提示搞得焦头烂额的专业博主。如果你也像我一样&#xff0c;在使用Mac时经常遭遇卡顿、慢吞吞的情况&#xff0c;那么今天的Mac清理空间妙招分享绝对适合你&#xff01; CleanMyMac X全新版下载如下: https://wm.makedi…

为什么深度神经网络难以完全模拟人脑思维

由于深度神经网络基于线性函数和激活函数&#xff0c;不能完全模拟人脑思维&#xff0c;也许这是瓶颈。在人类思维中&#xff0c;我们能够处理模糊的概念&#xff0c;例如对于一只动物是否属于“狗”的判断&#xff0c;我们可以接受一定程度上的模糊性。但是在深度网络中&#…

IDEA2023.3.4开启SpringBoot项目的热部署【简单明了4步操作】

添加devtools依赖 <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId><scope>runtime</scope><optional>true</optional> </dependency>IDEA开启自动编译 …

PCB的介质损耗角是什么“∠”?

1、什么叫介质 介质是指在某种特定条件下能够传递力、能量或信息的物质或者空间。在物理学和工程学中&#xff0c;介质通常是指固体、液体或气体&#xff0c;它们能够传递机械波、电磁波等。例如&#xff0c;在声学中&#xff0c;空气、水和固体都可以作为声波的传播介质&…

使用vscode传入参数的方式进行debug

使用vscode传入参数的方式进行debug {// 使用 IntelliSense 了解相关属性。 // 悬停以查看现有属性的描述。// 欲了解更多信息&#xff0c;请访问: https://go.microsoft.com/fwlink/?linkid830387"version": "0.2.0","configurations": [{&quo…