一、程序注释
1 // 表示单行注释
2 /* */ 表示多行注释
二、HelloWorld说明
// 第一行的第三个单词必须和所在的文件名称完全一样，大小写也要一样
// public class 后面代表定义一个类的名称，类是Java当中所有源代码的基本组织单位
public class HelloWorld {
// 第二行的内容是万年不变的固定写法，代表main方法
// 这一行代表程序执行的起点
public static void main(String [] args ){
// 第三行代表打印输出语句 (其实就是屏幕显示)
System.out.println("Hello, World!!!");
// 希望显示什么东西，就在小括当中填写什么内容
}
}
三、关键字的概念与特征
1 关键字的特点：
① 完全小写的字母
② 有特殊颜色（在增强版的记事本当中【例如Notepad++】）
四、标识符的概念与规则
1 标识符：
是指在程序中，我们自己定义的内容。比如类的名字、方法的名字和变量的名字等等，都是标识符。
2 命名规则：硬性要求
① 标识符可以包含英文字母26个（区分大小写）、0-9数字、$（美元符号）和 _（下划线）
② 标识符不能以数字开头
③ 标识符不能是关键字
3 命名规范：软性建议
① 类名规范：首字母大写，后面每个单词首字母大写（大驼峰式）HelloWorld
② 变量名规范：首字母小写，后面每个单词首字母>大写（小驼峰式）helloWorld
③ 方法名规范：同变量名。
五、常量的概念与分类
1 常量：
在程序运行期间，固定不变的量
2 常量的分类：
① 字符串常量：凡是双引号引起来的部分，叫做字符串常量。例如：“abc”，“Hello”，“123”
② 整数常量：直接写上的数字，没有小数点。例如：100、200、0
③ 浮点数常量：直接写上的数字。例如：2.5、-3.14
④ 字符常量：凡是单引号引起来的单个字符，就做字符常量。例如‘A’、‘中’，单引号字符有且仅有一个字符
⑤ 布尔常量：只有量中取值。 true、false
⑥ 空常量：null 。代表没有任何数据
public class Demo01Const {
public static void main (String [] args) {
// 字符串常量
System.out.println("ABC");
System.out.println("");// 字符串两双引号中间的内容为空
System.out.println("XYZ");
// 整数常量
System.out.println(30);
System.out.println(-500);
// 浮点数常量（小数）
System.out.println(3.14);
System.out.println(-2.5);
// 字符常量
System.out.println('A');
System.out.println('6');
// System.out.println('');// 两单引号中间必须有且仅有一个字符，没有不行。
// System.out.println('AB');// 两个单引号重金必须有且仅有一个字符，有两不行。
// 布尔常量
System.out.println(true);
System.out.println(false);
// 空常量。 空常量不能直接用来打印输出
//System.out.println.(null);
}
}
六、数据类型分类
1 基本数据类型
整数型 byte short int long
浮点型 float double
字符型 char
布尔型 boolean
2 引用类型
字符串、数组、类、接口、Lambda
/*
注意事项：
1.字符串不是基本类型，而是引用类型。
2.浮点型可能只是一个近似值，并非精确的值。
3.数据范围与字节数不一定相关，例如：float数据范围比long更加广泛，但是float是4字节，long是8字节
4.浮点数当中默认类型是double，如果一定要使用float类型，需要加上一个后缀F。
如果是整数，默认为int类型，如果一定要使用long类型，需要加上一个后缀L。推荐使用大写字母后缀。
*/
七、变量的概念与定义
1 变量
程序运行期间，内容可以发生改变的量。
/*
创建一个变量并且使用的格式：
数据类型 变量名称；// 创建了一个变量
变量名称 = 数据值；// 赋值，将右边的数据值，复制交给左边的变量
一步到位的格式：
数据类型 变量名称 = 数据值；// 在创建一个变量的同时，立放入指定的数据值。
*/
public class Demo02Variable {
public static void main(String [] args) {
// 创建一个变量
// 格式：数据类型 变量名称；
int num1;
// 向变量当中存入一个数据
// 格式：变量名称 = 数据值
num1 = 10;
// 当打印数据变量名称的时候，显示出来是变量的内容
System.out.println(num1);
//改变变量当中本来的数字，变成新的数字
num1 = 20;
System.out.println(num1); // 20
// 使用一步到位的格式来变量
// 格式：数据类型 变量名称 = 数据值；
int num2 = 25;
System.out.println(num2); // 25
num2 = 35;
System.out.println(num2); // 35
System.out.println("============");
byte num3 = 30; // 注意：右边数值的范围不能超过左侧数据类型的取值范围
System.out.println(num3);
// byte num4 = 400; // 右侧超出byte数据范围，错误！
short num5 = 50;
System.out.println(num5); // 50
long num6 = 3000000000L;
System.out.println(num6);
float num7 = 2.5F;
System.out.println(num7); // 2.5
double num8 = 1.2;
System.out.println(num8); // 1.2
char zifu1 = 'A';
System.out.println(zifu1); // A
zifu1 = '中';
System.out.println(zifu1);
boolean var1 = true;
System.out.println(var1); // true
var1 = false;
System.out.println(var1); // false
// 将一个变量是的数据内容，赋值交给另一个变量
// 右侧的变量名称var1已经存在，里面装的是false布尔值
// 将右侧变量里面的false值，向左交给var2变量进行存储
boolean var2 = var1;
System.out.println(var2); // false
}
}
2 变量的注意事项
1.如果创建多个变量，那么变量之间的名称不可以重复。
2.对于float和long类型来说，字母后缀F和L不要丢掉。
3.如果使用byte或者short类型的变量，那么右侧数据值不能超过左侧类型的范围。
4.没有进行赋值的变量，不能直接使用；一定要赋值之后，才能使用。
5.变量使用不能超过作用域的范围。
【作用域】：从定义变量的一行开始，一直到直接所属的大括结束为止。
6.可以通过一个语句来创建多个变量，但是一般情况不推荐这么写。
public class Demo03VariableNotice {
public static void main(String [] args) {
int num1 = 10; // 创建了一个新的变量，名叫num1
// int num1 = 20; // 又创建了另一个新的变量，名字也叫num1，错误！
int num2 = 20; // 20
int num3;
num3 = 30;
int num4; // 定义了一个变量，但是没有进行赋值
// System.out.println(num4); // 未赋值的变量，直接使用打印输出就是错误的。
// System.out.println(num5); // 在创建变量之前，不能使用这个变量 必须要先创建再使用变量
int num5 = 500;
System.out.println(num5); // 500
{
int num6 = 60;
System.out.println(num6);
}
// System.out.println(num6); // 已经超出了大括的范围，超出了作用域，变量不能再使用了
// 同时创建三个全都是int类型的变量
int a,b,c;
// 各自分别赋值
a = 10;
b = 20;
c = 30;
System.out.println(a); // 10
System.out.println(b); // 20
System.out.println(c); // 30
// 同时创建三个int变量，并且同时各自赋值。不推荐这样使用赋值方式
int x = 100, y = 200, z = 300;
System.out.println(x); // 100
System.out.println(y); // 200
System.out.println(z); // 300
}
}
八、数据类型转换
1 自动类型转换（隐式）
特点：代码不需要进行特殊处理，自动完成。
规则：数据范围从小到大
public class Demo01DataType {
public static void main (String [] args) {
System.out.println(1024); // 这就是一个整数，默认就是int类型
System.out.println(3.14); // 这就是一个浮点数，默认就是double类型
// 左边是long 类型，右边是默认的int类型，左右不一样
// 一个等号代表赋值，将右侧的int常量，交给左侧的long变量进行存储
// int --> long,符合了数据范围从小到大的要求
// 这一行代码发生了自动类型转换
long num1 = 100;
System.out.println(num1); // 100
// 左边是double类型，右边是float类型，左右不一样
// float --> double，符合从小到大的规则
// 也发生了自动转换
double num2 = 2.5F;
System.out.println(num2);
// 左边是float类型，右边是long类型，左右不一样
// long --> float，范围是float更大一些，符合从小到大的规则(float小数部位包含了N多数据故float的范围比long大)
// 也发生了自动转换
float num3 = 30L;
System.out.println(num3); // 30.0
}
}
2 强制类型转换
特点：代码需要进行特殊的格式处理，不能自动完成
格式：范围小的类型 范围小的变量名 = （范围小的类型）原本范围大的数据
3 注意事项
强制类型转换一般不推荐使用，因为有可能发生精度损失，数据溢出。
byte/short/char这三种类型都可以发生数学运算，例如加法 “+”
byte/short/char这三种类型在运算的时候，都会被首先提升称为int类型，然后再计算
boolean类型不能发生数据类型转换
public class Demo02DataType {
public static void main (String [] args) {
// 左边是int类型，右边是long类型，不一样
// long --> int, 不是从小到大
// 不能发生自动类型转换
// 格式：范围小的类型 范围小的变量 = （范围小的类型）原本范围大的数据
int num = (int)100L;
System.out.println(num);
// int num1 = 200L; // 不兼容的类型: 从long转 换到int可能会有损失精度
// long强制转换为int 类型
int num2 = (int)6000000000L; // 数据出错 1705032704
System.out.println(num2);
// double --> int，强制类型转换
int num3 = (int)3.99;
System.out.println(num3); // 这不是四舍五入，所有的小数位都会被舍弃
char zifu1 = 'A'; // 这是一个字符型变量，里面是大写字母A
System.out.println(zifu1 + 1); // 66 也就是大写字母 A 被当作65进行处理
// 计算机的底层会用一个数字（二进制）来代表字符 A，就是65
// 一旦char类型进行数字运算，那么字符就会按照一定的规则翻译称为一个数字
byte num4 = 40; // 注意！右侧的数值大小不能超过左侧的类型范围
byte num5 = 50;
// byte + byte --> int + int --> int
int result1 = num4 + num5; //
System.out.println(result1);
short num6 = 60;
// byte + short --> int + int --> int
// int 强制转换为short：注意必须保证逻辑上真实大小本来就没有超过short范围，否则会发生数据溢出
short result2 = (short)(num4 + num6);
System.out.println(result2);
byte result3 = (byte)(num4 + num6);
System.out.println(result3);
}
}
ASCII码对照表
https://www.sojson.com/asciitable.html
/*
数字和字符的对照关系表（编码表）
ASCII码：American Standard Code for Information Interchange, 美国信息交换标准代码
Unicode码表：万国码。也是数字和字符的对照关系，从0-127部分和ASCII完全一样，但是从128开始包含有更多的字符
48 - '0'
65 - 'A'
97 - 'a'
*/
public class Demo03DataTypeChar {
public static void main(String [] args) {
char zifu = '1';
System.out.println(zifu);
char zifu2 = 'A'; // 其实底层保存的是65数字
char zifu3 = 'c';
// 左侧是int类型，右边是char类型。
// char --> int，确实是从小到大
// 发生了自动类型转换
int num = zifu3;
System.out.println(num); // 99
char zifu4 = '中'; //正确
System.out.println(zifu4); // 中
System.out.println(zifu4 + 0); // 20013
}
}
九、运算符
1.1 算数运算符
运算符：进行特定操作的符号。例如：+
表达式：用运算符连的式子叫做表达式。例 20 + 5；a + b
四则运算：加：+ ; 减：- ; 乘：* ; 除：/ ; 取模（取余数）：%
/*
对于一个整数的表达式来，除法用的是整除，整数除以整数，结果仍然是整数，只看商，不看余数
只有对于整数的除法来，取模运算符才有余数的意义。
注意事项：
一旦运算当中有不同类型的数据，那么结果将会是数据类型范围大的那种
*/
public class Demo04Operator {
public static void main(String [] args) {
// 两个常量之间可以进行数学运算
System.out.println(20 + 30);
// 两个变量之间也可以进行数学运算
int a = 20;
int b = 30;
System.out.println(a + b); // -10
// 变量和常量之间可以混合使用
System.out.println(a * 10); // 200
int x = 10;
int y = 3;
int result1 = x / y;
System.out.println(result1); // 3
int result2 = x % y;
System.out.println(result2); // 余数：取模 1
// int + double --> double + double --> double
double result3 = x + 2.5;
System.out.println(result3); // 12.5
}
}
1.2 四则运算当中的加号“+”有常见的三种用法：
- 对于数值来，那就是加法
- 对于字符char类型来，在计算之前，char会被提升称为int，然后再计算。
- 对于字符串String（首字母大写，并不是关键字）来说，加号代表字符串连接操作。
1.3自增自减运算符的用法：
自增运算符：++
自减运算符：--
基本含义：让一个变量涨一个数字1，或者让一个变量降一个数字1
使用格式：写在变量名称之前，或者写在变量名称之后，例如：++num，也可以num++
使用方式：
1.单独使用：不和其他任何操作混合，自己独立成为一个步骤。
2.混合使用：和其他操作混合，例如与赋值混合，或者与打印操作混合等等
使用区别：
1.在单独使用的时候，前++和后++没有任何区别，也就是：++num；和num++；是完全一样的。
2.在混合的时候，有【重大区别】
A.如果是【前++】，那么变量【立刻马上 + 1】，然后拿着结果进行使用。【先加后用】
B.如果是【后++】，那么首先使用变量本来数值，【然后再变量+1】。【先用后加】
注意事项：
只有变量才能使用自增、自减运算符。常量不可发生改变，所以不能用。
自增自减运算格式及使用方法均一致。
public class Demo06Operator {
public static void main(String [] args) {
int num1 = 10;
System.out.println(num1++); // 10
System.out.println(num1); // 11
System.out.println(++num1); // 12
System.out.println("===================");
// 与打印操作
int num2 = 20;
System.out.println(++num2); // 21
System.out.println(num2); // 21
System.out.println("===================");
int num3 = 30;
// 混合使用，后++，首先使用变量本来的30，然后再让变量+1得到31；
System.out.println(num3++); // 30
System.out.println(num3); // 31
System.out.println("===================");
int num4 = 40;
// 和赋值操作混合
int result1 = --num4;
System.out.println(result1); // 39
System.out.println(num4); // 39
System.out.println("===================");
int num5 = 50;
// 混合使用，后--，首先把本来的数字50交给result2，然后再-1变成49
int result2 = num5--;
System.out.println(result2); // 50
System.out.println(num5); //49
System.out.println("===================");
int x = 10;
int y = 20;
int result3 = ++x + y--;
System.out.println(result3); // 31
System.out.println(x); // 11
System.out.println(y); // 19
}
}
1.4 赋值运算符
赋值运算符分为：
基本赋值运算符：就是一个等号"="，代表将右侧的数据交给左侧的变量。
复合赋值运算符：（ / 求模，% 取余）
+= a += 1 相当于 a = a + 1
-= b -= 4 相当于 b = b - 4
*= c *= 4 相当于 c = c * 4
/= d /= 4 相当于 d = d / 4
%= e %= 4 相当于 e = e % 4
1.5 比较运算符：
注意事项：
1.比较运算符的结果一定是一个boolean值，成立就是true，不成立就是false
2.如果进行多次判断，不能连着写。
1.6 逻辑运算符：
与（并且） && 全都是true，才是true，否则就是false
或（或者） || 至少一个true，就是true，全都是false，才是false
非（取反） | 本来是true，变成false，本来是false，变成true
与“&&”，或“||”，具有短路效果：如果根据左边已经可以判断得到最终结果，那么右边的代码将不再执行，从而节省一定的性能
注意事项：
1.逻辑运算符只能用于boolean值
2.与、或需要左右各自有一个boolean值，但是取反只要有唯一的一个boolean值即可。
3.与、或两运算符，如果有多个条件，可以连。
两个条件：条件A && 条件B
多个条件：条件A && 条件B &&条件C
Tips：
对于1 < x <3 的情况，应该拆成两部分，然后使用与运算符连接起来。
int x = 2;
1 < x && x < 3 ;
public class Demo09Logic{
public static void main (String[] args) {
System.out.println( true && false); // false
System.out.println(3 < 4 && 10 > 5); // true
System.out.println("============");
System.out.println(true || false); // true
System.out.println(true || true); // true
System.out.println(false || false); // false
System.out.println("============");
System.out.println(true); // true
System.out.println(!true); // false
int a = 10;
System.out.println(3 > 4 && ++a < 100); // false
System.out.println(a); // 10 ,由于左侧已判断出结果为false，++a并未执行，所以a的值依旧为10
System.out.println("============");
int b = 20;
System.out.println(3 < 4 || ++b < 100); // true
System.out.println(b); // 20，由于左侧已判断出结果为true ++b并未执行，所以b的值依旧为20
}
}
1.7 三元运算符：
一元运算符：只需要一个数据就可以进行操作的运算符，例如取反|，自增++，自减--
二元运算符：需要两个数据才可以进行操作的运算符，例如加法+，赋值=
三元运算符：需要三个数据才可以进行操作的运算符
格式：
数据类型 变量名称 = 条件判断 ？ 表达式A ：表达式B；
流程：
首先判断条件是否成立;
如果成立为true，那么将表达式A的值赋值给左侧的变量。
如果不成立为false，那么将表达式B的值赋值给左侧的变量。
二者选其一、
注意事项：
1.必须同时保证表达式A 和表达式B都符合左侧数据类型的要求。
2.三元运算符的结果必须被使用。
public class Demo10Operator {
public static void main (String[] args) {
int a = 10;
int b = 20;
// 判断a > b是否成立，如果成立将a的值赋值给max；如果不成立将b的值赋值给max。
int max = a > b ? a:b; // 最大值的变量
System.out.println(max); // 20
ystem.out.println(a > b ? a:b)
}
}
十、方法：
定义一个方法的格式：
public static void 方法名称(){
}
方法名称的命名规则和变量一样，使用小驼峰。
方法体：也就是大括号当中可以包含任意条语句。
注意事项：
1. 方法定义的先后顺序无所谓
2. 方法的定义不能产生嵌套包含关系
3. 方法定义后，不会执行，要进行方法调用
调用：
方法名称（）;
public class Demo11Method {
public static void main(String[] args) {
famer();
seller();
cook();
me();
}
// 我
public static void me() {
System.out.println("吃");
}
// 厨子
public static void cook() {
System.out.println("洗菜");
System.out.println("切菜");
System.out.println("炒菜");
System.out.println("装盘");
}
// 小商贩
public static void seller() {
System.out.println("运输到农贸市场");
System.out.println("抬高价格");
}
// 农民伯伯
public static void famer(){
System.out.println("播种");
System.out.println("浇水");
System.out.println("施肥");
System.out.println("除虫");
System.out.println("收割");
System.out.println("卖给小商贩");
}
}
十一 、 流程：
1.顺序结构
2.选择结构
if (条件) {
...
} else {
...
}
注意事项：
1. 多个case后面的数值不可以重复
2. switch后面小括号当中只能是指定的数据类型
基本数据类型：byte / short / char / int ;
引用数据类型：String 字符串、enum 枚举
3. switch语句格式可以很灵活：前后顺序可以颠倒，而且break语句还可以省略（最好不要省略），对流程没有任何影响，“匹配哪一个case就从哪一个位置向下执行，直到遇到了break或者整体结束为止，遇不到break会向下穿透语句，直至遇到break停止执行语句。”
public class Demo07Switch {
public static void main(String[] args) {
int num = 8;
switch (num) {
case 1 :
System.out.println("Monday");
break;
case 2 :
System.out.println("Tuesday");
break;
case 3 :
System.out.println("Wednesday");
break;
case 4 :
System.out.println("Thursday");
break;
case 5 :
System.out.println("Friday");
break;
case 6 :
System.out.println("Saturday");
break;
case 7 :
System.out.println("Sunday");
break;
default:
System.out.println("数据不合理");
break;
}
}
}
循环语句：
循环结构的基本组成部分，一般可以分成四部分：
1. 初始化语句：在循环开始最初执行，而且只做唯一一次。
2. 条件判断：如果成立，则循环继续；如果不成立，则循环退出。
3. 循环体：重复要做的事情内容，若干行语句。
4. 步进语句：每次循环之后都要进行的扫尾工作，每次循环结束之后都要执行一次。
for循环：
public class Demo09For{
public static void main(String[] args){
for(int i = 1;i <= 10; i++){
System.out.println("我错啦，原谅我吧。" + i );
}
System.out.println("程序停止");
}
}
while循环：
public class Demo10While {
public static void main(String[] args) {
for(int i = 1; i <= 10; i++){
System.out.println("我错啦"+ i);
}
System.out.println("==============");
int i = 1;
while (i <= 10) {
System.out.println("我错啦"+ i);
i++; // 步进语句
}
}
}
do...while...循环：
public class Demo11DoWhile{
public static void main(String[] args){
int i = 1;
do{
System.out.println("我错啦" + i++);
}while(i <= 10);
}
}
练习题：求1~100偶数和
public class Demo12HundredSum{
public static void main(String[] args){
for1();
System.out.println("==========");
while1();
System.out.println("==========");
doWhile1();
}
public static void for1(){
int sum = 0;
for(int i = 1; i <= 100; i++){
if(i % 2 == 0){
sum += i;
}
}
System.out.println("1总和为" + sum);
}
public static void while1(){
int sum = 0;
int i = 1;
while(i <= 100){
if(i % 2 == 0){
sum += i;
}
i++;
}
System.out.println("2总和为" + sum);
}
public static void doWhile1(){
int sum = 0;
int i = 1;
do{
if(i % 2 == 0){
sum += i;
}
i++;
}while(i <= 100);
System.out.println("3总和为" + sum);
}
}
三种循环的区别
1. 如果条件判断从来没有满足过，那么for循环和while循环将会执行0次，但是do-while循环会执行至少一次。
2. for循环的变量在小括号当中定义，只有循环内部才可以使用，while循环和do-while循环的初始化语句本来就在外面。
循环控制语句：
break关键字
1. 可以用在switch语句当中，一旦执行，整个switch语句立刻结束
2. 还可以用在循环语句当中，一旦执行，整个循环语句立刻结束，打断循环
关于循环的选择，一些建议：
凡是次数确定的场景多用for循环；否侧多用while循环。
continue关键字
一旦执行，立刻跳过当前次循环剩余内容，马上开始下一次循环。
public class Demo15Continue{
public static void main(String[] args){
for(int i = 1; i <= 10; i++){
if(i == 4 ){
continue;
}
System.out.println(i + "层到了");
}
}
}
死循环
无法结束的循环，一直执行循环体
嵌套循环
public class Demo17LoopHourAndMiute{
public static void main(String[] args){
for (int hour = 0; hour < 24; hour++){
for(int miute = 0; miute < 60; miute++){
System.out.println(hour + "点" + miute + "分");
}
}
}
}
