Java入门第一季

1.1 Java的特性与版本

跨平台 开源（开放源代码）

Java代码（.java）

字节码文件（.class）

Java的版本区别

J2SE：标准版，提供了Java语言最核心的功能，是其他版本的基础。

J2EE：企业版，针对企业级应用开发提供了更多高级功能。

J2ME：崁入式版，可为智能设备开发应用程序，目前极少使用。

1.2 我与Java的第一次接触
public class HelloWord{  意思是创建了一个名为HelloWorld的程序

        public static void  main(String[] args){  此行为程序入口意思主要代码在这一组大括号中来进行书写

                System.out.println("Hello World"); 意思为将后面引号中的字符在屏幕上打印输出，其中最后注意分号

        }

}

1.4 第一个Java程序
public class HelloWorld {
    public static void main(String[] args){
        System.out.println("hello imooc");
    }
}

输出：hello imooc

Publick 公开的

class 类

static 静止的

void 无效的

main 主要

string 字符串

system 系统

println 输出

命令学习：system.out.println（系统文字输出）

固定入口：pubilck static void main （string【】 args）

1.5 程序的移植

快捷键psvm 代表public static void main()

快捷键sout 代表 System.out.println();

1.6 经验技巧分享
多练习 练习总结经验

多向大佬提问自己不懂的 用最短的时间解决所遇到的问题

总结自己所学到的东西

2.1 Java中的关键字 
Java 语言中有一些具有特殊用途的词被称为关键字。关键字对 Java 的编译器有着特殊的意义，在程序中应用时一定要慎重哦！！

abstract //抽象方法，抽象类的修饰符
assert //断言条件是否满足
boolean //布尔
break //跳出循环或者label代码段
byte //8-bit 有符号数据类型
case //switch语句的条件
catch //和try搭配捕捉异常
char //16-bit Unicode字符数据
class //定义类
const //未使用
continue //不执行循环体剩余部分
default //switch语句中的默认分支
do //循环语句，至少会执行一次
double //64-bit双精度浮点数
else //if条件不成立
enum //枚举类型
extends //继承
final //常量
//方法不能被重写，或者一个类不能有子类
finally //try 语句不管是否发生异常都要执行的语句块
float //32-bit单精度浮点数
for //for循环
goto //未使用
if //条件语句
implements //类实现了接口
import //导入类
instanceof //测试一个对象是否是某个类的实例
int //32位整型数
interface //接口
long //64位整型数
native //表示方法用非java代码实现
new //新的类实例
package //包
private //表示私有字段，方法等，只能从类内部访问
protected //表示只能通过类或者其子类访问
//子类或者在同一个包内的其他类
public //表示共有属性或者方法
return //方法返回值
short //16位数字
static //静态
strictfp //浮点数比较使用严格的规则
super //表示父类/基类
switch //选择语句
synchronized //表示同一时间只能由一个线程访问的代码块
this //当前实例
//或者调用另一个构造函数
throw //抛出异常
throws //定义异常
transient //修饰不要序列化的字段
try //捕捉异常
void //标记方法不返回任何值
volatile //标记字段可能会被多个线程同时访问，而不做同步
while //while循环

        

编写Java程序时，应注意以下几点：
    大小写敏感：Java是大小写敏感的，这就意味着标识符Hello与hello是不同的。
    括号：任何括号都要配对! 建议: 括号成对写，如果删除的话成对删除。
    缩进：适当注意代码的缩进，会增加代码的可视性。
    符号：在写代码的时候，所有符号一定是英文半角符号输入。同时每句执行代码的结尾一定以分号结束。
    换行：适当注意换行，会增加代码的可视性。
    导包：可以同过import引入相应的工具类来辅助开发。
    类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。
    方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。
    源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记Java是大小写敏感的），文件名的后缀为.java。（如果文件名和类名不相同则会导致编译错误）。
    主方法入口：所有的Java 程序由public static void main(String[]args)方法开始执行。
2.2 认识Java标识符

使用标识符时，需要遵守几条规则：

 1.  标识符可以由字母、数字、下划线（_）、美元符（$）组成，但不能包含 @、%、空格等其它特殊字符，不能以数字开头。譬如：123name 就是不合法滴

 2.  标识符不能是 Java 关键字和保留字（ Java 预留的关键字，以后的升级版本中有可能作为关键字），但可以包含关键字和保留字。如：不可以使用 void 作为标识符，但是 Myvoid 可以

 3.  标识符是严格区分大小写的。 所以涅，一定要分清楚 imooc 和 IMooc 是两个不同的标识符哦！

 4.  标识符的命名最好能反映出其作用，做到见名知意。

2.3 变量是什么
变量名=房间的名字；

变量类型=房间类型；

入住的客人=变量；

比如：String Hello="hello";

String就是房间类型是经济房还是总统套房，它就是变量类型，它还可以是char、int。

Hello就是房间号或者说是房间的名字是101还是888，它就是变量的名字，它还可以是Hi、hi等。

hello就是入住的客人了它可以是"a"也可以是"b"，他就是变量的值，它的值还可以是shenme、Shenme等。

2.4 如何命名Java变量

注意：

1、变量名由多单词组成时，第一个单词的首字母小写，其后单词的首字母大写，俗称骆驼式命名法（也称驼峰命名法），如 myAge

2、变量命名时，尽量简短且能清楚的表达变量的作用，做到见名知意。如：定义变量名 stuName 保存“学生姓名”信息

PS： Java 变量名的长度没有限制，但 Java 语言是区分大小写的，所以 price 和 Price 是两个完全不同的变量哦！

2.5 Java中的数据类型
ava 语言是一种强类型语言。通俗点说就是，在 Java 中存储的数据都是有类型的，而且必须在编译时就确定其类型。 Java 中有两类数据类型：

在 Java 的领域里，基本数据类型变量存的是数据本身，而引用类型变量存的是保存数据的空间地址。说白了，基本数据类型变量里存储的是直接放在抽屉里的东西，而引用数据类型变量里存储的是这个抽屉的钥匙，钥匙和抽屉一一对应。

常用的基本数据类型有：

注：String 是一种常见的引用数据类型，用来表示字符串。在程序开发中，很多操作都要使用字符串来完成，例如系统中的用户名、密码、电子邮箱等。

2.6 Java中变量的使用规则
1、Java 中的变量需要先声明后使用
2、变量使用时，可以声明变量的同时进行初始化
3、变量中每次只能赋一个值，但可以修改多次
4、main 方法中定义的变量必须先赋值，然后才能输出
5、虽然语法中没有提示错误，但在实际开发中，变量名不建议使用中文，容易产生安全隐患，譬如后期跨平台操作时出现乱码等等
2.7 Java中的自动类型转换
在 Java 程序中，不同的基本数据类型的数据之间经常需要进行相互转换。例如：

代码中 int 型变量 score1 可以直接为 double 型变量 score2 完成赋值操作，运行结果为： 82.0 

这种转换称为自动类型转换。

当然自动类型转换是需要满足特定的条件的：

1.  目标类型能与源类型兼容，如 double 型兼容 int 型，但是 char 型不能兼容 int 型

2.  目标类型大于源类型，如 double 类型长度为 8 字节， int 类型为 4 字节，因此 double 类型的变量里直接可以存放 int 类型的数据，但反过来就不可以了

2.8 Java中的强制类型转换

 因为 int 型的存储范围比 double 型的小。此时就需要通过强制类型转换来实现了。

语法：( 数据类型 ) 数值

运行结果：

可以看到，通过强制类型转换将 75.8 赋值给 int 型变量后，结果为 75，数值上并未进行四舍五入，而是直接将小数位截断。

强制类型转换可能会造成数据的丢失哦

2.9 Java常量的应用
所谓常量，我们可以理解为是一种特殊的变量，它的值被设定后，在程序运行过程中不允许改变。

语法：final 常量名 = 值;

注：常量名一般使用大写字符

2.10 如何在Java中使用注释
Java 中注释有三种类型：单行注释、多行注释、文档注释

运行结果： Hello Imooc!

被注释的代码块在程序运行时是不会被执行的~~

单行注释//开头     (快捷键 ctrl+/ )
多行注释：/* */    (ctrl+shift+/ )
文档注释：/** */
3.1 什么是运算符
运算符是一种“功能”符号，用以通知 Java 进行相关的运算。譬如，我们需要将变量 age 的值设置为 20 ，这时候就需要一个“=”，告诉程序需要进行赋值操作。

Java 语言中常用的运算符可分为如下几种：

Ø 算术运算符

Ø 赋值运算符

Ø 比较运算符

Ø 逻辑运算符

Ø 条件运算符

3.2 Java中的算术运算符
Java 中常用的算术运算符：

 其中，++ 和 -- 既可以出现在操作数的左边，也可以出现在右边，但结果是不同滴

一定要注意哦！自增和自减运算符只能用于操作变量，不能直接用于操作数值或常量！例如 5++、8-- 等写法都是错误滴！

PS：% 用来求余数，也称为”取模运算符“。

3.3 Java中的赋值运算符
赋值运算符是指为变量或常量指定数值的符号。如可以使用 “=” 将右边的表达式结果赋给左边的操作数。

Java 支持的常用赋值运算符，如下表所示：

3.4 Java中的比较运算符
比较运算符用于判断两个数据的大小，例如：大于、等于、不等于。比较的结果是一个布尔值（ true 或 false ）。

1、  > 、 < 、 >= 、 <= 只支持左右两边操作数是数值类型

2、  == 、 != 两边的操作数既可以是数值类型，也可以是引用类型

3.5 Java中的逻辑运算符
逻辑运算符主要用于进行逻辑运算。Java 中常用的逻辑运算符如下表所示：

我们可以从“投票选举”的角度理解逻辑运算符：

1、 与：要求所有人都投票同意，才能通过某议题

2、 或：只要求一个人投票同意就可以通过某议题

3、 非：某人原本投票同意，通过非运算符，可以使其投票无效

4、 异或：有且只能有一个人投票同意，才可以通过某议题

当使用逻辑运算符时，我们会遇到一种很有趣的“短路”现象。

譬如：( one > two ) && ( one < three ) 中，如果能确定左边 one > two 运行结果为 false , 则系统就认为已经没有必要执行右侧的 one < three 啦。

同理，在( one > two ) || ( one < three ) 中，如果能确定左边表达式的运行结果为 true , 则系统也同样会认为已经没有必要再进行右侧的 one < three 的执行啦！

3.6 Java中的条件运算符
条件运算符（ ? : ）也称为 “三元运算符”。

语法形式：布尔表达式 ？ 表达式1 ：表达式2

运算过程：如果布尔表达式的值为 true ，则返回 表达式1 的值，否则返回 表达式2 的值

因为，表达式 8>5 的值为 true ，所以，返回： 8大于5

3.7 Java中运算符的优先级
所谓优先级，就是在表达式中的运算顺序。Java 中常用的运算符的优先级如下表所示：

级别为 1 的优先级最高，级别 11 的优先级最低。譬如，x = 7 + 3 * 2  得到的结果是 13 “先乘后加”嘛!

PS：大家没必要去死记运算符的优先级顺序，实际开发中，一般会使用小括号辅助进行优先级管理。

分析：小括号优先级最高，因此

1、 执行 a + 18 ，结果为 30

2、 执行( a + 18 ) % 4 取模，结果为 2

3、 执行 a * ( ( a + 18 ) % 4 )，结果为 24

4.2 Java条件语句之 if...else

4.3 Java条件语句之多重 if
多重 if 语句，在条件 1 不满足的情况下，才会进行条件 2 的判断；当前面的条件均不成立时，才会执行 else 块内的代码。

该段代码的含义是：如果 score 值大于90，则奖励一个 Iphone 5s ，当 score 值小于等于 90 时，先判断 score 是否大于 70 ，如果 score 是介于 70--90 之间，则奖励一个红米，如果成绩小于等于 70 ，则罚做 500 个俯卧撑。

4.4 Java条件语句之嵌套 if
嵌套 if 语句，只有当外层 if 的条件成立时，才会判断内层 if 的条件。

运行结果为： 去室外游乐场游玩

4.5 Java条件语句之 switch

执行过程：当 switch 后表达式的值和 case 语句后的值相同时，从该位置开始向下执行，直到遇到 break 语句或者 switch 语句块结束；如果没有匹配的 case 语句则执行 default 块的代码。

不得不说的几点小秘密：

1、 switch 后面小括号中表达式的值必须是整型或字符型

2、 case 后面的值可以是常量数值，如 1、2；也可以是一个常量表达式，如 2+2 ；但不能是变量或带有变量的表达式，如 a * 2

3、 case 匹配后，执行匹配块里的程序代码，如果没有遇见 break 会继续执行下一个的 case 块的内容，直到遇到 break 语句或者 switch 语句块结束 

4、 可以把功能相同的 case 语句合并起来，如

5、 default 块可以出现在任意位置，也可以省略

4.6 Java循环语句之 while
Java 常用的 3 种循环： while 、 do...while 、 for

< 1 >、 判断 while 后面的条件是否成立( true / false )

< 2 >、 当条件成立时，执行循环内的操作代码 ，然后重复执行< 1 >、< 2 >， 直到循环条件不成立为止

特点：先判断，后执行

4.7 Java循环语句之 do...while
do...while 循环与 while 循环语法有些类似，但执行过程差别比较大。

<1>、 先执行一遍循环操作，然后判断循环条件是否成立

<2>、 如果条件成立，继续执行< 1 > 、< 2 >，直到循环条件不成立为止

特点： 先执行，后判断

由此可见，do...while 语句保证循环至少被执行一次！

例如，依然输出 1000 遍“我爱慕课网”，使用 do...while 的实现代码为：

4.8 Java循环语句之 for
Java 的循环结构中除了 while 和 do...while 外，还有 for 循环，三种循环可以相互替换。

<1>、 执行循环变量初始化部分，设置循环的初始状态，此部分在整个循环中只执行一次

<2>、 进行循环条件的判断，如果条件为 true ，则执行循环体内代码；如果为 false ，则直接退出循环

<3>、 执行循环变量变化部分，改变循环变量的值，以便进行下一次条件判断

<4>、 依次重新执行< 2 >、< 3 >、< 4 >，直到退出循环

特点：相比 while 和 do...while 语句结构更加简洁易读

需要留心的几个小细节：

1、 for 关键字后面括号中的三个表达式必须用 “;” 隔开，三个表达式都可以省略，但 “;” 不能省略。

    a. 省略“循环变量初始化”，可以在 for 语句之前由赋值语句进行变量初始化操作，如:

   b. 省略“循环条件”，可能会造成循环将一直执行下去，也就是我们常说的“死循环”现象，如:

在编程过程中要避免“死循环”的出现，因此，对于上面的代码可以在循环体中使用 break 强制跳出循环（关于 break 的用法会在后面介绍）。

    c. 省略“循环变量变化”，可以在循环体中进行循环变量的变化，如：

2、 for 循环变量初始化和循环变量变化部分，可以是使用 “,” 同时初始化或改变多个循环变量的值，如：

代码中，初始化变量部分同时对两个变量 i 和 j 赋初值，循环变量变化部分也同时对两个变量进行变化，运行结果：

3、 循环条件部分可以使用逻辑运算符组合的表达式，表示复杂判断条件，但一定注意运算的优先级，如：

代码中，必须同时满足变量 i 小于 10 ，并且 i 不等于 5 时才会进行循环，输出变量 i 的值。

4.9 Java循环跳转语句之 break
在 Java 中，我们可以使用 break 语句退出指定的循环，直接执行循环后面的代码。

例如，使用循环输出 1--10的数值，其中，如果数值大于 2 ，并且为 3 的倍数则停止输出。

4.10 Java循环跳转语句之 continue
continue 的作用是跳过循环体中剩余的语句执行下一次循环。

例如，打印 1--10 之间所有的偶数，使用 continue 语句实现代码为：

4.11 Java 循环语句之多重循环
循环体中包含循环语句的结构称为多重循环。三种循环语句可以自身嵌套，也可以相互嵌套，最常见的就是二重循环。在二重循环中，外层循环每执行一次，内层循环要执行一圈。

例如：使用 * 打印长方形：

执行流程：当 i = 1 时，外层循环条件成立，进入内层循环，开始打印第一行内容。此时， j 从 1 开始，循环 8 次，内层循环结束后换行，实现第一行 8 个 * 的输出。接下来返回外层循环 i 变为 2 ，准备打印下一行，依此类推，直到完成长方形的打印。

5.1 什么是数组
数组可以理解为是一个巨大的“盒子”，里面可以按顺序存放多个类型相同的数据，比如可以定义 int 型的数组 scores 存储 4 名学生的成绩

数组中的元素都可以通过下标来访问，下标从 0 开始。例如，可以通过 scores[0] 获取数组中的第一个元素 76 ，scores[2] 就可以取到第三个元素 92 啦！

5.2 如何使用 Java 中的数组
Java 中操作数组只需要四个步骤：

1、 声明数组

语法：  数据类型[ ] 数组名；

或者   数据类型 数组名[ ]；

其中，数组名可以是任意合法的变量名，如：

2、 分配空间

简单地说，就是指定数组中最多可存储多少个元素

语法：  数组名 = new  数据类型 [ 数组长度 ];

其中，数组长度就是数组中能存放元素的个数，如：

话说，我们也可以将上面的两个步骤合并，在声明数组的同时为它分配空间，如：

3、 赋值

分配空间后就可以向数组中放数据了，数组中元素都是通过下标来访问的，例如向 scores 数组中存放学生成绩        

4、 处理数组中数据

我们可以对赋值后的数组进行操作和处理，如获取并输出数组中元素的值

在 Java 中还提供了另外一种直接创建数组的方式，它将声明数组、分配空间和赋值合并完成，如

它等价于：

5.3 使用循环操作 Java 中的数组
实际开发中我们经常使用循环控制数组成员的操作。如：

其中，  数组名.length  用于获取数组的长度

需要注意的“小毛病”：

1、 数组下标从 0 开始。因此 scores[3] ，表示数组中的第 4 个元素，而并非第 3 个元素

2、 数组下标的范围是 0 至 数组长度-1 ，如果越界访问，就会报错。如：

运行时会报如下错误： 

上面错误信息的意思是数组下标超过范围，即数组访问越界。在上面的代码中创建一个长度为 2 的数组，因此数组下标范围是 0 到 1 ，而程序中下标出现了 2 ，即 scores[2] ，超过了范围，造成数组访问越界。