day0203_基础知识

常量
转义字符
标识符
注释
数据类型
变量
数据类型之间的转换
运算符（算数运算符、赋值运算符、比较运算符、逻辑运算符、位运算符、三目运算符）
选择控制语句
Scanner类和Random类的使用
循环结构（for、while、do-while）
跳转语句 (break、continue)

JDK 和 JRE 的关系

JRE = JVM + Java类库 Java runtime environment

JDK = JRE + 开发工具集 Java development kit

关键字：

具有特殊含义、被保留的、不能随意使用的字符

添加注释：

注释：就是对代码的解释和说明，其目的就是让其他开发者轻松的了解代码，注释是不影响程序的编译和运行的。 Java中的注释通常有三种：

1.单行注释 //

2.多行注释 /* */

3.文档注释 /** */

标识符：

一般是指在程序中，我们自定义的内容比如：类名、方法名、变量名都是标识符

命名规则：（硬性要求）

标识符可以包含英文字母26个（区分大小写、0-9数字、_（下划线）、$(美元符号)）

标识符不能以数字开头

标识符不能是关键字

命名规范：（软性建议）

类名首字母大写后面的每个单词首字母建议大写（大驼峰命名法）、

方法名首字母小写，后面的每个单词首字母建议大写（小驼峰命名法）、

变量名，同方法名

名字尽量见名知意

常量：

常量，在程序的运行期间，固定不变的量。

常量的分类：

字符串常量：凡是用双引号引起来的部分，叫做字符串常量"今天是我学习Java的第2天"

整数常量：直接写上的数字，没有小数点。如 18、20、-5

浮点数常量(小数常量)：直接写上的数字，有小数点。如3.14、0.0

字符常量：凡是用 ' '引起来的单个字符，叫做字符常量如 '男'、 ' A'、 '1 '

布尔常量：只有true/false

空常量： null，代表没有任何数据，在内存中不存在。

空常量不能直接用来打印输出（引用不明确）

变量：

变量：在程序运行期间，内容可以发生变化的量。

数学中， 3 + 5 = 8 ---> x + 5 = 8 或者 3 + x = 8

在程序中，可以使用字母保存数字的方式进行运算，提高计算能力，可以解决更多的实际问题。比如 x可以保存3 也可以保存5 x保存数字（数据）是可以发生改变的，我们一般称这个x为变量。

备注：Java中，一个变量每次只能保存一个数据。

数据类型

分类：基本数据类型和引用数据类型

基本数据类型：如整数、浮点数、字符、布尔

引用数据类型：如类、数组、接口

基本数据类型：四类八种 byte 、short 、int、long float、double、boolean、char

数据类型	关键字	内存大小	取值范围
字节型	byte	1个字节 1B	-128-127 2^7-1
短整型	short	2个字节 2B	-32768-32767 2^15-1
整形	int	4个字节 4B	21开头的十位数 -2^31- 2^31-1
长整形	long	8个字节 8B	92开头的19位数 2^63-1
单精度浮点数	float	4个字节 4B	-1.4013E-45—3.4028E+38
双精度浮点数	double	8个字节 8B	4.9E-324 —1.7977E+308
字符型	char	2个字节 2B	0—65535
布尔型	boolean	1个字节 1B	true、false

备注：Java中的默认数据类型：整数类型为int；浮点类型为double

计算机基础知识：

二进制：计算机中的数据全部采用二进制表示，只包含0 1两个数逢二进一 1+1=10；

每一个1或者一个0，叫做一个 bit（比特）

字节：字节是计算机中最小的存储单元。计算机中存储任何的数据都是以字节的形式进行存储

1个字节 = 8个比特（二进制位） 00000000 8位写成 1 byte

1B = 8 bit 1024B = 1KB 1024KB = 1MB GB TB PB EB ZB

变量的定义：

变量的定义需要具备三元素：数据类型、变量名、数据值。

格式：变量的数据类型变量名 = 变量值；

定义变量的时候，需要注意的事项如下：
1.创建多个变量的时候，变量之间的名称不可以重复；
2.对于float和long类型来说，变量的数据值后面需要添加字母F和L
3.如果使用的是byte和short类型变量，注意右侧数值大小不要超过数据类型范围
4.没有进行赋值的变量，不能直接使用，能够使用的变量一定是经过初始化
5.变量的使用不能超出它对应的作用域
6.可以通过一个语句创建多个变量，但是不建议使用。
作用域--->{} 左半部分代表作用域的起始位置
右半部分代表作用域的结束位置

转义字符

一些具有特殊含义的字符，通过 ' '来进行转义

一个制表符占8位一个tab 缩进

换行符相当于执行newLine（）

回车符按下enter键

退一格

（v 垂直制表符）编译报错非法转义符

数据类型之间的转换

Java程序中要求参与运算的数据，必须保证数据类型的一致性。

当数据类型不一致的时候，将会发生数据类型转换。

数据类型之间的转换分为两种：

1.自动类型转换（隐式）

自动转换：将取值范围小的类型自动提升为取值范围大的类型。

byte在内存中占一个字节，需要和int类型的变量做运算会自动提升为int类型，自动补充三个字节，计算的结果自然就是int类型。

1.特点：代码不需要进行处理，程序内部转换自动完成。
2.规则：从数据范围小的转换为数据范围大的。

2.强制类型转换（显式）

将取值范围大的类型强制转换成取值范围小的类型

格式：数据类型变量名 = （数据类型）被转数据值

强制类型转换的注意事项：
1.一般不推荐使用，因为可能会发生精度损失，数据溢出
2.byte short char这三种数据类型在运算的时候，都会被提升为int类型，再进行运算
3.boolean类型不能发生数据类型转换 4.char类型可以进行数学运算，例如：加法 +

ASCII（美国信息交换标准代码）

数字和字符的对照关系表（编码表）

ASCII编码：American standard code for information interchange

Unicode编码：万国码。也是数字和字符符号的对照关系表，开头以0-127部分和ASCII完全一样，但是从128开始，包含更多的字符。

需要记忆： 48 ---> '0' 57---> '9' 65--->'A' 90--->'Z' 97--->'a' 122--->'z'

在计算机内部运算采用二进制方式，里面的数据都是0、1格式，如何让计算机识别人类的文字呢，就出现了编码表的概念。

编码表：就是将人类的文字和一个十进制数进行对应起来组成的一张表格。

将所有的英文字母、数字、符号都和十进制进行对应，产生了世界上第一张编码表（ASCII）

备注：在 char和int类型进行计算的过程中，char类型的字符会被转成int类型，需要查询编码表

**运算符 **

算术运算符 7种

算术运算符	含义
+	加法运算、字符串拼接、表正数
-	减法运算、表负数
*	乘法运算、通配符
/	除法运算（求商）
%	除法运算（求余数、取模运算）
++	自加一运算
--	自减一运算

比较运算符 6种

比较运算符	含义
==	相等比较
<	小于比较
>	大于比较
>=	大于等于比较
<=	小于等于比较
!=	不等于比较

备注：比较运算符运算结果都是 boolean 类型的值 true / false。

注意事项：如果我们进行多次判断，不能连着写。

数学当中， a>3 a<-1 ---> -1<a<3

程序中， -1<a && a<3

赋值运算符 6种

赋值运算符	含义
=	赋值
+=	加等于
-=	减等于
*=	乘等于
/=	商等于
%=	模等于

备注：1.重点掌握 " = " 基本的赋值运算符

2.剩下的都是复合赋值运算符

3.只有变量才可以使用赋值运算符

4.复合赋值运算符其中隐含了一个强制类型转换

逻辑运算符 4种

逻辑运算符	含义
&& 短路与	1.如果两边都是true，结果为true 2.如果一边为false，结果为false
\|\| 短路或	1.如果两边任何一边为true 结果为true ，否则为false
！取非	1.如果为false，结果为true，反之则为false
^ 抑或	1.如果两边有且只有一个true结果则为true，否则为false

位运算符 7种

运算符	含义	示例
<<	左移	5 << 2 = 20 == 5*2^2
>>	右移	5 >> 1 =2 == 5/2^1
>>>	无符号右移	对于正数来说，拿0来补符号位，负数拿1来补
&	与运算（位与）	5 & 3 == 1 只要出现一个位为0，结果位就为0
\|	或运算	5 \| 3 == 7 只要出现一个位为1，结果位就为1
^	异或运算	5 ^ 3 == 6 相异为1，相同为0
~	取反运算	~ 6 == -7 符号位也参与取反

备注：位运算计算机底层采用的是（对整数）二进制运算【没有无符号左移位运算符】计算机二进制表示：原码，反码，补码

表达式：本质是一个值；

语句：以，结尾；

三目运算符

格式：布尔类型表达式？真的结果值：假的结果值

计算方式：如果布尔类型表达式结果为true，三目运算符运算的结果为：前面的值如果布尔类型表达式结果为false，三目运算符运算的结果为：后面的值

备注：当三目运算符参与有其他运算（如赋值运算）的时候，要求三目运算符种：前后的数据类型一致
三目运算符的结果必须有变量接收，否则会出现意外的错误（不是语句）

流程控制

顺序结构：程序是从上往下进行加载，按照代码的编写顺序进行执行。

选择结构（分支结构）：

if else语句
1. if 单支情况
  
  if语句的格式： if（布尔类型表达式 / 布尔值）{
  
  //语句体
  
  }
  
  if 语句（单支）的执行流程：
  
  ①首先判断布尔类型表达式，看它的结果是false还是true
  
  ②如果是true就执行{ }里面的方法体内容
  
  ③如果是false就不执行 { } 里面的方法体内容，程序往后加载
  1. if else双支结构
    
    if （布尔类型表达式 / 布尔值）{
    
    //语句体内容一
    
    }else{
    
    //语句体内容二
    
    }
    
    执行流程：
    
    ①首先判断布尔类型表达式，看它的结果是false还是true
    
    ②如果是true就执行{语句体内容一 }里面的方法体内容
    
    ③如果是false就执行 {语句体内容二 } 里面的方法体内容
    
    3.if ... else if ... else 多支结构
    
    格式：
    
    if（布尔类型表达式1 / 布尔值1）{
    
    //语句体内容一
    
    }else if（布尔类型表达式2 / 布尔值2）{
    
    //语句体内容二
    
    }
    
    ……
    
    }else{
    
    //语句体内容n
    
    }
    
    执行流程：
    
    ①首先判断布尔表达式1看其结果是true/false
    
    ②如果是true，就执行方法体内容1
    
    ③如果是false，就继续判断布尔类型表达式2，看其结果是true/false
    
    ④……
    
    ⑤如果上述所有布尔类型表达式都为false ，执行语句体内容n
    
    备注：范围大的条件放在下面，否则会覆盖范围小的条件
    1. if...if...else...else语句、嵌套情形
      
      格式：
      
      if（布尔类型表达式1）{
      
      //方法体内容1
      
      ......
      
      if(布尔类型表达式2){
      
      //方法体内容2
      
      }else{
      
      //方法体内容3
      
      }
      
      }else{
      
      //方法体内容4
      
      }
      
      执行流程：
      
      ①首先判断布尔表达式1看其结果是true/false
      
      ②如果是true，就执行方法体内容1，再继续判断布尔类型表达式2，看其结果是true/false
      
      如果是true就执行方法体内容2，如果是false，就执行方法体内容3
      
      ③如果是false，就执行方法体内容4
  if语句与三目运算符的互换
```
int num01 = 10;
int num02 = 20;
//定义一个变量，保存num01和num02的最大值
int c;
if(num01 > num02){
    c = num01;
}else{
    c = num02;
}//上面的语句可以使用三目运算符
c = num01 > num02 ? num01 :num02;
```
switch case语句

格式：
```
switch(表达式/变量){
	case 常量值1：
		//语句体内容1
		break;
    case 常量值2：
		//语句体内容2
		break;
     ......
   default:
        //语句体内容n
        break;
}
```
执行流程：

①首先计算出表达式的值

②其次，依次和case后的常量值做比较，一旦有对应的值，就会执行相应的语句体内容

执行的过程中，遇到break就会结束switch case语句

③最后，如果所有的case都和表达式的值不匹配，就会执行default中的语句体内容，然后 switch case 程序结束

注意：在Switch语句中，表达式的数据类型，可以是byte/short/int/char/enum（枚举），

JDK1.7之后可以接收字符串类型

case的穿透性 在switch语句中，如果case后面的break省略，将会出现穿透现象。不会判断case的情形值，直接向后加载运行，直到遇见break结束

循环结构

【三种基本循环】for while do-while

循环结构的组成部分：一般分为4部分 1. 初始化语句：在循环最初开始时，需要定义一个初始化变量，而且只会初始化一次。 2. 条件判断：如果条件成立满足，进入循环，如果条件不满足，退出循环 3. 循环体内容：重复要做的事情内容，可能包含多条语句（事情是有规律的） 4. 迭代语句（步进语句）：每次循环结束之后需要执行步进语句，对初始化的变量做步进（迭代）

for循环语句结构 格式：

	for(1.初始化语句;2.条件判断式;4.迭代语句){
		3.//循环体内容
	}

执行流程：执行顺序：1—>2—>3—>4—>2—>3—>4—>2—>3—>4......2不满足为止

1负责循环变量的初始化 2负责判断是否满足循环条件，不满足退出循环 3循环代码执行语句 4负责变量的迭代

while循环语句

格式：

//1.初始化语句
while(2.判断条件){
    //3.循环体内容;
    //4.步进语句;
}

执行流程：

执行顺序：1--->2--->3--->4--->2--->3--->4......--->2不满足为止

1负责循环变量的初始化 2负责判断是否满足循环条件，不满足退出循环 3循环代码执行语句 4负责变量的迭代

do-while

格式：

//1.初始化语句
do{
	//3.循环体内容
	//4.迭代语句
}while(2.判断条件);

执行流程：

执行顺序：1--->3--->4--->2--->3--->4--->2--->3--->4--->......2不满足为止

1负责循环变量的初始化 2负责判断是否满足循环条件，不满足退出循环 3循环代码执行语句 4负责变量的迭代

备注：无条件的执行一次循环内容，即使判断条件不满足，也依然循环一次，这样的循环是有风险的，不建议使用

循环语句的区别

for 和 while 的区别：

控制语句中，所涉及到的循环变量，当for循环结束后，定义的循环变量不能再被访问到，而while循环依然可以被访问到，如果不继续使用循环变量了，建议使用for循环，因为for循环结束后，循环变量就会从内存中消失，从而提高内存的使用效率。
在已知循环次数的情况下，建议使用for循环，当循环次数不确定时，使用while循环

跳出语句

break、continue两个语句

break ：使用情形：终止switch 或者循环语句备注：离开了使用情形，对于break来说，毫无意义

public static void main(String args[]){
    //使用break语句
    //跳出循环
    //10以内的偶数和
    int sum =0;
    for(int i = 0 ; i < = 100 ; i++){
        if(i>10){
			break;
        }
        if(i / 2 == 0){
             sum += i;
        }
    }
    //跳出switch case语句
    //季节    四个季节
    String season = "春季";
    switch(season){
        case "春季" :
            System.out.println("万物复苏的季节！");
            break;
        case "夏季" :
            System.out.println("烈日炎炎的季节！");
            break;s
        case "秋季" :
            System.out.println("丰收的季节！");
            break;
     	case "冬季" :
            System.out.println("寒冷的季节！");
            break;
        default:
            System.out.println("跳出三界外，不在五行中");
            break;
    }
}

continue

使用情形：结束本次循环，继续下次循环

public static void main(String args[]){
    //continue
    //求一下100以内的偶然和   2+4+6+8+10+...+100
    for(int i=1;i<=100;i++){
        //使用场景  奇数跳过去，不参与累加和
        if(i%2!=0){
            continue;
        }
        sum+=i;
    }
}

扩展知识点

1.死循环

概念：循环中的条件永远都是true，死循环是永不结束的。例如：while(true){ }

死循环一般要和跳出语句结合

2.循环嵌套

概念：是指一个循环的循环体是另一个循环，比如for循环中内置了一个for循环，就是循环嵌套。

循环次数 = 外部循环的次数 * 内部循环的次数

格式：
    	for(1.初始化语句1;2.判断语句1;4.迭代语句1){
            //3.循环体内容
            for(5.初始化语句2;6.判断语句2;8.迭代语句2){
                //7.循环体内容2
            }
        }

执行流程：1--->2--->3--->5--->6--->7--->8--->6--->7--->8--->...6不满足为止（跳出循环）

--->4--->2--->3--->5--->6--->7--->8--->6--->7--->8--->...6不满足为止（跳出循环）

--->.......2不满足的时候（结束整个循环），加载外层for循环后面的语句

外循环一次，内循环多次

public static void main(String args[]){
	//使用场景
	//打印3*8长方形  长为3，宽为8
	//外循环3次，内循环8次
    for(int i = 0; i < 3; i++){
        for(int j = 0;j <8 ; i++){
            //输出
            System.out.print("*");
        }
        System.out.println();
    }
}

Scanner类和Random类的使用

API（application programming interface）应用程序编程接口 JavaAPI 程序员的字典是JDK提供给我们的使用类的说明文档，只需要自己查阅即可

Scanner类

它是一个可以解析基本数据类型和字符串的文本扫描器。主要作用就是把外部的数据录入到系统中

Scanner scanner = new Scanner(System.in);
//让系统能够从外部录入一个整数  nextInt()
int num = scanner.nextInt();
//备注：System.in可以实现通过键盘往系统中录入一个数据。
//让系统能够实现从外部录入一个浮点数(小数)   next Double()
double num02 = scanner.nextDouble();
//让系统能够实现从外部录入一个字符串数据
String str = scanner.next();