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

一、第一个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 常见关键字

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 算术运算符

5.2 赋值运算符

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

5.4 逻辑运算符

5.5 位运算符

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();
}