java泛型笔记（根据青空的霞光）

问题：

• 有些数据的他的类型是不固定的，比如成绩：可以是数字，也可以是字符串（比如优良），那么要存储这样的数据要用什么数据类型

• 可以使用object类型来解决这个问题，但是我们无法判断对方传进来的到底是什么类型，如果既不是数字也不是字符串，我们也无法得知。如果想要将object类再转换回数字类型，如果此时传递的是字符，就会报错

泛型类

• 泛型是一个待定的类型，可以把它当成一个模版，待定的类型就是要填入的东西

public class score <T>{  
    String name;  
    int age;  
    T value;   //T 会根据我们传的类型自动变成  
    public score(String name ,int age ,T value){  
        this.name=name;  
        this.age=age;  
        this.value=value;  
    }  
  
    public T getValue() {  
        return value;  
    }  
}

public class Score <T,U>{  
    String name;  
   U age;  
    T value;   //T 会根据我们传的类型自动变成  
    public Score(String name ,U age ,T value){  
        this.name=name;  
        this.age=age;  
        this.value=value;  
    }  
  
    public T getValue() {  
        return value;  
    }  
}

public class Main {  
    public static void main(String[] args) {  
      Score score=new Score<String,Integer>("cheems",18,"13456");  //只能是包装类
        System.out.println(score.getValue());  
    }  
}

• 没有指定类型时，就默认object，指定类型就转换。

• 在编译时，会指定类型

• 由于泛型只能在创建对象时明确类型，所以静态方法无法使用泛型

• 不能使用泛型类去创建数组和构造方法，因为不知道类型

• 一定是引用类型，不支持基本类，基本类的数组是可以的

• 泛型类不同的指定类型的引用不能相互赋值

• 如果让泛型指定任意类型就可以填入？本质上是object类，这个时候引用就是可以赋值的

泛型与多态

public interface Test<T> {  
    T test();  
}
 
public class Main {  
    public static void main(String[] args) {  
        System.out.println(new A().test());  
  
    }  
    static class A implements Test<String> {  
        @Override  
        public  String test() {  
            return "啊 确实";  
        }  
    }  
}

• 也可以在泛型接口之后再次使用泛型

• 同时也可以string

• 继承也是一样的

泛型方法

不需要依靠泛型对象来

public class Main  {  
    public static void main(String[] args) {  
  
    String a=test("啊，确实");  
        System.out.println(a);  
    }  
    public static   <T> T test(T t){  
            return t;  
    }  
}

不是静态也可以
test里传的是什么类型，泛型就为什么类型

public class Main  {  
    public static void main(String[] args) {  
        Main main = new Main();  
        int a=main.test(13245);  
        System.out.println(a);  
  
    }  
    public <T>T test(T t){  
        return t;  
    }  
}

import java.util.Arrays;  
import java.util.Comparator;  
  
public class Main  {  
    public static void main(String[] args) {  
        //要实现数组的逆序  
        Integer []a={1,2,5,4,3,1,54,1,35,46,13346,1};  
     1   Arrays.sort(a, new Comparator<Integer>() {  //sort的第二个参数返回正数正序，返回负数逆序。  
            @Override  
            public int compare(Integer o1, Integer o2) {  
                return o2-o1;  
            }  
        });  
        System.out.println(Arrays.toString(a));  
        Arrays.sort(a,0,6);   //这是从0到6的数字排序  
  
        System.out.println(Arrays.toString(a));  
  
    }  
  
}