Java继承特性和super关键字和快速排序

继承：关键字为extends，子类对象继承父类对象的所有内容，但不都可见；静态资源属于类，不属于被继承范畴。

继承中的构造方法：

子类构造方法默认来自父类无参；

如果父类有有参但没有无参，则子类无法直接写出无参构造；

 需要用super()指定父类的构造方法；

super的作用：可以修饰属性，方法，构造方法；

super调用属性、方法：

子类的方法中，可以通过super.属性  super.方法 的方式，

显示的去调用父类提供的属性,方法。

在通常情况下，super.可以省略不写；

但是当子类和父类的属性或方法重名时，你要想使用父类的属性或方法,必须加上修饰符super.， 只能通过super.属性或super.方法来调用 ！

super调用构造方法：

其实我们平时写的空构造器的第一 行都有: super() -->作用:调用父类的空构造器，只是我们一般都省略不写;

如果构造器中已经显示的调用super父类构造器，那么它的第一行就没有默认分配的super0);

在构造器中，super调用父类构造器和this调用子类构造器只能存在一个， 两者不能共存

因为super修饰构造器要放在第一行， this修饰构造器也要放在第一行:

以后写代码构造器的生成可以直接使用IDEA提供的快捷键:alt +insert

下面大家看一下快速排序；

package cn.kgc;

import java.util.Arrays;
import java.util.Scanner;

/**
 * @Author：Adminstrator
 * @Date：2021-11-02
 * @Description：演示快速排序
 * 方法的递归
 */
public class QuickSort {
    /**
     * 快速排序，使用递归
     * @param a 待排序数组
     * @param s 数组起始位置
     * @param e 数组结束位置
     */
    public static void sort(int[] a,int s,int e){
        if (s >= e) {//递归的退出条件，当数组中只有一个元素或没有元素
            return;
        }
        int i=s;//因为在循环中， 下标会不停的动，因此需要一个临时变量来变化,
        int j=e;//而不是直接动数组的开始和结束
        int num=a[s];//每次以数组的第一个元素来作为基准值
        while(i<j){// 只要没有找到基准值的位置，就需要继续判断
            while(num>=a[j]&&j>i)j--;//只要满足顺序的，就继续
            a[i]=a[j];//不满足顺序的，就向左放到对应位置
            while(num<=a[i]&&i<j)i++ ;//只要满足顺序的，就继续
            a[j]=a[i];//不满足顺序的，就向右放到对应位置
        }
        a[i]=num;//i和j相等，就是基准值的位置
        sort(a,s,i-1);//基准值左边的元素作为新数组，继续上面的过程
        sort(a,i+1,e);//基准值右边的元素作为新数组，继续上面的过程
    }

    public static int[] randomArray(int length){
        int[] a=new int[length];
        for (int i = 0; i < a.length; i++) {
            a[i]=(int)(Math.random()*length*10);
        }
        return a;
    }
    public static void bubbleSort(int[] a){  //冒泡排序法
        for (int i = 0; i < a.length-1; i++) {
            boolean flag=true;
            for (int j = 0; j < a.length-1-i; j++) {
                if(a[j]>a[j+1]){
                    int tmp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=tmp;
                    flag=false;
                }
            }
            if(flag){
                break;
            }
        }
    }
    public static void main(String[] args) {
        int[] a=randomArray(10000);
//        System.out.println(Arrays.toString(a));
//        sort(a,0,a.length-1);
//        System.out.println(Arrays.toString(a));
        long s=System.currentTimeMillis();
//        bubbleSort(a);      //冒泡排序
        sort(a,0,a.length-1);//快速排序
//        Arrays.sort(a);//数组自带的排序方法，其实里面包含了快排
        long e=System.currentTimeMillis();
        System.out.println(e-s);  //显示排序所用时间ms
     //很明显快排速度远远超过冒泡排序，递归是在栈里进行的，循环是在堆里进行的，栈的速度远快于堆
    }
}