泛型

泛型

package Generics;
//泛型类   就是属性的数据类型不确定, 在创建对象的时候再确定.
public class a1<T> {    //属性类型是<T>泛型   
    private T name;
  public a1() {
    }

    public a1(T name) {
        this.name = name;
    }

    public T getName() {
        return name;
    }

    public void setName(T name) {
        this.name = name;
    }
}
//------------------------------
package Generics;
//必须是引用类型,比如:String, class类型, 基本类型要用包装类如Integer, Boolean...
public class a1Demo {
    public static void main(String[] args) {
        a1<String> a = new a1<String>();
        a.setName("abc");
        a1<Integer> i = new a1<Integer>();
        i.setName(100);
        a1<Boolean> b = new a1<Boolean>();
        b.setName(true);
        System.out.println(a.getName()+","+i.getName()+","+b.getName()+",");
    }
}

package Generics;
/*泛型方法 : 泛型类只能在创建对象时确定属性类型,
 泛型方法可以在调用方法时确定属性类型. */
public class Generic_1 {
    public <T> void show(T t){
        System.out.println(t);
    }
}
//-----------------------------------
package Generics;
//测试类   调用方法时再确定类型.
public class GenericDemo {
    public static void main(String[] args) {
        Generic_1 gen = new Generic_1();
        gen.show("abc");            //String
        gen.show(123);             //Integer
        gen.show(true);             //Boolean
        gen.show(12.34);          //Float
        a1<String> a1 = new a1<>("Peppa");
        gen.show(a1.getName());   //a1
    }
}

package Generics;
//接口
public interface GenericsInterface_1<E> {
    void show(E e);//show方法

}
//----------------------------
package Generics;
//接口的实现类        一般接口名+Impl为这个接口的实现类
public class GeInImp <E> implements GenericsInterface_1<E>{
    @Override
    public void show(E e) {
        System.out.println(e);
    }
}
//-----------------------------
package Generics;
//测试类
public class GenericsInterfaceDemo {
    public static void main(String[] args) {
//    GeInImp gii =new GeInImp();
        GenericsInterface_1<String> g1 =new GeInImp<>();
        GenericsInterface_1<Integer> g2 =new GeInImp<>();
        g1.show("abc");
        g2.show(100);

    }
}

package Generics;
import java.util.ArrayList;
import java.util.List;
public class Generics$_$ {
    public static void main(String[] args) {
        //类型通配符<?>
        List <?> list1 = new ArrayList<Object>();
        List <?> list2 = new ArrayList<Number>();
        List <?> list3 = new ArrayList<Integer>();
        //类型通配符上限<? extends>允许所有子类
//     List <? extends Number> list4 = new ArrayList<Object>(); Object是Number的父类所以报错!
        List <? extends Number> list5 = new ArrayList<Number>();
        List <? extends Number> list6 = new ArrayList<Integer>();
        //类型通配符下限<? super>允许所有父类
        List <? super Number> list7 = new ArrayList<Object>();
        List <? super Number> list8 = new ArrayList<Number>();
//     List <? super Number> list9 = new ArrayList<Integer>();Integer是Number的子类所以报错!
    }
}

package Generics;
public class argsDemo {
    public static void main(String[] args) {
        System.out.println(sum(1,2,3,4,5,6,7,8,9));//从1加到9
    }
    //参数不停变化就要写很多方法,可变参数方法可以解决这个问题
    public static int sum1(int a , int b, int c){
        return a+b+c;   
    }
    public static int sum(int ... a){
        //a是个数组,求所以元素的和,这里就用enhance_for
        int sum = 0;
        for (int i:a){
            sum+=i;
        }
        return sum;
    }
}

package Generics;

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

public class argsMethod {
    public static void main(String[] args) {
        /*
        Arrays工具类中有一个静态方法：
        public static＜T＞List＜T＞asList（T...a）：返回由指定数组支持的固定大小的列表*/
        List<String> list1 = Arrays.asList("hello", "world", "java");
//        list1.add("abc");//UnsupportedOperationException不支持操作异常
//        list1.remove("hello");//UnsupportedOperationException
        list1.set(2,"javaee");//可以修改,不能增删. 也就是不能修改集合的大小.
        System.out.println(list1);
        /*
        List接口中有一个静态方法：
        public static ＜E＞List＜E＞of（E...elements）：返回包含任意数量元素的不可变列表
        返回的集合不能做增删改操作
        接口的static方法也是<用接口名点方法>调用*/
        List<String> list2 = List.of("hello","world","java","world");//List集合可以有重复元素
//        list2.add("abc");
//        list2.remove("hello"); //UnsupportedOperationException
//        list2.set(0,"123");  //不能做增删改操作
        System.out.println(list2);
        /*
        Set接口中有一个静态方法：
        public static ＜E＞Set＜E＞ of（E...elements）：返回一个包含任意数量元素的不可变集合
        在给元素的时候，不能给重复的元素
        返回的集合不能做增删操作，Set集合没有索引所以没有修改的方法(set方法)
         Set集合不能有重复元素, 否则IllegalArgumentException非法或不正确的参数*/
        Set<String> set = Set.of("hello","world","java","hello");
        set.add("abc");
        set.remove("hello");
        System.out.println(set);
    }
}