1.冒泡排序代码

简单的排序算法

依次比较两个相邻的元素，

原理如下：

• 比较相邻的元素
• 从开始第一对到结尾的最后一对。
• 针对所有的元素重复以上的步骤，除了最后一个。

以下就是一个冒泡排序

public class Test {
   public int[] sort(int[] a){
       int t=0;
       for (int i = 0; i < a.length-1; i++) {
           int f=0;
           for (int j = 0; j < a.length-i-1; j++) {
               if (a[j+1]>a[j]){
                   t=a[j];
                   a[j]=a[j+1];
                   a[j+1]=t;
                   f=1;
               }
           }
           if (f==0){
               break;
           }
       }
       return a;
   }
    public static void main(String[] args) {
        Test test = new Test();
        int[] a={2,5,1,6,4,9,8,5,3,1,2,0};
        int[] b=test.sort(a);
        for (int n:b) {
            System.out.print(n+" ");
        }
    }
}
//结果：9 8 6 5 5 4 3 2 2 1 1 0 

2.选择排序的代码

简单直观的排序算法

每一次从待排序的数据元素中选出最小 （或最大）的一个元素，存放在序列的起始位置

public class Test007 {
   public int[] sort(int[] a){
        //1.假设第一个下标值为最小值
       int t=0;
       for (int i = 0; i < a.length-1; i++) {
           int minindex=i;
           //2.第一个和第二个值比较，如果第二个值小于第一个值，则下标换成第二个值的下标
           for (int j = i+1; j < a.length; j++) {
                if (a[minindex]>a[j]){
                    minindex=j;
                }
           }
           //3.发现最小值不是最初的了
           if (i!=minindex){
               t=a[i];
               a[i]=a[minindex];
               a[minindex]=t;
           }
       }
       return a;
   }
    public static void main(String[] args) {
        Test007 test = new Test007();
        int[] a={2,5,1,6,4,9,8,5,3,1,2,0};
        int[] b=test.sort(a);
        for (int n:b) {
            System.out.print(n+" ");
        }
    }
}
//结果：0 1 1 2 2 3 4 5 5 6 8 9 

3.插入排序的代码

在一个已经排序好的数组中插入一个数，插入之后仍然保持有序

新的排序方法——插入排序法

public class Test007 {
    public int[] sort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return arr;
        }
        for (int i = 1; i < arr.length; i++) {
//内层循环依次减少并提出结果
            for (int j = i; j > 0; j--) {
//如果当前数字小于前一个,则交换,否则不变
                if (arr[j] < arr[j - 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = temp;
                } else {
                    break;
                }
            }
        }
        return arr;
    }

    public static void main(String[] args) {
        Test007 test = new Test007();
        int[] a = {2, 5, 1, 6, 4, 9, 8, 5, 3, 1, 2, 0};
        int[] b = test.sort(a);
        for (int n : b) {
            System.out.print(n + " ");
        }
    }
}
//0 1 1 2 2 3 4 5 5 6 8 9 

4. 可变参数的作用和特点

可变参数

• 形式 ...
• 只能是方法的形参
• 对应的实参可以0,1,2.....n个，也可以是一个数组
• 如果定义了可变参数的方法，不允许同时定义相同类型数组参数的方法

数组做形参和可变参数做形参联系和区别

联系：

• 实参都可以是数组
• 方法体中，可变参数本质就是当做数组来处理

区别：

• 个数不同 可变参数只能有一个数组参数可以多个
• 位置不同 可变参数只能是最后一个 数组参数位置任意
• 实参不同 可变参数实参可以0,1,2.....个，也可以是一个数组，数组的实参只能是数组

private static int sum(int... values) {
int sum = 0;
for (int i = 0; i < values.length; i++) {
sum += values[i];
}
return sum;
}

5.类和对象的关系

类是对象的抽象，而对象是类的具体实例

人类就是一个概念

小明就是一个具体的人，也就是实例

还可以有小红,小蓝等具体的人即对象,但他们都是人类的实例,即类.

7.面向过程和面向对象的区别

比喻：

 面向过程是蛋炒饭，面向对象是盖浇饭

盖浇饭的好处就是“菜”“饭”分离，从而提高了制作盖浇饭的灵活性。饭不满 意就换饭，菜不满意换菜

蛋炒饭就不 行了, 如果不满意就要丢掉重做

区别：

• 编程思路不同
• 封装性：都具有封装性，但是面向过程是封装的是功能，而面向对象封装的是数据和功能

面向对象具有继承性和多态性

8.方法重载和方法重写（覆盖）的区别

方法重载（overload）：一句话”方法名字相同，而参数列表不同“

方法重写（override）：子类继承父类的方法进行编写，但是不允许更改此方法的参数列表。子类根据需求定义。

重写与重载直接的区别

重载

•  发生在一个类中
• 对返回权限没有要求（但在开发中会保持一致）
• 对返回值没有要求（但在开发中会保持一致）
• 表示重载的单词是 overloading

重写：

• 发生在继承中（子类和父类）
• 子类不能拥有比父类更小的访问权限
• 如果子类和父类访问权限一样则返回值必须相同
• 表示重写的单词是 override

9.this和super关键字的作用  

this：

this是对象内部指代自身的引用,同时也是解决成员变量和局部变量同名问题；this可以调用成员变量，不能调用局部变量；this也可以调用成员方法，但是在普通方法中可以省略this，在构造方法中不允许省略，必须是构造方法的第 一条语句。而且在静态方法当中不允许出现this关键字。

super：

super可以调用直接父类的成员方法（注意权限修饰符的影响，比如不能访问private成员）；super可以调用直接父 类的构造方法，只限构造方法中使用，且必须是第一条语句。