Java基础（五）

框架是个好东西，可早晚有一天会过时，这世界上就没有亘古不变的东西，来学下Java基础吧

泛型

指定泛型继承了类A并且实现了接口B，具体代码为

<T extends A & B>

关键点：

​ 在泛型中只能出现extends关键字，中间用&符连接

实际应用：

自己设计一个泛型的获取数组最小值的函数. 并且这个方法只能接受 Number 的子类并且实现了 Comparable 接口。

先看下Comparable的源码

public interface Comparable<T> {
    int compareTo(T var1);
}

这里的泛型T可能是compareTo的传入类型，也有可能是compareTo传入类型的父类型【多态】

在Java8源码中一般显式的将多态表现出来

所以代码如下

    private static <T extends Number & Comparable<? super T>> T min(T[] values) {
        if (values == null || values.length == 0) {
            return null;
        }
        T min = values[0];
        for (int i = 1; i < values.length; i++) {
            if (min.compareTo(values[i]) > 0) {
                min = values[i];
            }
        }
        return min;
    }

	public static void main(String[] args) {
        Integer[] a = {1,5,9};
        Integer min = min(a);
        System.out.println(min);
    }

<<<1

关键点就是

​ <T extends Number & Comparable<? super T>>

​ T继承了Number并且实现了Comparable接口，而Comparable接口需要一个泛型，传入的是比较的对象，显式声明为多态

用数组实现栈

以 Integer 为例，实现栈的基本方法

public class Stack {
    //    栈中的数据
    private Integer[] data;
    //    栈的总长度
    private Integer length;
    //    栈的当前长度
    private Integer current;
    //    栈每次扩容多少
    private static final Integer GROW_FACTOR = 2;


    //    构造函数，默认长度是10
    public Stack() {
        data = new Integer[10];
        length = 10;
        current = 0;
    }

    public Stack(Integer length) {
        data = new Integer[length];
        this.length = length;
        current = 0;
    }

    //    入栈
    public void push(Integer value) {
        while (current == length) {
//            扩容
            expansion();
        }
        data[current++] = value;
    }

    //    扩容
    private void expansion() {
        length *= GROW_FACTOR;
        data = Arrays.copyOf(data, length);
    }

    //    返回栈顶元素并出栈
    public Integer pop() {
        if (current == 0) {
            throw new IllegalCallerException("非法调用，栈中无元素");
        } else {
            current--;
            return data[current];
        }
    }

    //    返回栈顶元素，不出栈
    public Integer peek() {
        if (current == 0) {
            throw new IllegalCallerException("非法调用，栈中无元素");
        } else {
            return data[current - 1];
        }
    }

    //    判空
    public Boolean isEmpty() {
        return current == 0;
    }

    //    返回栈中个数
    public Integer size() {
        return current;
    }

    @Override
    public String toString() {
        String info = "";
        for (int i = 0; i < current; i++) {
            info += data[i];
            info += " ";
        }
        return info;
    }

    //  测试
    public static void main(String[] args) {
        Stack stack = new Stack(2);
        stack.push(1);
        stack.push(2);
        stack.push(3);
        System.out.println(stack);
    }
}

⚛️ ：有兴趣的同学可以将栈中的数据类型换成泛型（和第一点结合起来），实现全栈功能。