森纵培训第十天课程总结


排序：大小

在计算机编程的研究中，其中排序算法是最成熟的；

使用不同的排序算法，效率大不相同；

最慢的排序：冒泡排序

中间效率：选择法

最快的排序：快速排序 quick sort

影响排序效率的最关键因素是：元素数据交换的次数

封装一个包括升降排序在内的排序方法：

package com.sunzone.day10;

import com.sunzone.util.Me;

public class Demo04 {

public static void main(String[] args) {

int[] arr = new int[7];

for (int i = 0; i < arr.length; i++) {

arr[i] = Me.random(100);

}

System.out.println("原始数组：");

Me.disp(arr);

System.out.println("升序：");

sort(arr, true);

Me.disp(arr);

System.out.println("降序：");

sort(arr, false);

Me.disp(arr);

}

// sortType为true,则为升序，否则为降序

public static void sort(int[] arr, boolean sortType) {

if (arr == null || arr.length == 0) {

return;

}

for (int i = 0; i < arr.length; i++) {

int k = i;

for (int j = i + 1; j < arr.length; j++) {

if (sortType) { // 升

if (arr[k] > arr[j]) {

k = j;

}

} else {// 降

if (arr[k] < arr[j]) {

k = j;

}

}

}

if (i != k) {

int temp = arr[i];

arr[i] = arr[k];

arr[k] = temp;

}

}

}

}

void sort(int []array,boolean sortType);

void sort(int []array,boolean sortType,int gap);

void sort(int []array,boolean sortType,int startIndex,int endIndex,int gap);

sort(arr,true,0,arr.length,0);

在类中定义一个方法，完成两个整数的交换；

public void swap(int a,int b){//…}

继承：本意是“扩展”，在原数据结构的基础上，新添加成员（字段成员和方法成员），使新的数据结构的功能更加强大，对于新结构中的旧有结构，进行了复用。

将原结构称为“父结构”，新结构称为“子结构”。

父类-》子类 父接口-》子接口 父注解-》子注解

在java中，子结构的功能一定强于父结构；

子结构的对象一定强于父结构的对象，父结构对象能够完成的，子对象都可完成；

父对象包含在子对象之中；

在一些面向对象的编程语言中，在继承方面分为两种情况：

多继承

单继承（java中只支持这种情况）

在访问级别的继承上，它只支持公有继承；

与继承有关的一个重要关键这：extends

软件设计中的一条铁的规律：对修改关闭，对扩展开放。

class Student{

private int id;

private String name;

private int age;

//…

}

小学生，初中生，高中学生，大学生，研究生

class BoyStudent extends Student{

private boolean is少先队员;

//…

}

class MiddleStudent extends Student{

private boolean is共青团员;

private int score;

}

在java的继承中，除了extends外，还有一个关键字super,表示当前类的直接父类；与this（表示当前类对象）类似；

学生类Student的两个直接子类：

BoyStudent

MiddleStudent

如何表示父类Student与其两个直接子类BoyStudent和MiddleStudent之间的关系？

用UML图来表示以上提到的继承关系：

类图的画法：一个类图分三部分，分别是类名，类中的字段，类中的方法

父类和子类对象的引用关系？

学生是小学生；不正确！

小学生是学生；完全正确!

（小学生是小学生，学生是学生）；

Student s1 = new Student();

上图是“学生是学生”的典型表现；

红色学生表示赋值号右边，即一个Student类型的对象；

蓝色学生表示赋值号左边的引用，即这个学生对象所在的类型是Student类型；

右边的学生对象是左边Student类型的一个实例；

子类对象与父类对象的关系属于“is-a”关系，“是一个”，

一个子类对象是一个父类对象；

既然子类对象是父类对象，子类是父类，所以可以使用父类的引用来操纵子类对象；在任何情况下，都可以将子类对象（的地址）赋给父类的引用；

利用父类引用操纵子类是一种常态。

class A {

}

class B extends A {

}

class C extends B {

}

上面的类B就是类A的子类，或称为类A的派生类；

类A称为B的父类，或称为类B的基类；

直接父类，直接子类，间接父类，间接子类；

看两个测试时要用到的类:

class A {

A() {

System.out.println("call A()");

}

}

class B extends A {

B() {

System.out.println("call B()");

}

}

测试代码：

new B(); // 类B的匿名对象

System.out.println();

new A(); // 类A的匿名对象

以上的输出说明了哪些问题？

说明在构造B对象时，会生成一个父类的A对象；

一个重要概念：在子类对象中，除本身外，还会包含一个或多个父类对象；

B b = new B();

在上面的对象b中，至少有一个b对象本身，还有一个A类对象；

具有继承关系的多个类，可以生成继承链；

在一条继承链上，从上到下，为从父类到子类，功能越来越强，但实例范围越来越小。无论一条继承链有多长，由下到上，都符合“is-a”的关系特点；