【说明】以下内容，选取于网上搜索进行的排版。如有冲突，请联系作者删除。

一、第一个Hello World程序

1.1 开发工具介绍

• eclipse

• IntelliJ IDEA 

1.2 案例开发步骤

• 首先定义一个类class 类名

• 在类定义后加上一对大括号{}

• 在大括号中间添加一个主(main)方法/函数public static void main(String [] args){ }

• 在主方法的大括号中间添加一行输出语句System.out.println(“hello world”);

• 完整源码

public class HelloWorld {
    public static void main(String [] args) {
        System.out.println(“Hello World”);
    }
}

1.3 程序解析

• 首先编写java源代码程序，扩展名.java

• 在命令行模式中，输入javac命令对源代码进行编译，生成字节码文件javac  源文件名.java

• 编译完成后，如果没有报错信息，输入java命令对class字节码文件进行解释运行,执行时不需要添加.class扩展名java HelloWorld

1.4 常见错误

• 文件扩展名隐藏导致编译失败

• class写错 Class claas…

• 类名格式有问题 暂时全部使用英文

• 类名后面的大括号匹配不正确

• main方法格式错误 public static void main(String [] args){ }

• main方法大括号缺失

• 打印语句拼写错误 System.out.println(“”);

引号使用错误，使用成中文全角引号

二、关键字，标识符，注释

2.1 关键字

• 关键字概述被Java语言赋予特定含义的单词

• 词关键字特点组成关键字的字母全部小写

• 关键字注意事项goto和const作为保留字存在,目前并不使用类似Notepad++，eclipse，IntelliJ IDEA开发工具,针对关键字有特殊的颜色标记，非常直观

2.1.1 常见关键字

用于定义数据类型的关键字
class	interface	byte	short	int
long	float	double	char	boolean
void
用于定义数据类型值的关键字
true	false	null
用于定义流程控制的关键字
if	else	switch	case	default
while	do	for	break	continue
return

用于定义访问权限修饰符的关键字
private	protected	public
用于定义类，函数，变量修饰符的关键字
abstract	final	static	synchronized
用于定义类与类之间关系的关键字
extends	implements
用于定义建立实例及引用实例，判断实例的关键字
new	this	super	instanceof
用于异常处理的关键字
try	catch	finally	throw	throws
用于包的关键字
package	import
其他修饰符关键字
native	strictfp	transient	volatile	assert

2.2 标识符

• 标识符概述就是给类,接口,方法,变量等起名字时使用的字符序列

• 组成规则

  • 英文大小写字母

  • 数字字符

  • $和_

• 注意事项

  • 不能以数字开头

  • 不能是Java中的关键字

  • 区分大小写

• 包(其实就是文件夹,用于解决相同类名问题)单级和多级分别举例

function 功能包

function.util 功能公共功能包

• 类或者接口一个单词和和多个单词分别举例

Hello

class HelloWorld 类的首字母是大写的

interface IHello

helloWorld 变量首字母是小写的

• 方法和变量一个单词和和多个单词分别举例

• 常量一个单词和和多个单词分别举例

常量所有字母都是大写的，多个单词直接使用"_"连接

NAME = “Wesky”

PERSON_NAME = "Wesky";

2.3 注释

2.3.1 注释概述

• 注释是一个程序员必须要具有的良好的编程习惯。

• 初学者编写程序可以养成习惯：先写注释再写代码。

• 将自己的思想通过注释先整理出来，再用代码去体现。

• 因为代码仅仅是思想的一种体现形式而已。

2.3.2 Java中注释分类格式

• 单行注释格式： // 注释文字

• 多行注释

格式： /*  注释文字  */
/*
多行注释
多行注释
多行注释
多行注释
*/

• 文档注释

格式：/** 注释文字 */
/**
  *  文档注释
  *
  *
  */

三、常量

3.1 常量概述

在程序执行的过程中其值不可以发生改变

变量： int a = 10 a = 20 （√）

常量: a = 10 a = 20 (×)

3.2 Java中常量分类

字面值常量​ 自定义常量

3.3 常见常量形式

• 字符串常量 用双引号括起来的内容  "Gerry"

• 整数常量 所有整数122 ,  23

• 小数常量 所有小数12.56,  36.78

• 字符常量 用单引号括起来的内容‘a’,’A’,’0’

• 布尔常量 较为特有，只有true和false

• 空常量 null(数组部分讲解)

3.3.1 整数常量提供了4种表现形式

3.3.1.1 进制概述 1~9 = 10

进制：就是进位制，是人们规定的一种进位方法。 对于任何一种进制--X进制，就表示某一位置上的数运算时是逢X进一位。二进制就是逢二进一，八进制是逢八进一，十进制是逢十进一，十六进制是逢十六进一。 

• 二进制 二进制的2 => 10 

• 八进制 八进制的8 = >10

• 十进制 十进制的10 = > 10

• 十六进制 十六进制的16 = > 10

3.3.1.2 不同进制的数据组成

• 二进制 由0,1组成。以0b开头

• 八进制 由0,1,…7组成。以0开头

• 十进制 由0,1,…9组成。整数默认是十进制的

• 十六进制由0,1,…9,a,b,c,d,e,f(大小写均可)。以0x开头

3.3.1.3 进制转换

• 其他进制到十进制通过十进制推出结论把0b100, 0100, 0x100转换成十进制

• 十进制到其他进制通过十进制推出结论把47分别表示成二进制，八进制，十六进制

3.3.1.4 进制快速转换

• 十进制和二进制的快速转换8421码100转成二进制101101转成十进制

• 二进制和八进制，十六进制如何转换

• 以十进制作为桥梁

• 二进制到八进制 3位组合100110

• 二进制到十六进制 4位组合100110

3.3.1.5 有符号数据表示法

• 在计算机内，有符号数有3种表示法：原码、反码和补码。所有数据的运算都是采用补码进行的。

• 原码就是二进制定点表示法，即最高位为符号位，“0”表示正，“1”表示负，其余位表示数值的大小。

• 反码正数的反码与其原码相同；负数的反码是对其原码逐位取反，但符号位除外。

• 补码正数的补码与其原码相同；负数的补码是在其反码的末位加1。

总结：

十进制变二进制：原码--反码--加一（补码）；

二进制变十进制：减一--反码--原码。

四、变量和数据类型

4.1 变量

4.1.1 变量概述

在程序执行的过程中，在某个范围内其值可以发生改变的量

4.1.2 变量定义格式

数据类型 变量名 = 初始化值;

注意：格式是固定的，记住格式，以不变应万变

总结：1:从本质上讲，变量其实是内存中的一小块区域，使用变量名来访问这块区域，因此，每一个变量使用前必须要先申请（声明），然后必须进行赋值（填充内容），才能使用。2:为什么要定义变量呢 用来不断的存放同一类型的常量，并可以重复使用

int number = 100;

number = 20;

number =1;

4.2 数据类型

4.2.1 数据类型概述

Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间

4.2.2 Java数据类型种类

4.2.3 数据类型占用的存储空间及默认值

注意： Java中提到的整数都是int类型，提到的小数都是double类型。

4.2.4 注意事项

• 作用域 变量定义在哪一级大括号中，哪个大括号的范围就是这个变量的作用域。相同的作用域中不能定义两个同名变量。

• 初始化值没有初始化值不能直接使用

• 在一行上建议只定义一个变量可以定义多个，但是不建议

4.2.5 数据类型的转换

4.2.5.1 默认转换（从小的数据类型到大的数据类型）

• byte，short，char-int-long-float-double

• byte，short，char相互之间不转换，它们参与运算首先转换为int

4.2.5.2 强制转换（从大的数据类型到小的数据类型）

格式： 目标数据类型 变量 = （目标数据类型）被转换的数据

五、运算符

5.1 算术运算符

操作符	描述	例子
+	加法 - 相加运算符两侧的值	A + B 等于 30
-	减法 - 左操作数减去右操作数	A – B 等于 -10
*	乘法 - 相乘操作符两侧的值	A * B等于200
/ 取商	除法 - 左操作数除以右操作数	B / A等于2
％ 取余数	取余 - 左操作数除以右操作数的余数	B%A等于0
++	自增: 操作数的值增加1	B++ 或 ++B 等于 21
--	自减: 操作数的值减少1	B-- 或 --B 等于 19

5.2 赋值运算符

操作符	描述	例子
=	简单的赋值运算符，将右操作数的值赋给左侧操作数	C = A + B将把A + B得到的值赋给C
+ =	加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数	C + = A等价于C = C + A
- =	减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数	C - = A等价于C = C - A
* =	乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数	C * = A等价于C = C * A
/ =	除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数	C / = A，C 与 A 同类型时等价于 C = C / A
（％）=	取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数	C％= A等价于C = C％A
<< =	左移位赋值运算符	C << = 2等价于C = C << 2
>> =	右移位赋值运算符	C >> = 2等价于C = C >> 2
＆=	按位与赋值运算符	C＆= 2等价于C = C＆2
^ =	按位异或赋值操作符	C ^ = 2等价于C = C ^ 2
| =	按位或赋值操作符	C | = 2等价于C = C | 2

5.3 比较运算符 (true 代表真，false 代表假)

运算符	描述	例子
==	检查如果两个操作数的值是否相等，如果相等则条件为真。	（A == B）为假。
!=	检查如果两个操作数的值是否相等，如果值不相等则条件为真。	（A != B) 为真。
>	检查左操作数的值是否大于右操作数的值，如果是那么条件为真。	（A> B）为假。
<	检查左操作数的值是否小于右操作数的值，如果是那么条件为真。	（A <B）为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。	（A> = B）为假。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。	（A <= B）为真。

5.4 逻辑运算符

操作符	描述	例子
&&	称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。	（A && B）为假。
| |	称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。	（A | | B）为真。
！	称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。	!（A && B）为真。

5.5 位运算符

操作符	描述	例子
＆	如果相对应位都是1，则结果为1，否则为0	（A＆B），得到12，即0000 1100
|	如果相对应位都是 0，则结果为 0，否则为 1	（A | B）得到61，即 0011 1101
^	如果相对应位值相同，则结果为0，否则为1	（A ^ B）得到49，即 0011 0001
〜	按位取反运算符翻转操作数的每一位，即0变成1，1变成0。	（〜A）得到-61，即1100 0011
<<	按位左移运算符。左操作数按位左移右操作数指定的位数。	A << 2得到240，即 1111 0000
>>	按位右移运算符。左操作数按位右移右操作数指定的位数。	A >> 2得到15即 1111
>>>	按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。	A>>>2得到15即0000 1111

5.6 三目运算符

• 格式 (关系表达式)?表达式1：表达式2；

  • 如果条件为true，运算后的结果是表达式1；

  • 如果条件为false，运算后的结果是表达式2；

5.6.2 接收键盘输入数据

• 导入Scanner包 import java.util.Scanner;

• 创建对象 Scanner scanner = new Scanner(System.in);

• 接收数据： int data = scanner.netInt();

5.7 测试代码

public class Test {
    public static void main(String[] args) {
    	int num1 = 10;
	int num2 = 20;
	/ 算术运算符 /
	System.out.println("num1 + num2 = "+ (num1 + num2));
	System.out.println("num1 - num2 = "+ (num1 - num2));
	System.out.println("num1 * num2 = "+ (num1 * num2));
	System.out.println("num1 / num2 = "+ (num1 / num2));
	System.out.println("num1 % num2 = "+ (num1 % num2));
	// ++ 在变量的前面，先计算结果后再输出
 	// ++ 在变量的后面，先输出在计算
	System.out.println("num1++ = "+ (num1++)); // 10
	System.out.println("++num1 = "+ (++num1)); // 12
	// -- 在变量的前面，先计算结果后再输出
 	// -- 在变量的后面，先输出在计算
	System.out.println("num2-- = "+ (num2--)); // 20
	System.out.println("--num2 = "+ (--num2)); // 18
	/ 赋值运算符 /
	// 赋值符:"="
	int num3 = 25;
	System.out.println("num3+=4 =>"+(num3=num3+4)); // 29
	System.out.println("num3 -=10 =>"+(num3=num3-10)); // 19
	System.out.println("num3 *=2 =>"+(num3=num3*2)); // 38
	System.out.println("num3 /=4 =>"+(num3=num3/4)); // 9
	System.out.println("num3 %=2 =>"+(num3=num3%2)); // 1
	System.out.println("num3 <<= 2 =>"+(num3=num3 << 2)); // 0001 => 0100 => 4
	System.out.println("num3 >>= 2 =>"+(num3=num3 >> 2)); // 0100 => 0001 => 1
	/ 比较运算符 /
	num1 = 60;
	num2 = 60;
	System.out.println("num1="+num1 + ", num2 =" + num2);
	System.out.println("num1 == num2 =>" +(num1 == num2));
	System.out.println("num1 != num2 =>" +(num1 != num2));
	System.out.println("num1 > num2 =>" +(num1 > num2));
	System.out.println("num1 < num2 =>" +(num1 < num2));
	System.out.println("num1 >= num2 =>" +(num1 >= num2));
	System.out.println("num1 <= num2 =>" +(num1 <= num2));
	/ 逻辑运算符 /
	// 总结：
	// 1、逻辑与： && 连接的每一个比较运算结果为true，结果才是真(true)
	// 2、逻辑或： || 连接的每一个比较运算的结果中有一个为true，结果就是真(true)
	// 3、逻辑非:  ! 将整过比较运算的结果取反,就是运算结果为false，取反就是真(true)
	System.out.println("num1 <= num2  && num1 < num2=>" +(num1 <= num2  && num1 < num2));
	System.out.println("num1 <= num2  || num1 < num2=>" +(num1 <= num2  || num1 < num2));
	System.out.println("num1 <= num2  && num1 < num2=>" +(!(num1 <= num2  && num1 < num2)));
	/// 位移运算 
	// &: 相对应位数为1，才为1，否则就是0
	//  | : 相对应位数是0才为0，否则都是1
	// ^: 相对应位数是 0 1 或者 1 0 才是1，否则就是0
	// ~: 对应位数的0变1,1变0
	// <<: 向左移动实际就是在原有的数基础上乘以2多次幂的倍数, 7 << 3 => 7x 2 ^ 3 = 56
	// >>: 向右移动实际就是在原理数的基础上除以2多少次幂的倍数 7 / (2^2) = 1
	// >>>： 最高位的符号位，0表示正数，1代表负数，
	// >>   1000 1111   => 1000 0011
	// >>> 1000 1111 =>   0010 0011
	int a = 5;
	int b = 7;
	int c = -9;
	System.out.println("a & b =>" +(a & b)); // 
	System.out.println("a  |  b =>" +(a | b));
	System.out.println("a ^ b =>" +(a^b));
	System.out.println("~a=>" +(~a));
	System.out.println("b << 3=>" +(b << 3));
	System.out.println("b  >> 2=>" +(b >> 2));
	System.out.println("c >>> 2=>" +(c >>> 2));
	// 三目运算符 /
	a = 10;
	System.out.println(a > 5 ? "a大于5" :"a小于5");
    }
}

七、流程控制语句

7.1 概述

在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。也就是说程序的流程对运行结果有直接的影响。所以，我们必须清楚每条语句的执行流程。而且，很多时候我们要通过控制语句的执行顺序来实现我们要完成的功能。

7.2 流程控制语句分类

• 顺序结构

• 选择结构

• 循环结构

7.2.1 顺序结构概述

是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。总的来说：写在前面的先执行，写在后面的后执行

7.2.1.1 顺序结构图

7.2.2 选择结构

• 也被称为分支结构。

• 选择结构有特定的语法规则，代码要执行具体的逻辑运算进行判断，逻辑运算的结果有两个，所以产生选择，按照不同的选择执行不同的代码。

• Java语言提供了两种选择结构语句if语句switch语句

7.2.2.1 if语句

if语句有三种格式

if语句 第一种格式：

if(关系表达式) {

语句体; 

}

• 执行流程

  • 首先判断关系表达式看其结果是true还是false

  • 如果是true就执行语句体

  • 如果是false就不执行语句体

if语句 第二种格式

if(关系表达式) {

语句体1;

}else {

语句体2;

}

• 执行流程

  • 首先判断关系表达式看其结果是true还是false

  • 如果是true就执行语句体1

  • 如果是false就执行语句体2

• 我们前面讲解过三元运算符，它根据比较判断后，给出的也是两个结果，所以，这种情况和if语句的第二种格式很相似，他们在某些情况下应该是可以相互转换的。

• if语句第二种格式和三元运算符

  • 三元运算符的操作都可以使用if语句改进，反之不成立

  • 什么时候不成立呢?

    • 当if语句控制的语句体是一条输出语句的时候，就不成立。因为三元运算符是一个运算符，必须要求有一个结果返回。而输出语句却不能作为一个返回结果。

if语句 第三种格式

if(关系表达式1) {

语句体1;

}else  if (关系表达式2) {

语句体2;

}    

…

else {

语句体n+1;

}

• 执行流程

  • 首先判断关系表达式1看其结果是true还是false

  • 如果是true就执行语句体1

  • 如果是false就继续判断关系表达式2看其结果是true还是false

  • 如果是true就执行语句体2

  • 如果是false就继续判断关系表达式…看其结果是true还是false…

  • 如果没有任何关系表达式为true，就执行语句体n+1。

7.2.2.2 switch语句

JDK8及以前写法

switch(表达式) {

      case 值1：

语句体1;

break;

  case 值2：

语句体2;

break;

    …   

default：

语句体n+1;

break;   

 }

JDK14以及以上的写法

不带返回值

switch(表达式) { 

   case 值1，值2，值3 -> 语句体1; 

   case 值4，值5，值6 -> 语句体2; 

    case 值7 -> 语句体3;

}

通过yield返回一个新值

String result = switch(表达式) { 

   case 值1，值2，值3 -> 语句体1; yield 返回值1; 

   case 值4，值5，值6 -> 语句体2; yield 返回值2;  

   case 值7 -> 语句体3; yield 返回值3;

}

7.3 循环结构

7.3.1 概述

循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。

7.3.2 循环语句的组成

• 初始化语句：一条或者多条语句，用这些语句完成一些初始化操作。

• 判断条件语句：这是一个boolean 表达式，这个表达式能决定是否执行循环体。

• 循环体语句：这个部分是循环体语句，也就是我们要多次做的事情。

• 控制条件语句：这个部分在一次循环体结束后，在下一次循环判断条件执行前执行。通过用于控制循环条件中的变量，使得循环在合适的时候结束。

7.3.3 for循环语句格式

for(初始化语句;判断条件语句;控制条件语句) {          循环体语句;    }

• 执行流程

  • A:执行初始化语句

  • B:执行判断条件语句，看其结果是true还是false如果是false，循环结束。如果是true，继续执行。

  • C:执行循环体语句

  • D:执行控制条件语句

  • E:回到B继续

7.3.4 循环流程图

7.4 while循环

• 基本格式

while(判断条件语句) {

      循环体语句; 

}

• 扩展格式

初始化语句;

while(判断条件语句) { 

     循环体语句;   

     控制条件语句; 

 }

7.4.1 while循环流程

7.4.2 do...while循环

• 基本格式

do {      

循环体语句;

}while(判断条件语句);

• 扩展格式

初始化语句;

do {      

循环体语句;      

控制条件语句;

 } while(判断条件语句);

7.4.2.1 do...while循环流程图

7.5 跳转控制语句

前面我们已经说过了，Java中的goto是保留字，目前不能使用。虽然没有goto语句可以增强程序的安全性，但是也带来很多不便，比如说，我想在某个循环知道到某一步的时候就结束，现在就做不了这件事情。为了弥补这个缺陷，Java就提供了break，continue和return来实现控制语句的跳转和中断。

• break 中断

• continue 继续

• return 返回 

7.5.1 跳转控制语句(break)

7.5.1.1 break的使用场景

• 在选择结构switch语句中

• 在循环语句中

离开使用场景的存在是没有意义的

7.5.1.2 break的作用

• 跳出单层循环

• 跳出多层循环

  • 带标签的跳出

  • 格式：标签名: 循环语句

  • 标签名要符合Java的命名规则

7.5.2 跳转控制语句(continue)

7.5.2.1 continue的使用场景

• 在循环语句中

• 离开使用场景的存在是没有意义的

7.5.2.2 continue的作用

• 单层循环对比break，然后总结两个的区别

  • break 退出当前循环

  • continue 退出本次循环

7.5.3 跳转控制语句(return)

return关键字不是为了跳转出循环体，更常用的功能是结束一个方法，也就是退出一个方法。跳转到上层调用的方法。这个在方法的使用那里会有详细的讲解。

八、数组

8.1 创建数组

// 创建数组： 数据类型 数组名[] = new 数据类型[长度];
int[] numbers = new int[5];
// 赋值 通过下标
numbers[2] = 100;
numbers[1] = 20;
// 获取数组中指定元素的值  数组名称[index]   index：下标 0 ~ 数组长度-1
int firstElement = numbers[1];
// 输出快捷键  sout
System.out.println(firstElement);

// 静态创建： 创建数组同事为元素赋值
int[] nums = new int[]{11,3,2,32,42};
// 简单写法
int[] ages  = {32,32,52,52,43};
//int [] ages1 = null;
//ages1 = {1,2,33,2};
// 通过length获取数组元素个数
System.out.println(nums.length);

8.2 遍历数组

// for循环快捷键 nums.fori + enter
for (int i = 0; i < nums.length; i++) {
    System.out.println(nums[i]);
}
System.out.println("========================");
// foreach  numbers.for + + enter
for (int number : numbers) {
    System.out.println(number);
}

8.3 二维数组

// 二维数组
int[][]  table = new int[3][3];
table[0][0] = 10;
table[0][1] = 20;
table[0][2] = 30;
// 看静态初始化
int[][] table1 = {{1,2,3},{2,3,4},{2,2}};

8.4 二维数组遍历

// 二维数组的遍历
for (int[] els : table1) {
    for (int el : els) {
        System.out.print(el+"\t");
    }
    System.out.println();
}