1、数组排序算法
选择排序
思路分析
缺点：交换频繁，浪费时间
改进版选择排序
改进：加一个mindex记录最小值的下标
//改进版选择排序
for (int i = 0; i <arr.length - 1; i++) {
//i设置为基准位置，目标是让包括基准位置在内到后面所有数中的最小值放入基准位置即可
int mindex = i;//假定基准位置就是最小值
for (int j = i + 1; j < arr.length; j++) {//找出最小值下标
if (arr[mindex] > arr[j]){//如果j位置的值更小，记录这个更小的下标
mindex = j;
}
}
//minIndex中保存的就是最小值的下标
int tmp = arr[i];
arr[i] = arr[mindex];//最小值归位
arr[mindex] = tmp;
}
for (int a : arr) {
System.out.print(a+" ");
}快速排序
关键思想：分区+递归
利用栈换取了时间
思路分析
代码实现
public class QuickSort {
public static void quick(int[] arr,int begin,int end){
if(begin == end){//这里必须给一个终止条件，否则就会出现数组溢出
return;
}
//设置一个关键值key 以这个关键字为中点，左小右大
int key = arr[begin];
//设置keyIndex 用来存储key的下标
int keyIndex = begin;
//for循环遍历数组
for (int i = begin; i < end; i++) {
//用数组中的数分别和key去比较 比key大的值就不需要再进行移动了
//如果比key值小
if(arr[i] < key){
//就keyIndex++，目的是定位最终key关键值的位置
keyIndex++;
//要把小的那个数放到左面，所以进行交换 交换前keyIndex 所指的一定是一个比key值大的数字 但是交换后就成了比key值小的
int tmp = arr[i];
arr[i] = arr[keyIndex];
arr[keyIndex] = tmp;
}
}
//遍历完成后，key值还在下标为0的位置，这时我们需要把key值放到keyIndex所指示的位置 交换后数组基本有序
arr[begin] = arr[keyIndex];
arr[keyIndex] = key;
//用递归的方式去排序前半段和后半段
quick(arr,begin,keyIndex);
quick(arr,keyIndex+1,end);
}
public static void main(String[] args) {
int[] arr = new int[8];
for (int i = 0; i < arr.length; i++) {
arr[i] = (int)(Math.random()*30);
}
for (int t : arr) {
System.out.print(t+" ");
}
System.out.println();
quick(arr,0,arr.length);
}
}JDK内部就是快排:双分区快排
调用函数：arrary.sort();
2、多维数组
二维数组：数组的数组，它的元素是一维子数组
初始化
1）动态初始化
格式1：int[][] arr = new int[3][2];
???????????二维数组中有3个一维数组 ?每一个一维数组中有2个元素
格式2：int[][] arr = new int[3][];
???????????二维数组中有3个一维数组。 ?每个一维数组都是默认初始化值null?
2）静态初始化：
格式1：int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};
格式2：int[][] arr = new int{{3,8,2},{2,7},{9,0,1,6}};
格式2不方便，声明初始化必须在同一行！
3）特殊写法情况：int[] x,y[]; x是一维数组，y是二维数组。
Java中多维数组不必都是规则矩阵形式
数组创建在内存中的形式
取最大值和最小值
public static void main1(String[] args) {
int[][] arrarr = new int[6][];//表示创建了只有6个子数组的数组，并没有真的子数组产生
for (int i = 0; i < arrarr.length ; i++) {
//真的创建子数组
int n = (int)(Math.random()*4+6);
arrarr[i] = new int[n];
//给子数组赋值
for (int j = 0; j < arrarr[i].length; j++) {
arrarr[i][j] = (int)(Math.random()*200);
}
}
for (int i = 0; i < arrarr.length; i++) {
for (int j = 0; j < arrarr[i].length; j++) {
System.out.print(arrarr[i][j]+" ");
}
System.out.println();
}
//找出最大值和最小值
int max = arrarr[0][0];
int min = arrarr[0][0];
for (int i = 0; i < arrarr.length; i++) {
for (int j = 0; j < arrarr[i].length; j++) {
if (arrarr[i][j] > max){
max = arrarr[i][j];
}
if (arrarr[i][j] < min){
min = arrarr[i][j];
}
}
}
System.out.println("max="+max);
System.out.println("min="+min);
}3、可变参数方法
1）参数可变，类型不可变
2）完全兼容了int数组?
????????int... values 本质就是数组，编译帮我们对我们传入的散数进行了转化
3）main方法中的args命令行参数本质也是可变参数
4）可变参数是JDK版本的新技术
????????String[]是通用的，但是使用String...要在JDK1.5以上版本使用
5）一个方法中只允许有一个可变参数，并且必须放在最后
//举例：找最大值
public class MaxArgs {
public static int max(int... args) {
//找最大值
int max = args[0];
for (int i = 0; i < args.length; i++) {
if (args[i] > max){
max = args[i];
}
}
return max;
}
public static void main(String[] args) {
System.out.println(max(2,4,7,9,5,45,6,4));
System.out.println(max(28,400,70,9,53,45,66,41));
}
}4、继承
什么是继承？
继承表达所有权? （所有权：没有直接使用权，有间接使用权）
继承：就是从现有类创建子类，现有类称为父类，基类(子类以父类为基础进行扩充)，超类（在子类中通过super限定来特指父类成员）
什么是子类？
1）子类是父类的扩充，子类>=父类
2）子类要继承父类所有成员，构造器除外
3）子类可以添加新的成员
????????????????特有成员；子类中扩充的成员
语法格式：
//PC继承Computer中的所有属性和方法
public class PC extends Computer{}
内存角度分析 子类>=父类
内存中创建的子类对象，会包含父类中的所有属性，只有一个纯子类对象，可以看成子类对象中暗含了一个父类对象，但实际并没有创建父类对象，只是可以把子类对象当成父类对象来使用。
什么情况要用继承呢？
多个类有相同属性和行为时，为了提升代码重用，使得子类的写法更简单
继承的作用：
1）提高复用性
2）类之间产生关系，多态的前提
3）动态性
多层继承和多重继承的区别？
1）多层继承，又称为单继承。
????????一个子类只能有一个父类
????????????????直接父类：离得近
????????????????间接父类：离得远
2）多重继承：一个子类拥有多个直接父类（不允许），因为多重继承时，如果多个直接父类中都有同名方法，子类会混乱
java中只支持单继承，多重继承时不允许的！
私有成员、方法能否被继承？
能继承，但是不能直接使用。
因为被private修饰成员只能在本类中使用，子类不是本类，所以在子类中不能直接使用，可以在父类中添加公共的get/set方法，在子类中可以通过父类继承的get/set方法间接使用。起保护作用！！
举例：内脏、CPU的使用
构造器不能继承，但是可以调用吗？
可以的，所有子类构造器都会默认调用父类中的无参构造器
super();如果不写，会有隐式的父类无参构造器的调用
?注意点：
1）子类构造器中的第一行必须是this(...)或super(...)
this(...)作用是间接调用父类构造
super(...)作用是直接调用父类构造器
2）结论：子类构造器必须先调用父类构造器
如果this(...)和super(...)同时出现会两次初始化
5、方法的覆盖（override）
最重要的的概念 没有之一
定义：子类对从继承来的父类方法进行改造
????????????以继承为前提
覆盖原因：父类方法不再满足需要
覆盖条件：
1）子类和父类中 方法签名（方法名、参数列表和返回值类型）必须完全相同，参数列表一致体现为类型一致、参数一致、顺序一致
2）覆盖方法不能比被重写方法有更严格的访问权限，子类控制修饰符>=父类
3）都必须是static
注意：如果方法重写，执行的时候执行的是子类中的方法
public String getDetails(){
? ? ? return "cpu:"+getCpu()+",内存:"+getMemory()+",磁盘："+getDisk()+",键盘："+keyboard;
? ?}
为什么在父类中不写完整？
因为父类是被动的，它永远不知道那些子类继承了它。
属性不能覆盖，永远都是共存！
如果子类和父类中有相同属性
this.age表示当前类的age
super.age才是从父类中继承来的
方法覆盖必须加注解！！！
6、注解
特殊的注释，不参与程序的运行，但可以被编译器和JVM识别
本质是修饰符，放在方法前面
@override注解：
请求编译器做方法覆盖的检查，如果这个方法的覆盖出问题，请编译出错
格式如下：
@Override
public String getDetails(){
return super.getDetails()+",键盘："+keyboard;
}7、super关键字
super特指当前子类的父类
若子类中有两个say()方法， super.say()表示父类中的被覆盖的方法
对于测试类而言，那么子类重写的方法是唯一方法，父类中被重写的方法永不可见
好处：父类发生变化，不用再修改子类，实现连环调用
可与上面的例子作比较
public String getDetails(){
return super.getDetails()+",键盘："+keyboard;
}super作用：可访问父类中的属性、方法、构造器
注意点：super的追溯不仅限于直接父类
this和super的区别：
1）this表示当前对象整体
2）super表示只是一个内存标识，用于限定从父类继承的成员
3）super绝不是对象！
8、访问权限修饰符?
总结?
今天主要学习的内容：
1）数组排序算法；
2）二维数组；
3）可变参数方法；
4）继承：
5）this关键字；
6）方法的覆盖（重点）；