知识点(二)

快速排序

package com;

import java.util.Arrays;
class D{
	//先从右往左找一个小于基准的数，再从左往右找一个大于基准的数
	public static void quickSort(int[] arr,int low,int high) {
		int i,j,temp,t;
		if(low>high) {
			return;
		}
		i=low;
		j=high;
		//temp是基准
		temp=arr[i];
		while(i<j) {
			//先看右边，依次往左递减
			while(arr[j]>=temp&&i<j) {
				j--;
			}
			//再看左边，依次往右递增
			while(arr[i]<=temp&&i<j) {
				i++;
			}
			//如果满足条件则交换
			if(i<j) {
				t=arr[i];
				arr[i]=arr[j];
				arr[j]=t;
			}
		}
		//最后将基准为与i和j相等位置的数字交换
		arr[low]=arr[i];
		arr[i]=temp;
		//递归调用左半数组
		quickSort(arr,low,j-1);
		//递归调用右半数组
		quickSort(arr,j+1,high);
	}
	
	public static void main(String[] args) {
		int[] arr= {10,7,7,23,1,8,3,5,5,9,55,16};
		quickSort(arr,0,arr.length-1);
		System.out.println(Arrays.toString(arr));
	}
}

输出：

插入排序

package com;

import java.util.Arrays;

class E{
	public static void sort(int[] arr) {
		if(arr==null||arr.length==0) {
			return;
		}
		int i,j,t;
		for(i=1;i<arr.length;i++) {
			t=arr[i];//把a[i]之前的数跟a[i]比
			for(j=i-1;j>=0&&t<arr[j];j--) {//前面的要是比a[i]大就往后移动一位(待会数据移动会变，先用t存一下)
					arr[j+1]=arr[j];
			}
			arr[j+1]=t;//找到了准确的位置，插入a[i]
			System.out.println(Arrays.toString(arr));
		}
	}
	public static void main(String args[]) {
		int[] arr= {4,3,2,1,0};
		sort(arr);
	}
}

输出：

概念
1、模块内，高内聚，低耦合。
2、try-catch-finally，
不发生异常不会执行catch里的内容；
try-catch里有return的话，会先看看finally里是不是有return，有的话返回finally的返回值，否则就是try-catch里的。
3、final声明的方法是不能被覆盖的，
假如父类定义了一个这样的方法private final void run()，与此同时，继承父类的子类同样定义了这么一个方法private final void run()。这里并没有错误，因为方法是private的，也就是说子类没有继承父类的方法，因此子类的run方法跟父类的run方法无关，并不是覆盖。子类定义的调用会执行子类的run()方法。
4、初始化的过程：
(1) 首先，初始化父类中的静态成员变量和静态代码块，按顺序。
(2) 然后，初始化子类的静态成员变量和静态代码块，按顺序。
(3) 其次，初始化父类的普通成员变量和代码块，再执行父类的构造方法。
(4) 最后，初始化子类的普通成员变量和代码块，再执行子类的构造方法。
5、Math.toRadians角度转弧度。