20202330 金晨《数据结构与面向对象程序设计》课程总结

目录

• 一、课程内容总结
  • 第一章 绪论
  • 第二章 数据与表达式
  • 第三章 类与对象
  • 第四章 编写类
  • 第五章 条件判断和循环
  • 第六章 面向对象设计
  • 第七章 数组
  • 第八章 异常
  • 第九章 递归
  • 第十章 算法分析
  • 第十一章 查找与排序
  • 数据结构其他内容以实验呈现。
• 二、作业总结(点击下列小标题可进入查看)
  • 1. 封装继承多态重写重载文件字符字节读写-测试
  • 2. 实现自己的ArrayList
  • 3. ArrayStack测试
  • 4. 栈应用—进制转换
  • 5. 最小生成树测试
  • 6. 快速排序测试
  • 7. 最后一次测试
• 三、实验报告连接汇总（点击进入网址）
  • 实验一：linux基础与java开发环境
  • 实验二：Java基础（数据/表达式、判定/循环语句）
  • 实验三：数据结构与面对对象程序设计
  • 实验四：JavaSocket 编程
  • 实验五&六：线性结构与链表
  • 实验七：查找与排序
  • 实验八：树
  • 实验九：图
• 四、学习java时的注意点。
• 五、代码托管链接

一、课程内容总结

第一章 绪论

1. 计算及体系结构
   
2. 标识符（identifier）、关键字（keyword）和保留字（reserved words）

• 标识符：Java中类名、变量名以及方法名凡是自己可以起名字的地方都被称为标识符。
  

• 关键词：被 Java 语言赋予了特殊含义，用做专门用途的字符串（单词），均为小写。
  

• 保留字：现有Java版本尚未使用但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字goto、const。
  

3. 空白符

• 空白符由空格、制表符和换行符组成。计算机执行程序中会忽略空白符。
  

4. 编辑器、编译器和解释器

• 编译器将程序输入计算机并保存为文件。
  

• 译码器将一种编程语言代码翻译成另一种语言的等效代码的程序。
  

• 解释器将编译和执行交织在一起，即编译一部分代码后执行该部分的代码，然后再编译并执行另一部分代码。
  

• 编译和执行java程序的过程通常是结合使用编译器和解释器。
  

5. 命令行基本操作

• cd  进入某目录
  

• cd .. 进入上级目录
  

• ls 列出当前目录下的文件
  

• rm 删除当前目录下某个文件
  

• mkdir  创建文件夹
  

• cp 复制某文件至某地址
  

• mv 将某文件转移或重命名
  

• man  查找命令的使用方法等
  

• vi/vim 创建文件并进入编辑
  

• java 运行一个java程序
  

• javac Test.java 编译一个java文件
  

6. 开发环境

• 软件开发环境是一组用于创建、测试及修改程序的软件工具。
  

• 将多种不同工具集成在一个软件里的开发环境，称为集成开发环境（IDE）。
  

7. java程序的结构

• 一个程序由一个或者多个类组成。
  

• 每个类包含一个或者多个方法。
  

• 方法由程序语句构成。
  

8. 面向对象编程

• 类：类是一个模子，描述了该对象应该具有什么特征。
  

• 对象：对象是类的实例，由照着类这个模子创建出的实例。
  

第二章 数据与表达式

1. 字符串

• java中，字符串就是对象，由String类定义。java允许定义字符串常量（string literal），并以双引号作为字符串的定界符。
  

2. print和println方法

• 对象的使用方法，示例如下。
  `System.out.pringln("whatever you are, be a good one");`
  

• System.out对象表示一个输出设备或文件，默认的输出设备是显示器屏幕，当然我们也可以用别的方式输出，例如：文件读写。
  

• println方法是System.out对象提供的一个方法，输出后将光标移动至下一行的起点。
  

3. 字符串的拼接

• 字符串拼接运算符为“+”，下面这个字符串拼接在一起的例子。
  `System.out.println("Ther are"+40+"children");`
  

• 实现了字符串与数字拼接，数字不在双引号中，证明这些数字不是字符串。
  

• “+”到底是用于算术加法还是字符串拼接取决于——两边操作数的数据类型。
  

4. 基本的数据类型

• 8 种基本类型(byte,short,int,long,float,double,boolean,char)
  

• 6种数字类型(byte,short,int,long,float,double)
  

• 4种整数类型(byte,short,int,long)，
  

• char占两个字节，
  

• boolean只有true和false。
  

4. 转义字符

• \b：回退键
  

• \t：制表符
  

• \n；换行
  

• \r：回车
  

• \"：双引号
  

• \'：单引号
  

• \\：反斜杠
  

5. Scanner类

• Scanner类可以理解为一个可以解析基本类型和字符串的简单文本扫描器。
  

• (1)构造方法：
  

• Scanner(InputStream source)  //构造一个新的 Scanner，它生成的值是从指定的输入流扫描
  

• InputStream: //输入流
  

• System.in: //代表从键盘录入
  

• (2)成员方法
  

• String next()  查找并返回来自此扫描器的下一个完整标记--> 获取一个字符串。
  

• int nextInt()  将输入信息的下一个标记扫描为一个 int---> 获取一个int类型的数据。
  

• String nextLine()  此扫描器执行当前行，并返回跳过的输入信息--->获取一行数。
  

第三章 类与对象

1. 面向对象编程的三个特性

• (1)继承：通过继承，一个类可以生成他的子类。
  

• (2)多态：去完成某个行为，当不同的对象去完成时会产生出不同的状态。特点：1.灵活性2.可扩充性.3.可替换性。
  

• (3)封装：将类里面的信息保存起来，不允许外部直接访问。用该类提供的方法才能对封装内的信息要进行操作和访问。
  

2. String类

• String类用于创建和操作字符串。
  

• `String str = "Runoob";`
  

• 如果创建好的字符串需要修改，可以使用 StringBuffer & StringBuilder 类。
  

• 连接"string1"和"string2"这两个字符串：`string1.concat(string2);`
  

3. 包（package）

• java语言由一个称为Java API（应用程序编程接口）的标准类库支持，该类库由一套支持程序开发的类组成。
  

• 包：把功能相似的或者相联系的类或接口组织在同一个地方，方便查找和使用。
  

• 包的创建
  `package animals;`
  

• java标准类库的类会被划分成包，例如：
  

• Scanner类就是java.util包中的类，String类和System类是java.lang包中的类。
  

4. import声明

• 使用import声明指定程序中要使用的包和类
  

• 声明方式：
  `import java.util.Scanner;`
  

• 如果使用了包中两个以上的类，那么这样更好一些：
  `import java.util.*;`
  

• java.lang包中的类会自动载入程序，不需要声明。
  

5. Random类

• Random类模拟一个伪随机数发生器，可以在限定范围内随机生成一个数。
  

• 两种构造方法：
  

• Random() 无参构造方法，用于创建一个伪随机数生成器。
  

• Random(long seed) 有参构造方法，使用一个long类型的seed种子创建伪随机数生成器。
  

6. NumberFormat类

• NumberFormat类和DecimalFormat类用于格式化信息，定义在java.text包中。
  

• NumberFormat类使用getCurrencyInstance和getPercentInstance这两个方法格式化信息。一个格式化货币值，一个格式化百分率值。
  

7. 枚举(enum)

• Java 枚举类使用 enum 关键字来定义，各个常量使用“，” 来分割。例如定义一个颜色的枚举类：
  

• enum Color 
  { 
      RED, GREEN, BLUE; 
  }
  

8. 包装器类

• 将java的基本数据类型包装成对象的操作。
  

• 包装器类在java.lang包中，每次使用需要import。
  

• 对于数制转换提供了更好的办法：
  

• toBinaryString()[二进制]
  

• toHexString()[十六进制]
  

• toOctalString()[八进制]
  

第四章 编写类

1. 类和对象的回顾

• 类：属性（变量/常量）+方法（函数）。
  

• 类是对象的抽象\蓝图，对象是类的实例化。
  

2. UML类图（Unified Modeling Language）

• 使用UML类图可以对类和对象之间的关系进行可视化描述。
  

• 每一个类用矩形表示，有类名、属性（数据）和操作（方法）三部分组成。
  

• 用不同的连接线和箭头表示类间各种不同类型的面向对象机制的关系。
  

3. 方法的剖析

• return：返回值。
  

• 局部数据：作用域只在其声明所在的方法内。
  

• 变量的作用域取决于声明该变量的位置，作用域确定了何处可以引用该变量。
  

4. 封装（Encapsulation）

• 封装可以被理解为一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。
  

• 创建一对赋取值方法，用于对私有属性的访问(public)、修改属性的可见性(private)。
  

第五章 条件判断和循环

1. 布尔表达式

• 运行程序中语句的执行顺序称为控制流，线性方式顺序进行。
  

• 调用方法时控制会跳转到方法定义的代码段中执行。而后返回调用方法的位置继续执行。
  

• 也可以通过**条件语句**和**循环语句**来控制程序执行流程。
  

2. 控制循环语句

• if语句:使程序选则是否执行某一条语句。
  

• if-else语句：当某个条件表达式的值为true是做一件事，为flase时做另一件事。
  

• while、do、for：循环语句，使程序多次执行某些语句。
  

• switch语句：判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。
  

• 循环不能永远执行下去，程序员应该注意判断条件最终能否达到false。
  

3. 相等性运算符和关系运算符

• “=”和“！=”用于判断两个值相等还是不相等。
  

• 大于运算符(>)、小于(<)、等于(=)、以及大于等于(>=)、小于等于(<=)。
  

• 一般先运算算术运算符，然后运算相等性运算符和关系运算符，或者以括号来表明运算顺序。
  

4. 逻辑运算符

• !：逻辑非   &&：逻辑与   ||：逻辑或 
  

• 逻辑或和逻辑与具有“短路性”，当之前运算能确定的布尔结果，那么右操作数将不再参与运算。
  

5. 数据比较

• 浮点数的比较：计算两个差值的绝对值，在与公差进行比较。
  

• 字符比较：Unicode字符集定义的相对顺序，数字和其他字符要联系ASCII表中的编码。
  

• 字符串比较用equals
  

6. 迭代器

• 迭代器也是一个对象，可以使用它的一些方法每次处理集合中的一个元素。也就是说，迭代器可以按需一项项地处理每一个元素。
  

7. ArrayList类

• ArrayList 是一个数组队列，相当于动态数组。
  

• ArrayList 保存的是对象类型的元素的引用。不能创建用来保存int这种基本类型数据的ArryList对象，除非使用包装器。
  

第六章 面向对象设计

1. 明确类和对象

• 类代表一组有相似行为的对象，给类命名时要简洁易懂。
  

• 通常使用动词来给行为和完成行为的方法命名。 
  

2. 静态类成员

• 声明静态类成员使用static修饰符
  

• 静态变量(static variable)也被称为类变量，其声明如下：
  `private static int count=0`
  

• 在方法内声明的局部变量不能是静态的。
  

• java程序的方法必须使用static修饰符进行声明。
  

• main方法也只能访问静态变量或者局部变量（实例变量不行，除非实例一下对象）。
  

3. 测试

• 缺陷测试(defect testing)，使用测试用例进行有限式测试。
  

• 黑盒测试基于输入和输出。
  

• 白盒测试一个方法的内部结构和实现。
  

第七章 数组

1. 声明和使用数组

• 在java中，数组是必须实例化的对象。
  

• 声明示范如下：
  `int[] height = new int[11];`
  

• 数组的变量类型(int[])并未指定数组的大小，用new运算符实例化数组height后，其为确定的大小，即11个整型值的内存空间个数不可改变。
  

• 数组的索引是整数型，因此可以使用整形表达式用于数组的索引
  

• 索引运算符“[]”拥有最高的优先级。
  

• 第一次声明数组可以使用初始值表，例如
  `int[] primeNums = {2, 3, 5, 7, 9,}`
  

• 数组也可以作为参数，传递给一个方法。使得方法的形参成为袁术数组的别名。
  

2. 边界检查

• 索引运算符自动执行边界检查.
  

• 每当访问一个数组元素，索引值必须>=0并且<数组元素个数。
  

• 检查数组边界常用数组对象中的length常量，其可以直接引用。
  

• 例如上文建立一个height[11]的数组后，常量height.length的值就为11。
  

• 建立数组时将设置height.length，之后就不能改变。
  

• 数组的最大索引长度为(length-1)。
  

3. 二维数组

• 二维数组形式为int[][]
  

• 多维数组，依次嵌套，例如下面的代码：
  

• for(int row=0; row < table.length; row++)
    for(int col=0; col < table.length; col++)
      table[row][col] = row * 10 + col;
  

第八章 异常

1. 常见的异常抛出问题：

• 试图做除以0的操作。
  

• 数组索引越界。
  

• 找不到指定的文件。
  

• 不能正常完成被请求的I/O操作
  

• 使用了空引用。
  

• 执行的操作违反了某种安全规则。
  

2. 异常的处理

• (1)通过try...catch语句块来处理：
  

• try
  {
  // 程序代码
  }catch(ExceptionName e1)
  {
  //Catch 块
  }
  

• (2)直接抛出，通过throws/throw到上层再进行处理
  

• import java.io.*;
  public class className
  {
  public void deposit(double amount) throws RemoteException
  {
    // Method implementation
    throw new RemoteException();
  }
  //Remainder of class definition
  }
  

3. finally关键字

• finally 关键字用来创建在 try 代码块后面执行的代码块。
  

• 无论是否发生异常，finally 代码块中的代码总会被执行。
  

• 在 finally 代码块中，可以运行清理类型等收尾善后性质的语句。
  

• finally 代码块出现在 catch 代码块最后，语法如下：
  

•   try{
      // 程序代码
    }catch(异常类型1 异常的变量名1){
      // 程序代码
    }catch(异常类型2 异常的变量名2){
      // 程序代码
    }finally{
      // 程序代码
    }
  

第九章 递归

1. 递归的思想

• 把规模大的问题转化为规模小的相似的子问题来解决。
  

2. 递归的条件

• (1)可以通过递归调用来缩小问题规模，且新问题与原问题有着相同的形式。（自身调用）
  

• (2)存在一种简单情境，可以使递归在简单情境下退出。（递归出口）
  

3. 递归三要素

• 一定有一种可以退出程序的情况；
  

• 总是在尝试将一个问题化简到更小的规模
  

• 父问题与子问题不能有重叠的部分
  

4. 递归算法的一般形式：

• func( mode){
      if(endCondition){      //递归出口
            end;
      }else{
           func(mode_small)  //调用本身，递归
      }
  }
  

• 递归中的“递”就是入栈，递进；“归”就是出栈，回归。
  

第十章 算法分析

1. 算法效率

• 算法效率通常使用**CPU的使用时间**来表示。
  

2.时间复杂度的计算

• 加法准则——针对并列程序段
  

• 乘法准则——针对嵌套程序段 
  

• 特例情形——基本操作执行次数与问题的输入数据有关时
  

第十一章 查找与排序

1. 查找

• 线性查找：简单的对数组进行遍历，返回结果，可以设置哨兵提高查找效率。
  

• 二分查找：从中间开始，要求表是有序的，每次比较后可以减少查找池中的一半元素。
  

• 分块查找：首先查找索引表，采用二分查找，以确定待查记录在那一块，然后在已确定的块中进行顺序查找。
  

• 哈希查找：直接通过关键字找到存储地址，是的查找时间可以常数级。
  

• 散列查找：散列技术的记录之间不存在什么逻辑关系，它只与关键字有关。
  

2 排序

• 选择排序：分别将每个值放在排好序的最终位置，从而完成一组值的排序。
  

• 插入排序：将一个具体的值插入到表中已有序的子系列中，从而完成一组值的排序。
  

• 冒泡排序：重复地比较表中的相邻元素，如果它们不符合要求则交换他们。
  

• 快速排序：根据一个任意选定的划分元素来对表进行划分，然后再递归地对划分元素两边的字段进行排序，从而完成对表的排序。
  

• 归并排序：递归地对分表，知道每个子表只含有一个元素时为止，然后再将子表按序合并，从而完成对表的排序。
  

3 分析查找和排序算法

• 考虑当问题大小增大时算法的渐进复杂度。
  

• 考虑每个算法的最优情形和最差情形。
  

数据结构其他内容以实验呈现。

二、作业总结(点击下列小标题可进入查看)

1. 封装继承多态重写重载文件字符字节读写-测试

1.编写一组程序，要体现一下知识点：
（1）继承
（2）多态
（3）重写
（4）重载
（5）目录创建
（6）文件创建
（7）字节流读写
（8）字符流读写

2. 实现自己的ArrayList

1.编写自己的ArrayList类
要求：实现增加、删除、修改、查找、判断是否为空、返回list长度等操作。
2.测试。

3. ArrayStack测试

　（1）撰写自己的类；
　（2）提供StackADT，ArrayStack（框架），实现ArrayStack里面的剩余方法；
　（3）编写测试类，测试所写的方法是否正确。

4. 栈应用—进制转换

算法基于原理： N = (N div d)×d + N mod d
　 例如：（1348)10 = (2504)8 ，其运算过程如下：
N N div 8 N mod 8
1348 168 4
　　168 21 0
　21 2 5
　　2 0 2
要求输入一个十进制数，转换成任意进制数并输出。

5. 最小生成树测试

1.画出Prim算法的最小生成树的生成过程
2.画出Kruscal算法的最小生成树的生成过程
3.计算最小权值

6. 快速排序测试

3,44,38,5,47,15,36,26,27,2,46,4,19,50,48
快速排序
给出第一趟快速排序的结果！

7. 最后一次测试

三、实验报告连接汇总（点击进入网址）

实验一：linux基础与java开发环境

　　　　　　1、基于命令行进行简单的Java程序编辑、编译、运行和调试。
　　　　　　2、练习Linux基本命令；
　　　　　　3、学习Java程序的JDB调试技能：https://www.cnblogs.com/rocedu/p/6371262.html
　　　　　　4、编写简单的Java程序。

实验二：Java基础（数据/表达式、判定/循环语句）

　　　　　　1、 编写简单的计算器，完成加减乘除模运算。
　　　　　　2、要求从键盘输入两个数，使用判定语句选择一种操作，计算结果后输出，然后使用判定和循环语句选择继续计算还是退出。
　　　　　　3、编写测试代码，测试验证。（https://www.cnblogs.com/rocedu/p/4472842.html）

实验三：数据结构与面对对象程序设计

　　　　　　1、 初步掌握单元测试和TDD
　　　　　　2、 理解并掌握面向对象三要素：封装、继承、多态
　　　　　　3、初步掌握UML建模
　　　　　　4.、完成蓝墨云上 （1）-（5）实验。

实验四：JavaSocket 编程

　　　　　　1、Java Socket编程
　　　　　　2、Java和密码学：参考资料
　　　　　　3、编写有理数/复数计算器
　　　　　　4、远程有理数计算器
　　　　　　5、远程复数计算器
　　　　　　6、实验报告

实验五&六：线性结构与链表

　　　　　　1、链表练习，要求实现下列功能：通过键盘输入一些整数，建立一个链表；这些数是你学号中依次取出的两位数。 再加上今天的时间。打印所有链表元素， 并输出元素的总数。
　　　　　　2、链表练习，要求实现下列功能：实现节点插入、删除、输出操作；继续你上一个程序， 扩展它的功能；从磁盘读取一个文件，完成相关操作。
　　　　　　3、链表练习，要求实现下列功能：用冒泡排序法或者选择排序法根据数值大小对链表进行排序；
　　　　　　4、在android上实现实验（1）和（2）
　　　　　　5、在android平台上实现实验（3)

实验七：查找与排序

　　　　　　1、定义一个Searching和Sorting类，并在类中实现linearSearch,SelectionSort方法，最后完成测试。
　　　　　　2、重构你的代码
　　　　　　3、把Sorting.java Searching.java放入 cn.edu.besti.cs2023.（姓名首字母+四位学号） 包中（例如：cn.edu.besti.cs1823.G2301）重新编译，运行代码，提交编译，运行的截图（IDEA，命令行两种）
　　　　　　4、参考http://www.cnblogs.com/maybe2030/p/4715035.html ，学习各种查找算法并在Searching中补充查找算法并测试
　　　　　　5、实现排序方法等(至少3个)测试实现的算法（正常，异常，边界）
　　　　　　6、编写Android程序对实现各种查找与排序算法进行测试

实验八：树

　　　　　　1、参考教材PP16.1,完成链树LinkedBinaryTree的实现，自己编写驱动类对自己实现的LinkedBinaryTree进行测试。
　　　　　　2、基于LinkedBinaryTree，实现基于（中序，先序）序列构造唯一一棵二㕚树的功能
　　　　　　3、对自己实现的功能进行测试。
　　　　　　4、自己设计并实现一颗决策树提交测试代码运行截图，要全屏，包含自己的学号信息课下把代码推送到代码托管平台
　　　　　　5、输入中缀表达式，使用树将中缀表达式转换为后缀表达式，并输出后缀表达式和计算结果

实验九：图

　　　　　　1、初始化：根据屏幕提示（例如：输入1为无向图，输入2为有向图）初始化无向图和有向图（可用邻接矩阵，也可用邻接表），图需要自己定义（顶点个数、边个数，建议先在草稿纸上画出图，然后再输入顶点和边数）
　　　　　　2、图的遍历：完成有向图和无向图的遍历（深度和广度优先遍历）
　　　　　　3、 完成有向图的拓扑排序，并输出拓扑排序序列或者输出该图存在环
　　　　　　4、完成无向图的最小生成树（Prim算法或Kruscal算法均可），并输出
　　　　　　5、完成有向图的单源最短路径求解（迪杰斯特拉算法）

四、学习java时的注意点。

1. 学习中，要养成良好的习惯（写括号时要成对，字母大小写要区分，单词拼写要准确）。
2. 在学习的过程中，最好不是仅仅停留在java表层，不是抄书上的例子运行出结果就可以。要注意，即便对一个简单的例子也要有耐心去琢磨、调试、改动。
3. 在学习的过程中一定要动手做、试着写代码，而不是抱一本书看看就行。很多东西和体会必须自己动手才能真正属于自己。
4. 在 Java 的学习过程中，可能会遇到形形色色的问题不容易解决，应多去专业论坛了解相关的知识，书本上的知识有限。要会从网上搜索有用的信息 加以整理，促进学习的深入和知识水平的提高。

五、代码托管链接

给出statistic.sh的运行结果，统计本学期的代码量。
总计：（截图如下）