集合进阶-----Collection单列：泛型

 

泛型类：

package 集合进阶.Collection单列.泛型.泛型类;

public class Student {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

package 集合进阶.Collection单列.泛型.泛型类;

public class Teacher {

    private Integer age;

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

package 集合进阶.Collection单列.泛型.泛型类;

public class Generic <T> {

    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }

}

package 集合进阶.Collection单列.泛型.泛型类;
/*
     泛型类格式：
         格式：    修饰符 class 类名 <类型> ()
         范例：    public class Generic <T>{}
                    此处T可以随便写任意标识，如常见的T,E,K,V等形式的参数常用于泛型

 */

public class GenericDemo {
    public static void main(String[] args) {
        Student s=new Student();
        s.setName("程序员");
        System.out.println(s.getName());

        Teacher t=new Teacher();
        t.setAge(20);
        System.out.println(t.getAge());

        System.out.println("-------------");


        Generic<String> g1=new Generic<String>();
        g1.setT("程序员");
        System.out.println(g1.getT());

        Generic<Integer> g2=new Generic<Integer>();
        g2.setT(20);
        System.out.println(g2.getT());

        Generic<Boolean> g3=new Generic<Boolean>();
        g3.setT(true);
        System.out.println(g3.getT());


    }
}

 

泛型方法：

package 集合进阶.Collection单列.泛型.泛型方法;

/*
        泛型方法定义格式
            格式： 修饰符 <类型> 返回值类型 方法名 (类型 变量名) {}
            范例： public <T> void show(T t) {}
 */


public class Generic {
    public <T> void show(T t) {
        System.out.println(t);
    }
}

package 集合进阶.Collection单列.泛型.泛型方法;
/*
        泛型方法定义格式
            格式： 修饰符 <类型> 返回值类型 方法名 (类型 变量名) {}
            范例： public <T> void show(T t) {}
 */

public class GenericDemo {
    public static void main(String[] args) {

        Generic g = new Generic();
        g.show("程序员");
        g.show(20);
        g.show(true);
        g.show(12.34);

    }
}

泛型接口： 

package 集合进阶.Collection单列.泛型.泛型接口;
/*
        泛型接口定义格式：
            格式： 修饰符 interface 接口名 <类型>{}
            范例： public interface Generic <T>{}
 */

public interface Generic<T> {
    void show(T t);
}

package 集合进阶.Collection单列.泛型.泛型接口;

public class GenericImpl <T> implements Generic<T> {

    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

package 集合进阶.Collection单列.泛型.泛型接口;

public class GenericDemo {
    public static void main(String[] args) {

        Generic<String> g1=new GenericImpl<String>();
        g1.show("程序员");

        Generic<Integer> g2=new GenericImpl<Integer>();
        g2.show(20);

    }
}

类型通配符：

 

package 集合进阶.Collection单列.泛型;
/*
    类型通配符：
    1.为了表示各种泛型List的父类，可以使用类型通配符
       类型通配符:<?>
       List<?>:表示元素类型未知的List，它的元素可以匹配任何的类型
       这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中

    2.如果说我们不希望List<?>是任何泛型List的父类，只希望它代表某一类泛型List的父类，可以使用类型通配符的上限
        类型通配符上限:<?extends类型>
        List<? extends Number>:它表示的类型是Number或者其子类型

    3.除了可以指定类型通配符的上限，我们也可以指定类型通配符的下限
        类型通配符下限:<?super类型>
        List<?super Number>:它表示的类型是Number或者其父类型


 */

import java.util.ArrayList;
import java.util.List;

public class 类型通配符 {
    public static void main(String[] args) {

        //类型通配符:<?>
        List<?> list1 = new ArrayList<Object>();
        List<?> list2 = new ArrayList<Number>();
        List<?> list3 = new ArrayList<Integer>();
        System.out.println("----------");

        //类型通配符上限:<?extends类型>
//        List<? extends Number> list4 = new ArrayList<Object>();
        List<? extends Number> list5 = new ArrayList<Number>();
        List<? extends Number> list6 = new ArrayList<Integer>();

        //类型通配符下限:<?super类型>
//        List<? super Number> list7 = new ArrayList<Integer>();
        List<? super Number> list8 = new ArrayList<Number>();
        List<? super Number> list9 =new ArrayList<Object>();
    }
}

可变参数：

package 集合进阶.Collection单列.泛型.可变参数;
/*
   可变参数：
     1.可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了
          格式:修饰符返回值类型方法名(数据类型..变量名){}
          范例:public static int sum(int….a){}

    2.可变参数注意事项
         这里的变量其实是一个数组
         如果一个方法有多个参数，包含可变参数，可变参数要放在最后

 */

import static java.lang.Integer.sum;

public class 可变参数 {
    public static void main(String[] args) {
        System.out.println(sum(10,20));
        System.out.println(sum(10,20,30));
        System.out.println(sum(10,20,30,40));

    }


//格式:修饰符返回值类型方法名(数据类型..变量名){}
//          范例:public static int sum(int….a){}
/*
    public static int sum(int...a){
//        System.out.println(a);
//        return 0;
        int sum = 0;
        for(int i:a){
            sum+=i;
        }
        return sum;
    }
*/
//如果一个方法有多个参数，包含可变参数，可变参数要放在最后
public static int sum(int b,int...a){
    return 0;
}
}

可变参数的使用：

package 集合进阶.Collection单列.泛型.可变参数;
/*
 可变参数的使用
Arrays工具类中有一个静态方法:
public static <T>List<T>asList(T…a):返回由指定数组支持的固定大小的列表
返回的集合不能做增删操作，可以做修改操作

List接口中有一个静态方法:
public static <E>List<E>of(E.…elements):返回包含任意数量元素的不可变列表
返回的集合不能做增删改操作

Set接口中有一个静态方法:
public static <E> Set<E>of(E…elements):返回一个包含任意数量元素的不可变集合
在给元素的时候，不能给重复的元素
返回的集合不能做增删操作，没有修改的方法

 */

import java.util.ArrayList;
import java.util.List;
import java.util.Arrays;
import java.util.Set;

public class 可变参数的使用 {
    public static void main(String[] args) {

        //public static <T>List<T>asList(T…a):返回由指定数组支持的固定大小的列表
        List<String> list = Arrays.asList("hello","world","java");

//        list.add("javaee");//UnsupportedOperationException
//        list.remove("world");//UnsupportedOperationException
        list.set(1,"javaee");

        System.out.println(list);

        //public static <E>List<E>of(E.…elements):返回包含任意数量元素的不可变列表
        List<String> list2=List.of("hello","world","java");

//        list2.add("javaee");//UnsupportedOperationException
//        list2.remove("world");//UnsupportedOperationException
//        list2.set(1,"javaee");//UnsupportedOperationException

        System.out.println(list2);

        //public static <E> Set<E>of(E…elements):返回一个包含任意数量元素的不可变集合
        Set<String> set = Set.of("hello","world","java");

        set.add("javaee");//UnsupportedOperationException
        set.remove("world");//UnsupportedOperationException

        System.out.println(set);

    }
}