Day13 泛型

泛型

泛型定义

在一个类型（类，接口，方法）之后，定义一个类型参数。

原生类型:类型后面没有指定具体的类型参数。

好处

使用泛型的好处在于，它在编译的时候进行类型安全检查，并且在运行时所有的转换都是强制的，隐式的，大大提高了代码的重用率。

语法

class Point<T>{}

通配符（？）

无界通配符（？）可以接受任何的类类型。

public void show(Point<?> p){}

（? extends 上限类）只能接受上限类和上限类子类，如只能接受数字类型，Byte,Short,Integer,Long,Float,Double

public void show(Point<? extends Number> p){}

（? super 下限类）下限，下限类和下限类的父类，Number和Number的父类

public void show(Point<? super Number> p){}

注意

Point<Object>不是Point<String>、Point<Integer>等的父类

public void add(Point<String> ps,Point<Object> po){//错误
  po = ps
}

public void add(Point<String> ps,Point<? extends Object> po){//正确

类型参数与通配符的区别

类型参数与 通配符的区别：
<T> 和 <?>
1.类型参数可以指定上限，也只能指定上限；
统配符可以指定上限，也可以指定下限；
2.类型参数 可以指定多个 上限；
通配符 只能指定一个上限；
3.类型参数 可以作为一种类型存在；
统配符不能表示 类型

泛型构造

//定义了一个泛型类 
class PointN<T>{//类型参数 形式类型参数 
    private T x;
    private T y;
    //定义了一个泛型构造器
    <E>PointN(E e){
        System.out.println(e);
    }
    public T getX() {
        return x;
    }
    public void setX(T x) {
        this.x = x;
    }
    public T getY() {
        return y;
    }
    public void setY(T y) {
        this.y = y;
    }
}
public class TestPoint2 {
    public static void main(String[] args) {
        //                        指定具体的类型参数
        PointN<String> p1 = new <Integer>PointN<String>(22);
        //类型推断：   根据参数  的类型 自动推断出 构造的类型参数 是Integer类型
        PointN<String> p2 = new PointN<String>(22);
    }

}

泛型方法

定义泛型方法时，必须在返回值前边加一个<T>，来声明这是一个泛型方法，持有一个泛型T，然后才可以用泛型T作为方法的返回值。

class Demo{
    //泛型方法
    public <E> void f(E e) {
        System.out.println(e);
    }
    public <E> E ff(E e) {
        return e;
    }
    public <E extends Number> void fff(E e) {
        System.out.println(e);
        //自动推断的方式
        f("hello");
        //指定的方式，显示，this
        this.<String>f("hello");
    }
}
public class TestPoint3 {
    public static void main(String[] args) {
        // 泛型方法应用
        Demo d = new Demo();
        //具体指定 泛型方法参数的类型
        d.<String>f("hello");
        //可以使用类型推断： 根据参数的类型 自动推断
        d.f(11);
        d.fff(33);

    }

}

泛型擦除

1.参数化类型：Point<String>，擦除后为原生类型Point

2.类型参数:用上界来替换

• Point<T>:无界类型参数，用Object来替换

• 类型参数有上限，用上限来替换。

• 有多个上限，用第一个上限替换。

重载

class PointNew<T>{}
interface Info1{}
interface Info2{}

class Demo1{
    //为了实现重载
    //生成的字节码文件中，泛型的信息被擦除了
    public void f(String p) {}
    public void f(PointNew<Integer> p) {}//擦除后:PointNew p
    public <E> void f(E e) {}//擦除后:Object e
    public <E extends Info1> void f(E e) {}//擦除后:Info1 e
    public <E extends Info2 & Info1> void f(E e) {}//擦除后:Info2 e
    
}

重写

class Parent{
    //重写：参数父类中参数擦除后与子类中参数相同
    public void f(PointNew<String> p) {}
}
class Child1 extends Parent{
    public void f(PointNew<String> p) {}
}

泛型接口

//泛型接口
interface Info<T>{
    void f(T t);
}
//在实现接口时  指定具体的类型参数
class InfoImpl1 implements Info<String>{
    @Override
    public void f(String t) {
        System.out.println(t);
    }
}
//在实现 接口时  不能确定类型
class InfoImpl2<T> implements Info<T>{
    @Override
    public void f(T t) {
        System.out.println(t);
    }
}
public class TestPoint5 {

    public static void main(String[] args) {
        InfoImpl1 i1 = new InfoImpl1();
        i1.f("hello");
        InfoImpl2<String> i2 = new InfoImpl2<>();
        i2.f("tom");
    }

}

比较器

Comparable

Comparator

对象进行自然方式排序，必须是实现了Comparable接口的。

Arrays.sort(数组);//默认 自然排序

Comparable<T> 泛型接口 比较器实现自然排序

Comparator<T> 泛型接口 外部比较器

package day13;

import java.util.Arrays;
import java.util.Comparator;
class Student implements Comparable<Student>{
    private int age;
    private int no;
    public Student(int no,int age) {
        this.age = age;
        this.no= no;
    }
    public int getAge() {
        return age;
    }
    public int getNo() {
        return no;
    }
    @Override
    public String toString() {
        return "编号："+no+",年龄："+age;
    }
/*    @Override
    public int compareTo(Object o) {
        //this 与  o比较
        //this.age   o.age
        Student stu = (Student)o;
        //this.age  stu.age
        
        return 0;
    }*/
    @Override
    public int compareTo(Student o) {
        // this.age   o.age
        //升序的方式 
        /*if(this.age > o.age ) {
            return 1;//正数
        }else if(this.age < o.age) {
            return -1;//负数
        }else {
            return 0;//相等
        }*/
        return this.age - o.age;
    }    
}
//按照 编号升序排序
class NoComparator implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        // o1  和 o2比较
/*        if(o1.getNo() > o2.getNo()) {
            return 1;
        }else if(o1.getNo() < o2.getNo()) {
            return -1;
        }else {
            return 0;
        }*/
        return o1.getNo()- o2.getNo();
    }    
}
public class TestSort {
    public static void main(String[] args) {
        Student zhang = new Student(2,44);
        Student wang = new Student(1,11);
        Student zhao = new Student(3,33);
        Student [] stus = {zhang,wang,zhao};
        //Arrays.sort()按照自然方式排序的
//        Arrays.sort(stus);
        //1.自定义类 实现接口
//        Arrays.sort(stus, new NoComparator());
        //2.匿名内部类实现接口
        Arrays.sort(stus,new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getNo() - o2.getNo();
            }    
        });
        //3 Lambda
        Arrays.sort(stus,(s1,s2)->s1.getNo()-s2.getNo());
        
        Arrays.stream(stus).forEach(System.out::println);
        //--------------------------------------------
        int [] arr = {45,1,77,34,3};
        Arrays.sort(arr);
        Arrays.stream(arr).forEach(System.out::println);
        //--------------------------------------------
        String [] arrs = {"cc","dd","aa","ee"};
        Arrays.sort(arrs);
        Arrays.stream(arrs).forEach(System.out::println);
        //------------------------------------------------
    }

}

枚举类型

语法

enum 枚举类型{
  
}

package day13;

import java.util.Scanner;

//RGB
/*class Color{
    public static final int RED = 1;
    public static final int GREEN = 2;
    public static final int BLUE = 3;
}*/
interface ColorInfo{
    void fv();//抽象方法
}
enum Color{
    RED(1,"红色") {
        @Override
        void f() {
            // TODO Auto-generated method stub
            
        }
    },GREEN(2,"绿色") {
        @Override
        void f() {
            // TODO Auto-generated method stub
            
        }
    },BLUE(3,"蓝色") {
        @Override
        void f() {
            // TODO Auto-generated method stub
            
        }
    };
    
    private Color(int no, String name) {
        this.no = no;
        this.name = name;
    }
    private int no;
    private String name;
    //抽象方法
    abstract void f();
}
/*enum Color implements ColorInfo{
    //定义枚举成员,对象，实例
    RED(1,"红色"){
        public void fv() {
            System.out.println("红色的");
        }
    },GREEN(2,"绿色"){
        public void fv() {
            System.out.println("绿色的");
        }
    },BLUE(3,"蓝色"){
        public void fv() {
            System.out.println("蓝色的");
        }
    };    //public static final
    private int no;//编号
    private String name;//名字
    
    private Color(int no, String name) {
        this.no = no;
        this.name = name;
    }
    public int getNo() {
        return no;
    }
    public void setNo(int no) {
        this.no = no;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void f() {}
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return this.no+","+this.name();
    }
    @Override
    public void fv() {
        // TODO Auto-generated method stub
        
    }
    
}*/
public class TestEnum {
    public static void main(String[] args) {
//        System.out.println(Color.RED.getNo()+","+Color.RED.getName());
//        System.out.println(Color.BLUE.getNo()+","+Color.BLUE.getName());
/*        Color.RED.setName("红色");
        System.out.println(Color.RED.getName());
        Color.RED.f();*/
    /*    Color.RED.no = 11;
        Color.GREEN.name = "绿色";
        System.out.println(Color.RED.no);
        System.out.println(Color.GREEN.name);*/
        
/*        Scanner input = new Scanner(System.in);
        System.out.println("输入一个颜色：");
        String s = input.next();
        Color co = Color.valueOf(s); 
        switch(co) {
        case RED:
            System.out.println("进行红色的操作");
            break;
        case GREEN:
            System.out.println("进行绿色的操作");
            break;
        case BLUE:
            System.out.println("进行蓝色的操作");
            break;
        }*/
        
        //可以遍历枚举值
/*        for(Color c: Color.values()) {
            System.out.println(c.name());
            System.out.println(c.ordinal());
        }*/
        
/*        // 类型不安全
        int red = Color.RED;
        int a = red +5;
        System.out.println(a);
        //意思不明确
        System.out.println(Color.RED);*/
//        System.out.println(Color.RED);
        
        
        
        

    }

}

注意

1.所有的枚举类型的对象都在枚举类第一行显示定义出来。

2.对象默认是public static final的

3.枚举类的构造都是private的

4.枚举类继承自java.lang.Enum类

5.对于一个非抽象枚举类来说，都是final

一个枚举类的所有对象都实现了接口中的抽象方法，此枚举类就是抽象类，abstract的了

枚举类中定义抽象abstract方法，所有对象都需要实现此抽象方法，那么此枚举类是abstract的了

强制垃圾回收

class Person{

    @Override
    protected void finalize() throws Throwable {
        System.out.println("this---->"+this);
    }
    
}
public class TestGC {

    public static void main(String[] args) {
        // 强制垃圾回收
        Person per = new Person();
        System.out.println(per);
        per = null;//断开引用
        System.gc();//强制通知垃圾回收器
//        Runtime.getRuntime().gc();//

    }

}