《零基础学Java语言》学习总结

《零基础学Java语言》学习总结

 

第1周 计算

    1.0 计算机与编程语言

1.1 第一个Java程序

1.2 变量与计算

1.3 浮点数计算

第2周 判断

2.1 比较

2.2 判断

2.3 分支

2.4 判断语句常见错误

第3周 循环

3.1 循环

3.2 循环的例子

第4周 循环控制

4.1 for循环

4.2 循环控制

4.3 循环的例子

第5周 数组

5.1 数组

5.2 数组计算

5.3 二维数组

第6周 使用对象

6.1 字符类型

6.2 包裹类型

6.3 字符串

第7周 函数

7.1 函数定义与调用

7.2 函数参数与函数内的变量

学编程很容易陷入一听就懂，一做就懵的境地。目前就是这种情况，还要多练习。

学习编程的四个阶段，第一步，想办法看懂别人的代码，看懂的过程一定要去做调试，不是拿眼睛一看，看懂了。要运行代码，跟踪调试代码，从中知道代码是怎么走的，一步一步怎么走过来的。第二步，在别人的代码基础上进行适当的改写。第三步，能把多段已有的代码拼凑起来实现自己需要的功能，在已有的代码基础上加一些东西，拼一些东西，形成自己的代码。第四步， 自己动手编写代码实现特定功能需求的代码。

学习编程的四个方法，1.多读，多读别人的代码。2.多练，通过大量的练习才能手熟。不多练习的话，看着会，敲代码的时候写不出来。 3. 多想。4.多交流。

下一阶段学习内容：接下来两个月以学习翁恺老师的《面向对象程序Java语言》为主，参考书籍明日科技的《零基础学Java》。

学习计划：

第1周 类与对象

第2周 对象交互

第3周 对象容器

第4周 继承与多态

第5周 设计原则

第6周 抽象与接口

第7周 控制反转与MVC模式

第8周 异常处理与输入输出

Win10下 Java环境变量配置

在电脑桌面 右键点击 “此电脑”的“属性”选项，选择“高级系统设置”选项，点击下面的“环境变量”选项。

具体的配置过程：

点击“系统变量”下面的”新建“选项

在”变量名“处填上”Java_Home“

”变量值“为JDK安装路径，根据实际路径填写“C:\Program Files (x86)\Java\jdk1.7.0_01”

点击”确定“选项

在”系统变量“中找到”Path“

选中”Path“点击”编辑“选项

选择右边的“编辑文本”，将引号里面的全部复制“%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;”，到“变量值”栏的最后面（放到最前面，最后面都可以），“确定”

在“系统变量”栏，“新建”，“变量名”为“CLASSPATH”，“变量值”为“.;%JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar;”

“确定”

点击“环境变量”最下面的“确定”选项

在cmd里边检查Java环境是否配置成功：

输入"java"

输入"javac"

输入"java -version"

第1周初次接触Java

写代码的时候能用键盘的操作尽量不要用鼠标。常用快捷键Alt+“／”键，自动补全，Tab键，缩进。Shift键+Tab键，退格。

经常用到的语句要做笔记，例如：

Scanner in = new Scanner(System.in);

int a = in.nextInt();

int b = in.nextInt();

System.out.println(a+"和"+b);

变量的名字

变量需要一个名字，变量的名字是一种“标识符”，意思是它是用来识别这个和那个的不同的名字。

标识符有标识符的构造规则。基本的原则是：标识符只能由字母、数字和下划线组成，数字不可以出现在第一个位置上，Java的关键字（有的地方叫它们保留字）不可以用做标识符。

赋值

和数学不同，a=b在数学中表示关系，即a和b的值一样；而在Java中，a=b表示要求计算机做一个动作：将b的值赋给a。关系是静态的，而动作是动态的。在数学中，a=b和b=a是等价的，而在Java中，两者的意思完全相反。

浮点数和浮点int到double自动转换,定义变量double inch;例如输入一个数值7，结果是inch=7.0

浮点数运算是有误差的，如System.out.println(1.2-1.1);结果是0.09999999999999987

浮点数和整数放到一起运算时，Java会将整数装换为浮点数，然后进行浮点数的运算。如果是浮点数转换成整型就需要进行强制类型转换 (int)，强制类型转换的优先级高于四则运算。

如：int i=32/3.0; 就会报错，类型不匹配。正确的写法是

    int i=(int)(32/3.0);  

用final 表示常量

加减乘除是有不同的优先级的

单目运算符：只有一个算子的运算符。如：＋、－

单目运算符的结合关系：一般自左向右，单目＋－和赋值＝是自右向左的。如果记不住的话，就加括号。

第2周 判断

能做判断的基础，是能对数据做比较，比较就是关于两个数据是否相等、谁大谁小的结论，这需要用到关系运算：对两个数据之间的关系的计算。

Java提供了六个关系运算符：

==  相等

!= 不相等

> 大于

>=  大于或等于

<   小于

<= 小于或等于

关系运算的结果是一个逻辑值，逻辑值只有两种可能的值：true（真，表示成立）或false（假，表示不成立）。

判断两个浮点数是否相等，通常求他们的差距看是否小于一个比较小的数  Math.abs(f1 - f2) < 0.00001 

    根据比较的结果，决定做、还是不做某些动作，就要用到if语句。

一个基本的if语句由一个关键字if开头，跟上在括号里的一个表示条件的逻辑表达式，然后是一对大括号“{}”之间的若干条语句。如果表示条件的逻辑表达式的结果为true，那么就执行后面跟着的这对大括号中的语句，否则就跳过这些语句不执行，而继续下面的其他语句。

有的时候我们希望在条件成立的时候做一件事情，而在条件不成立的时候做另外一件事情。这可以在if语句后面跟上一个else子句，形成一个if-else语句。

if语句这一行结束的时候并没有表示语句结束的“;”，而后面的赋值语句写在if的下一行，并且缩进了，在这一行结束的时候有一个表示语句结束的“;”。这表明这条赋值语句是if语句的一部分，if语句拥有和控制这条赋值语句，决定它是否要被执行。

流程图

以特定的图形符号加上说明，表示算法的图，称为流程图。圆角矩形表示“开始”与“结束”。矩形表示行动方案、普通工作环节。用菱形表示问题判断或判定（审核／审批／评审）环节。用平行四边形表示输入输出。箭头代表工作流方向。

嵌套的判断

当if的条件满足或者不满足的时候要执行的语句也可以是一条if或if-else语句，这就是嵌套的if语句。else总是和最近的那个if匹配。

为避免混淆，在if或else后面总是用{}，即使只有一条语句的时候。

代码风格

在if和else之后必须加上大括号形成语句块；大括号内的语句缩进一个tab的位置。

多路分支

switch-case

控制表达式只能是整数型的结果。

常量可以是常数，也可以是常数计算的表达式。

根据表达式的结果，寻找匹配的case,并执行case后面的语句，一直到break为止。

如果所有的case都不匹配，那么就执行default后面的语句；如果没有default,那么就什么都不做。

break

switch语句可以看作是一种基于计算的跳转，计算控制表达式的值后，程序会跳转到相匹配的case(分支标号）处。分支标号只是说明switch内部位置的路标，在执行完分支中的最后一条语句后，如果后面没有break,就会顺序执行到下面的case里去，直到遇到一个break,或者switch结束为止。

这段程序：

输入1，输出：你好

输入2，输出：你好

输入3，输出：晚上好  再见

输入4，输出：再见

输入5，输出：啊，什么啊？

第3周、第4周  循环

if语句可以判断条件是否满足，满足时才做相应的动作，而循环语句可以在满足条件时，不断地重复执行一些动作。

重复执行的语句（循环语句）可以多次执行其他语句，它检查一个逻辑条件是否满足，只在满足的时候执行它的循环体。

while语句是一个循环语句，它会首先判断一个条件是否满足，如果条件满足，则执行后面紧跟着的语句或语句括号，然后再次判断条件是否满足，如果条件满足则再次执行，直到条件不满足为止。后面紧跟的语句或语句括号，就是循环体。

while循环

如果我们把while翻译作“当”，那么一个while循环的意思就是：当条件满足时，不断地重复循环体内的语句。循环执行之前判断是否继续循环，所以有可能循环一次也没有被执行；条件成立是循环继续的条件。循环体内要有改变条件的机会。

do-while循环

do-while循环和while循环很像，唯一的区别是我们在循环体执行结束的时候才来判断条件。也就是说，无论如何，循环都会执行至少一遍，然后再来判断条件。与while循环相同的是，条件满足时执行循环，条件不满足时结束循环。

do-while循环在进入循环的时候不做检查，而是在执行完一轮循环体的代码之后，再来检查循环的条件是否满足，如果满足则继续下一轮。

for循环

for循环像一个计数循环：设定一个计数器，初始化它，然后在计数器到达某值之前，重复执行循环体，而每执行－轮循环，计数器值以一定步进进行调整，比如加1或者减1。

for(初始化；条件；单步动作）{

}

1.第一个部分是一个初始化，可以定义一个新的变量：int count=10或者直接赋值：i=10.

2.第二个部分是循环维持的条件。这个条件是先验的，与while循环一样，进入循环之前，首先要检验条件是否满足，条件满足才执行循环；条件不满足就结束循环。

3.第三个部分是步进，即每轮执行了循环体之后，必须执行的表达式。通常我们在这里改变循环变量，进行加或减的操作。

for=对于

for(count=10;count>0;count=count-1）

就读成：“对于一开始的count=10,当count>0时，重复做循环体，每一轮循环在做完循环体内语句后，使得count递减。”

以上2种循环语句也可以实现输出：10987654321发射!

让计算机来想一个数，然后让用户来猜，用户每输入一个数，就告诉它是大了还是小了，直到用户猜中为止，最后还要告诉用户它猜了多少次。

1.计算机随机想一个数，记在变量number里；

2. 一个负责计次数的变量count初始化为0;

3. 让用户输入一个数字a;

4.count递增（加一）；

5.判断a和number的大小关系，如果a大，就输出

“大”；如果a小就输出“小”；

6. 如果a和number是不相等的（无论大还是小），程序转回到第3步；

7. 否则，程序输出“猜中”和次数，然后结束。

for循环

for(初始动作；条件；每轮的动作）｛

｝

建议：只要是for语句，就一定跟上一对大括号。

for中的每一个表达式都是可以省略的

for(;条件；）＝＝while(条件）

三种循环的选用：

如果有固定次数，用for

如果必须执行一次，用do while

其他情况用while

复合赋值

5个算术运算符，＋－＊／％，可以和赋值运算符“＝”结合起来，形成复合赋值运算符：“＋＝”、“－＝”、“＊＝”、“／＝”和“％＝”

total +=5;

total=total+5;

注意两个运算符中间不要有空格。

递增递减运算符

“＋＋”和“－－”是两个很特殊的运算符，它们是单目运算符，这个算子还必须是变量。这两个运算符分别叫做递增和递减运算符，他们的作用就是给这个变量＋1或者－l 。

count++;

count+=1;

count= count+1;

前缀后缀

++和--可以放在变量的前面，叫做前缀形式，也可以放在变量的后面，叫做后缀形式。

a++的值是a加1以前的值，而++a的值是加了1以后的值，无论哪个，a自己的值都加了1了。

表达式	运算	表达式的值
count++	给count加1	count原来的值
++count	给count加1	count加1以后的值
count--	给count减1	count原来的值
--count	给count减1	Count减1以后的值

程序输出结果分别是2，3，2，1

循环控制

break:跳出循环

continue:跳过循环这一轮剩下的语句进入下一轮

只能对它所在的那层循环做。

如果是从从嵌套中break，要

Break和continue

在循环前可以放一个标号来标示循环：

label:

带标号的break和continue对那个循环起作用。

这个例子中，用了标号OUT:

break OUT;就跳出了循环，到标号OUT:的位置。

逻辑类型

关系运算的结果是一个逻辑值，true或false.这个值可以保存在一个对应的逻辑类型的变量中，这样的变量类型是 boolean

逻辑运算是对逻辑量进行的运算，只有逻辑量可以参与运算。

运算符	描述	示例	结果
!	逻辑非	!a	如果a是true结果就是false, 如果a是false结果就是true
&&	逻辑与	a&&b	如果a和b都是true,结果就 是true；否则就是false
||	逻辑或	a || b	如果a和b有一个是true,结果为true； 两个都是false,结果为false

第5周 数组

容器是当代程序设计重要的基础设施

数据可以存放在变量里，每一个变量有一个名字，有一个类型，还有它的生存空间。如果我们需要保存一些相同类型、相似含义、相同生存空间的数据，我们可以用数组来保存这些数据，而不是用很多个独立的变量。数组是长度固定的数据结构，用来存放指定的类型的数据。一个数组里可以有很多个数据，所有的数据的类型都是相同的。

数组是一种容器，所谓容器就是放东西的东西。容器是当代程序设计重要的基础设施，可以说每一个软件必定用到某种形式的容器。数组是最古老最基础的容器。

数据可以存放在变量里，每一个变量有一个名字，有一个类型，还有它的生存空间。如果我们需要保存一些相同类型、相似含义、相同生存空间的数据，我们可以用数组来保存这些数据，而不是用很多个独立的变量。数组是长度固定的数据结构，用来存放指定的类型的数据。一个数组里可以有很多个数据，所有的数据的类型都是相同的。

数组是一种容器（放东西的东西），特点是：其中所有的元素具有相同的数据类型；一旦创建，不能改变大小；数组中的每个数据叫做元素。

元素个数必须是整数；元素个数必须给出；元素个数可以是变量。

索引或下标是从0开始的。

每个数组有一个内部成员length,会告诉你它的元素的数量。

以上两个程序都是计算平均数

第一个程序对数组中的元素赋值，这个程序中如果输入的个数大于10 的话就会有问题数组下标越界。

第二个程序，首先让用户输入个数，用这个数作为数组元素的个数。这样输入几个数后，自动就给出了平均值，不会出现第一个程序中下标越界的问题。

for each循环      for(<类型> <变量> : <数组>)

for each循环特别适合于遍历一个数组的场合。拿出数组中的每一个元素，做些事情，比如比较，或者赋给别人。也有不适合的地方，这个for each循环里边k没有位置，他是在这个循环中取出来的一个变量，他和数组某个元素之间只是一个值的对应关系，而并不是具体的存储位置的关系。

遍历数组通常都是使用for循环，让循环变量i从0到<数组的length,这样循环体内最大的i正好是数组最大的有效下标。

数组变量

数组变量是数组的管理者而非数组本身

数组必须创建出来然后交给数组变量来管理

数组变量之间的赋值是管理权限的赋予

数组变量之间的比较是判断是否管理同一个数组

复制数组必须遍历源数组将每个元素逐一拷贝给目的数组

二维数组

二维数组的初始化

int[][] a = {

{1,2,3,4},

{1,2,3},

};

外边那一层大括号表示整个数组，里边每一层大括号表示每一行。

编译器来数数

每行一个，逗号分隔

最后的逗号可以存在，有古老的传统

如果省略，表示补零

int[][] a = new int[3][5];

通常理解为a是一个3行5列的矩阵。

a[0][0]	a[0][1]	a[0][2]	a[0][3]	a[0][4]
a[1][0]	a[1][1]	a[1][2]	a[1][3]	a[1][4]
a[2][0]	a[2][1]	a[2][2]	a[2][3]	a[2][4]

运行程序，输入：

0 1 2 3 4 5 6 7 8 9

输出

0 1 2

3 4 5

6 7 8

第6周 使用对象

字符也是Java中基础的数据类型之一，Java采用Unicode16表达字符，在所有的机器上，不管CPU、操作系统和本地语言，字符类型是一致和统一的。

一个字符的常量是用单引号包围起来的一个字符，如'a'、'*'、'好'。一个汉字也是Unicode的一个字符，所以也是Java的一个字符。

字符类型

单个的字符是一种特殊的类型：char

用单引号表示的字符字面量： 'a', '1''a’

Java使用Unicode来表示字符，可以表达包括汉字在内的多种文字。

·一个字符加一个数字得到Unicode码表中那个数之后的字符

·两个字符的减，得到它们在表中的距离

·char也可以和int之间互相赋值

输出结果：

abc    123

a      123

a"b"

逃逸字符

用来表达无法印出来的控制字符或特殊字符，它由一个反斜杠“＼”开头，后面跟上另一个字符，这两个字符合起来，组成了一个字符。

包裹类型

对于基本数据类型，Java提供了对应的包裹(wrap)类型。这些包裹类型将一个基本数据类型的数据转换成对象的形式，从而使得它们可以像对象一样参与运算和传递。下表列出了基本数据类型所对应的包裹类型：

基本类型	包裹类型
boolean	Boolean
char	Character
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double

我们看到，除了int和char以外，包裹类型就是把基本类型的名字的第一个字母大写。在Java的系统类库中，所有第一个字母大写的，都是类的名字。所以在编辑程序的时候，一定要小心大小写，以免一不小心犯错。

Character类的方法	说明
isLetter()	是否是一个字母
isDigit()	是否是一个数字字符
isWhitespace()	是否是一个空白字符
isUpperCase()	是否是大写字母
isLowerCase()	是否是小写字母
toUpperCase()	指定字母的大写形式
toLowerCase()	指定字母的小写形式
toString()	返回字符的字符串形式，字符串的长度仅为1

函数方法	说明
Math.abs()	绝对值
Math.pow(n, x)	n的x次方（浮点数）
Math.random()	0-1之间的随机数
Math.round()	四舍五入取整

程序输出结果

2147483647

-2147483648

false

true

A

a

0.3180097702755048

第7周

Java的函数必须定义在类的内部，成为类的成员。定义一个函数，要像这样写：

<返回类型> <方法名称>(<参数表>) {

    <方法体>

}

返回类型是这个函数运行结束时要返回给调用者的数据的类型，函数可以返回基本数据类型、对象或者void。返回void表示这个函数不返回任何值。函数名称是一个Java名字，一样要遵循和变量一样的命名规则。参数表是0个或1个或多个参数定义，用逗号’,’分隔。

在这个阶段，我们要在所有的函数的返回类型前面加上关键字“static”。static表示这个函数属于这个类，而不属于这个类的任何对象，因此我们才可以不制造这个类的对象，而直接从main()函数中调用它。

当一个函数被调用时，程序就转到这个函数中去运行，函数体里的语句就一条一条地被调用。一旦函数运行结束，就又回到调用它的地方去继续运行。

什么是函数？

函数是一块代码，接收零个或多个参数，做一件事情，并返回零个或一个值。

可以先想像成数学中的函数：y=f(x)

调用函数

函数名(参数值);

()起到了表示函数调用的重要作用, 即使没有参数也需要()

如果有参数，则需要给出正确的数量和顺序。

从函数中返回值

return停止函数的执行，并送回一个值，有以下两种方式：

return;

return 表达式;

一个函数里可以出现多个return语句，但是保持单一出口是好的做法。如果函数有返回值，则必须使用带值的return。

没有返回值的函数

void 函数名（参数表）

不能使用带值的return

可以没有return

调用的时候不能做返回值的赋值。

求出1到10、20到30和35到45的三个和，以及任意两个整数数a和b之间整数的和。

1到10，20到30，35到45。可以写三段循环实现。在一个代码中出现了很多类似代码段，“代码复制”是程序质量不良的表现。

可以定义一个函数public static void sum(int a, int b)

把公共部分用一个函数实现，在下面调用这个函数。

参数传递

调用函数，如果函数有参数，调用函数时必须传递给它数量、类型正确的值。可以传递给函数的值是表达式的结果，这包括：

字面量

变量

函数的返回值

计算的结果

输出结果：

6

12

6

23

12

Java语言调用函数时，永远只能传值给函数，下面这段程序输出结果是a=5,b=6

    每个函数都有自己的变量空间，参数也位于这个独立的空间中，和其他参数没有关系。

    过去，对于函数参数表中的参数，叫做“形式参数”，调用函数时给的值，叫做“实际参数”。由于容易让初学者误会实际参数就是实际在函数中进行计算的参数，误会调用函数的时候把变量而不是值传进去了，所以我们不建议继续用这种古老的方式来称呼它们。我们认为，它们是参数和值的关系。

类型不匹配的情况：

当函数期望的参数类型比调用函数时给的值的类型宽的时候，编译器能自动把类型转换好char->int->double

当函数期望的参数类型比调用函数时给的值的类型窄的时候，需要写强制类型转换。例如：(int)5.0

当函数期望的参数类型与调用函数时给的值的类型之间无法转换的时候，编译器报错，无法写程序。

本地变量

函数的每次运行，就产生了一个独立的变量空间，在这个空间中的变量，是函数的这次运行所独有的，称作本地变量。

定义在函数内部的变量就是本地变量。

参数也是本地变量。

变量的生存期和作用域

生存期：什么时候这个变量开始出现了，到什么时候它消亡了。

作用域：在（代码的）什么范围内可以访问这个变量（这个变量可以起作用）。

对于本地变量，生存期和作用域是统一的：大括号

本地变量的规则：

本地变量是定义在块内的

它可以是定义在函数的块内

也可以定义在语句的块内

甚至可以随便拉一对大括号来定义变量

程序运行进入这个块之前，其中的变量不存在，离开这个块，其中的变量就消失了

块外面定义的变量在里面仍然有效

不能在一个块内定义同名的变量，也不能定义块外面定义过的变量

本地变量不会被默认初始化

参数在进入函数的时候被初始化了