Day01---1java语言基础

1.标识符

什么是标识符？

 在java源程序中，凡是程序员有权自己命名的单词均为标识符

 标识符在EditPlus编辑器中以黑色字体高亮显示

标识符可以表示哪些元素？

 类名

 方法名（例如：main）

 变量名（例如：args）

 接口名

 常量名

标识符的命名规则？【不遵守规则，编译器会报错】

 一个合法的标识符只能由数字、字母、下划线_、美元符号$组成，不能含有其他符号

 不能数字开头

 严格区分大小写

 关键字不能做标识符

 理论上无长度限制，但最好不要太长

标识符的命名规范？【不属于语法，不遵守规范，编译器不会报错】

最好见名知意
例如：

public class UserService{

public void login(String username,String password){

}
}

遵守驼峰命名方式

例如：

 SystemService

 UserService

CustomService

类名、接口名：首字母大写，后面每个单词首字母大写

变量名、方法名：首字母小写，后面每个字母首字母大写

常量名：全部大写

合法和不合法的标识符

合法       不合法

------------------------------------------

_123Test    123Test

​HelloWorld！

A_B      HelloWord#

$ABC     Hello Word

class1      class

public0      public

2.关键字

 关键字在EditPlus工具中颜色为蓝色高亮（全部小写）

常见的关键字有哪些？

 public

 class

 static

 void

 if

 for

 while

 do

 default

 byte

 short

 int

 long

 float

 double

 boolean

 char

 private

 protected

 switch

 true

 false

 throws

 try

 catch

 提醒：关键字不需要单独记忆，编写程序过程中记忆

3.字面值

 -10、100

 -3.14

 -“abc”

 -‘a’

 -true、false

字面值就是数据

 字面值是java源程序的组成部分之一，标识符和关键字都是java源程序的组成部分

 数据在现实世界中使分门别类的，所以数据在计算机编程语言中也有类型【数据类型】

 -10、100 整数型字面值

 -3.14 浮点型字面值

 -true、false 布尔型字面值

 -“abc”“中国人” 字符串型字面值

 -“A”、“人” 字符型字面值

注意：java语言中所有的字符串型字面值必须使用双引号，双引号是半角

​ java语言中所有的字符型字面值必须使用单引号，单引号是半角

4.变量

①什么是变量？

 变量本质上是内存中的一块空间，这块空间“有数据类型”，“有名字”，“有字面值”

 变量包含三部分：数据类型、名称、字面值【数据】

 变量是内存中存储数据的最基本的单元

数据类型的作用？

 不同的数据有不同的类型，不同的数据类型底层会分配不同大小的空间

 数据类型是指导程序在运行阶段应该分配多大的内存空间

变量的要求：

 变量中存储的具体的“数据”必须和变量的“数据类型”一致，当不一致时，编译报错

声明/定义变量的语法格式：

数据类型 变量名；

 数据类型:整数型 int

 变量：只要是合法的标识符即可，规范要求：首字母小写，后面每个单词首字母大写

例如：

 int i;

 int age;

 int size;

 int num;

变量声明之后怎么赋值？

语法格式：变量名 = 字面值；

 要求：字面值的数据类型必须和变量的数据类型一致

  = ：等号是赋值运算符，先运算等号右边，表达式结束后将结果赋值给左边的变量

声明和赋值可以一起完成：

 int i = 10;

变量赋值之后，可以重新赋值，变量的值可变：

 int i = 10;

 System.out.println(i);//10

 i = 20;

 System.out.println(i);//20

有了变量的概念后，内存空间得到了重复利用：

 int i = 10;

 System.out.println(i);

 …

 System.out.println(i);

通常访问一个变量包括两种访问形式：

 第一种：读取变量中保存的具体数据 get/获取

 第二种：修改变量中保存的具体数据 set/设置

 i = 20;//set

 System.out.println(i);//get

变量在一行上可以声明多个：

 int a,b,c;

java中变量名必须先声明，再赋值，才能访问

 int i;程序执行到这里，内存空间没有开辟出来，变量i没有初始化，所以没有复制之前是无法访问的

②方法体中的java代码，遵守自上而下的顺序依次执行，逐行执行

 特点：上一行代码必须完整结束后，下一行程序才能执行

 在同一个“作用域”中，变量名不能重名，但变量可以重新赋值

变量的作用域：

什么是作用域？

 描述的是变量的有效范围，除了范围，该变量就无法访问（出了大括号就不认识了）

例题：

 for(int a = 0;a < 0;a++){//a变量的作用域是整个for循环，for循环结束后，a变量的内存就释放了

}

 System.out.println(a);//无法访问a变量

 int j;//j变量的作用域为main方法

 for(j = 0;j < 0;j++){

 }

 System.out.println(j);//可以访问

③关于变量的分类：

 根据变量声明的位置来分类：

 局部变量：在方法体中声明的变量

 成员变量：在方法外【类体内】声明的变量

 在不同的作用域中，变量名可以相同

 在同一个作用域中，变量名不能重名

5.数据类型

数据类型的作用？

 指导java虚拟机（JVM）再运行程序的时候给该数据分配多大的内存空间

 数据类型包括两种：基本数据类型、引用数据类型

基本数据类型

 四大类、八小种

 第一类：整数型：byte , short , int , long

 第二类：浮点型：float , double

 第三类：布尔型：boolean

 第四类：字符型：char

引用数据类型

 类、接口、数组

 字符串不属于基本数据类型，属于引用数据类型

 字符串使用双引号，字符使用单引号

八种基本数据类型各自占用空间的大小？

 byte  1（字节）

 short  2

 int   4

 long  8

 float  4

 double 8

 boolean  1

 char  2

字节（byte）：

 1byte = 8bit【1个字节 = 8个比特】1个比特表示一个二进制位

 1KB = 1024Byte

 1MB = 1024KB

 1GB = 1024MB

 1TB = 1024GB

 整数型中的byte类型，占用1个字节，所以byte类型的数据占用8个比特为，

 byte类型的取值范围：

 符号位：0表示整数，1表示负数

 byte类型最大值：01111111【10000000-1 = 127】

 byte类型的最小值：-128

 计算机在任何情况下只能识别二进制

 二进制：数据的表示形式

 计算机如何表示现实世界中的文字？

 文字和二进制之间的对照关系，这种对照转换关系叫做：字符编码

 最先出现的字符编码是：ASCII码

  ‘a’–>97

  ‘A’–>65

  ‘0’–>48（零字符）

  ‘1’–>49

 编码和解码采用同一套对照表，才不会出现乱码，否则，会出现乱码问题

GB2312 < GBK < GB18030

 unicode编码：统一了全球所有文字

 java语言源代码采用的是unicode编码方式，所以“标识符”可以采用中文

 实际开发中，一般采用UTF-8编码方式较多【统一编码方式】

八种基本数据类型的取值范围

 byte  【-128~127】

 short  【-32768~32767】

 int  【-2147483648~2147483647】

 long

 float

 double

 boolean  【true、false】

 char    【0~65535】

 注意：short和char所表示的种类总数一样，只不过char可以表示更大的正整数，char没有负数

关于八种基本数据类型的默认值：（一切向0看齐）

 成员变量没有手动赋值时，系统会默认赋值【局部变量不会】

数据类型      默认值

----------------------------------------------------

byte,short,int,long    0

float，double     0,0

booleanfalse   【true是1，false是0】

char        \u0000

char类型

 一个中文占用2个字节，char类型刚好2个字节，所以java中char类型可以存储一个中文字节

 *转义字符：*

 转义字符出现在特殊字符之前，会将特殊字符转换成普通字符

 \n —换行符

 \t ----制表符tab（制表符和空格不同）

 ’ -----普通的单引号

 \ -----普通的反斜杠

 " -----普通的双信号

 \u ----后边的一串字符是某个文字的Unicode编码

输出反斜杠\

	char k = '\\';

	System.out.println(k);

输出普通的单引号‘：

	char a = '\'';

	System.out.println(a);

输出双引号“：

	char b = '"';

	System.out.println(b);

	System.out.print();输出不换行

	System.out.println();输出且换行

整数型

 java语言中的“整数型字面值”被默认当做int类型来处理，

 要让此“整数型字面值”被当做long类型来处理的话，需要在“整数型字面值”后添加l/L,建议用L

 java语言中的整数型字面值有3中表示方式：

 十进制【是一种缺省默认的方式】

 八进制【在编写八进制整数型字面值的时候需要从0开始】

 十六进制【在编写十六进制整数型字面值的时候需要以0x开始】

小容量转换成大容量

 int类型是小容量，long类型是大容量，小容量可以自动转换成大容量，成为自动类型转换机制

 long z = 2147483648;//编译错误，出现整数默认为int，但数值超出int范围

 long z = 2147483648L;//编译成功

大容量转换成小容量

 大容量不能直接赋值给小容量，需要进行强制类型转换

 强制类型转换需要加“强制类型转换符”，虽然编译通过，但运行阶段可能损失精度

 所以强制类型转换需要谨慎使用，若超出原有范围，会导致损失精度，损失精度后可能损失很严重。严重损失精度，结果为负数

 int y = (int)x;

浮点型

 double的精度太低【相对来说】，不适合做财务软件

 SUN在技术SE类库中为程序员准备了精度较高的类型，只不过这种类型是一种引用数据类型，不属于基本数据类型，它是：java.math.BigDecimal

 例如：String.java和String.class

 (String[] args)中的String使用的就是String.class字节码文件

 在JAVA语言中，所有的浮点型字面值，默认被当作double类型处理，要想该字面值被当做float类型来处理，需要在字面值后面添加F/f

 注意：double和float在计算机内部二进制存储的时候存储的都是近似值

布尔型

 boolean:true false,没有其他值

 在底层存储时，boolean占用1个字节，因为实际存储时false底层是0，true底层是1

 boolean在实际开发中十分重要，经常使用在逻辑运算和条件控制语句中

 数据类型的互相转换：

 转换机制：【记住+理解】

 ①八种基本数据类型转换除布尔类型之外剩下的7种类型之间都可以互相转换

 ②小容量向大容量转换，成为自动类型转换，容量从小到大排序

 byte < short < int < long < float < double

 ​ char <

 注意：任何浮点类型不管占用多少字节，都比整数型容量大

 ​ char和short可以表示的种类数量相同，但是char可以取更大的正整数

 ③大容量转换为小容量–强制类型转换，需使用强制类型转换符，才可编译通过

 ④当整数字面值没有超出byte,short,char的取值范围，可以直接赋值给byte，short，char类型的变量

 ⑤byte,short,char混合运算时，各自先转换成int类型再做运算

 ⑥多种数据类型混合运算，先转换成容量最大的那种类型再做运算

6.运算符

①算数运算符

 + 求和

 - 相减

 * 乘积

 / 商

 % 求余数【取模】

 ++ 自加1【单目运算符】

 – 自减1

 注意：一个表达式中有多个运算符,运算符具有优先级，不确定的加小括号，优先级得到提升

 ++运算符可出现在变量前，也可出现在变量后，无论是变量前还是变量后，只要++运算结束，该变量的值一定会自加1

 ++出现在变量后：

 规则：先做赋值运算，再对变量中保存的值进行自加1

例：

 int a = 100;

 int b = a ++;

 System.out.println(a);//101

 System.out.println(b);//100

例：

 int e = 100;

 System.out.println(e ++);//100

 System.out.println(e);//101

 int s = 100;

 System.out.println(++ s);//101

 System.out.println(s);//101

 System.out.println(–s);//100

 System.out.println(s ++);//100

 System.out.println(s–);//100

 System.out.println(s–);//99

 System.out.println(s);98

 ++出现在变量前：

 规则：先进行自加1操作，再进行赋值操作

例：

 int m = 20;

 int n = ++ m;

 System.out.println(m);//21

 System.out.println(n);//21

②关系运算符

 > 大于

 >= 大于等于

 < 小于

 <= 小于等于

 == 等于

 != 不等于

 = 是赋值运算符，== 是关系运算符

 关系运算符的运算结果一定是布尔类型：true/false

运算原理：

 int a = 10;

 int b = 10;

 a>b比较时，比较的是a中保存的10这个值和b中保存的10这个值之间的大小比较

 a == b亦是如此

例：

 int a = 10;

 int b = 10;

 System.out.println(a > b);//false

 System.out.println(a >= b);//true

 System.out.println(a < b);//false

 System.out.println(a <= b);//true

 System.out.println(a == b);//true

 System.out.println(a != b);//false

③逻辑运算符

 & 逻辑与【并且】（两边的算子都是true，结果才是true）

 | 逻辑或【或者】（两边的算子只要有一个是true，结果就是true）

 ! 逻辑非（取反，！false就是true，！true就是false）【单目运算符】

 ^ 逻辑异或（两边的算子只要不一样，结果就是true）

 && 短路与（与逻辑与运算结果相同，只是短路与存在短路现象）

 || 短路或（与逻辑或运算结果相同，只是短路或存在短路现象）

 逻辑运算符要求两边的算子都是布尔类型，且逻辑运算最终的运算结果也是布尔类型

例：

 System.out.println(5 > 3 & 5 > 2);//true

 System.out.println(5 > 3 & 5 > 6);//false

 System.out.println(5 > 3 | 5 > 2);//true

 System.out.println(true ^ false);//true

 System.out.println(true ^ true);//false

逻辑与和短路与

逻辑与

 int x = 10;

 int y = 8;

 System.out.println(x < y & ++x < y);

 System.out.println(x);//11 相当于执行了++x

短路与：

 int x = 10;

 int y = 8;

 System.out.println(x < y && ++x < y);

 System.out.println(x);//10 没有执行++x

 短路与：x < y结果是false，整个表达式结果已经确定是false，所有后面的表达式没有再执行，这种现象成为短路现象，短路与才会有短路现象，逻辑与不存在短路现象

 短路与更智能，由于后面的表达式可能不执行，所以执行效率较高，开发中使用较多

 在某些特殊业务逻辑中，要求运算符两边的算子必须全部执行，此时必须使用逻辑与

什么情况下发生短路或？

 第一个表达式执行结果是true，会发生短路或

什么情况下发生短路与？

 第一个表达式执行结果是false，会发生短路与

④赋值类运算符

 包括两种：基本的赋值运算符（=）、扩展的赋值运算符（+=、-=、*=、/=、%=）

 赋值类的运算符优先级：先执行等号右边的表达式，将执行结果赋值给左边的变量

例：

 int i = 10;

 i = i + 5;//，数据类型相同时，等同于i += 5；

 System.out.println(i);//15

 +=可翻译为“追加/累加”

例：

 byte b = 10;

 b = (byte)(b + 5);

 System.out.println(b);

 b += 5;//等同于b = (byte)(b + 5)****，并不等同于b = b + 5;

 重要结论：扩展类的赋值运算符不改变运算结果类型

⑤字符串连接运算符

 “+”在java语言中有两个作用：

加法运算，求和

字符串的连接运算

 当“+”两边的数据都是数字时，一定是进行加法运算 数字 + 数字—>数字【求和】

 当“+”两边的数据只要有一个是字符串，一定会进行字符串连接运算，并且，连接运算之后的结果还是一个字符串类型 数字 + “字符串”---->“字符串”【】字符串连接

 在一个表达式中可以出现多个“+”，在没有添加小括号的前提下，遵循自左向右的顺序执行

例：

int a = 10;

int b = 20;

System.out.println("10 + 20 = " + a + b);//“10 + 20 = 1020”

//要求输出动态的 10 + 20 = 30

System.out.println(a + " + " + b + " = " + (a + b));//10 + 20 = 30

引用数据类型String

String是SUN在javaSE中提供的字符串类型

String.class字节码文件

int是基本数据类型，i是变量名，10是int类型的字面值

int i = 10;

String是引用数据类型，s是变量名，“abc”是String类型的字面值

String s = “abc”;

String ss = 10;//编译错误，类型不兼容

定义一个String类型的变量，起名username，赋值“zhangsan”

String username = “zhangsan”；

System.out.println(“登陆成功，欢迎” + username + “回来！”);//动态的

⑥三元运算符/三目运算符/条件运算符

 语法规则：布尔表达式？表达式1 ：表达式2

 执行原理：当布尔表达式结果为true时，选择表达式1作为整个表达式的执行结果

 当布尔表达式结果为false时，选择表达式2作为整个表达式的执行结果

例：

boolean sex = false;

sex ? “男” ： “女”;//编译报错，他不是一个完整的java语句

例：

char c = sex?“男”：“女”;

System.out.println©;//可以正常运行

例：

//类型不兼容

char c1 = sex?“男”：“女”;//语法错误，编译报错，结果可能是String，也可能是char，但前边不能用char来接收数据

例：

System.out.println(s);//可以运行

String s = sex?“男”：“女”;

System.out.println(s);//也可以

7.控制语句

分为7种：

①选择结构

if

if、if else（if语句又称为分支语句/条件控制语句）

if语句的四种编写方式：

1）

if(布尔表达式){

java语句；

java语句；

​ }

2）

if(布尔表达式){

Java语句；

java语句；

}else{

java语句；

java语句；

}

3）

if(布尔表达式){

java语句；

java语句；

}else if(布尔表达式){

java语句；

java语句；

}else if(布尔表达式){

java语句；

java语句；

}…

if(布尔表达式){

java语句；

java语句；

}else if(布尔表达式){

java语句；

java语句；

}else if(布尔表达式){

java语句；

java语句；

…

}else{

java语句；

java语句；

。。。

}

 重点：对于java中的if语句，只要有一个分支执行，整个if语句全部结束

 注意：以上的第二种编写方式和第四种编写方式都带有else分支，这两种方式可以100%保证会有分支执行

 所有的控制语句都可以嵌套使用，只需合理嵌套

if(){

if(){

if(){

}

}

}else{

if(){

if(){

}

}

}

注意：嵌套使用时，代码格式要保证完美【该缩进时必须缩进】

switch

（switch语句也属于选择结构，也是分支结构）

语法结构：

switch(int和String类型的字面值或变量){

case int和String类型的字面值或变量:

java语句；

。。。

break;

case int和String类型的字面值或变量:

java语句；

。。。

break;

case int和String类型的字面值或变量:

java语句；

。。。

break;

default:

java语句；

。。。

}

执行原理：

 1）switch后面的小括号中的数据和case后的数据进行一一匹配，匹配成功的分支执行，按照自上而下的顺序依次匹配

 2）匹配成功的分支执行，分支中有break语句时，整个switch语句终止

  匹配成功的分支执行，分支中没有break语句时，直接进入下一个分支执行（不进行匹配），这种现象叫做case穿透现象【提供break语句可以避免穿透】

 3）所有分支都没有匹配成功时，当有default语句时，汇之星default分支中的程序

 switch后面和case后面只能是int或String类型的数据，不能是探测其他类型

 当然：byte,short,char也可直接吓到switch和case后面，因为他们可以进行自动类型转换，

 case可以合并

例：

int i = 10;

switch(i){

case1:case2:case3:case10:

System.out.println(“Test Code!”);

}

②循环结构

 循环结构：在程序中总有一些需要反复的/重复的执行，假设没有循环结构，那么这段需要重复执行的代码自然是需要重复编写的。代码无法得到重复使用，所以多数编程语言都支持循环结构

for

语法结构：

for{初始化表达式；布尔表达式；更新表达式}{

//是需要重复执行的代码片段【循环体：由java语句构成】

}

初始化表达式、布尔表达式、更新表达式都不是必须的【但是两个分号是必须的】

初始化表达式最先执行，并且在整个for循环中只执行一次

布尔表达式必须是true/false，不能是其他值

执行过程：

先执行初始化表达式，并且该表达式只执行一次

判断布尔表达式的结果是true还是false

布尔表达式true

执行循环体

执行更新表达式

判断布尔表达式的结果是true还是false

布尔表达式true

执行循环体

执行更新表达式

。。。

布尔表达式为false

循环结束

布尔表达式false

循环结束

循环语句和条件判断语句嵌套使用【for和if的嵌套】

例：找出1-100所有的奇数

法一：效率高

for(int i = 1;i <= 100;i += 2){

System.out.println(“奇数---->” + i)：

}

法二：

for(int i = 1;i <= 100;i ++){

if(i % 2 != 0){

System.out.print(i);

}

}

使用for循环输出九九乘法表：

for(int i = 1;i <= 9;i++){//外层循环9次

//i是行号

//循环体中的程序主要任务是什么？ 处理当前行，将当前行中所有项目全部输出

for(int j = 1;j <= i;j++){

System.out.println(i + “*” + j + “=” + i * j + " ");

}

System.out.println();//换行

}

while

语法结构：

while(布尔表达式){

循环体;

}

执行原理：

先判断布尔表达式的结果：

true：执行循环体–>判断布尔表达式的结果。。。

false：循环结束

循环次数：

0~N次

注意：while循环的循环体可能执行次数为0次

do while

语法结构：

do{

循环体；

}

执行原理：

执行次数：

循环体代码片段执行次数是：1~N次【至少一次】

使用的注意事项：

do…while循环语句最终有一个“分号”，不能丢

③控制循环的语句

break

break是java语言中的关键字，被翻译为“中断、折断”；

break + “；”可以成为担负的完整的java语句：break；

break语句使用在switch语句中，用来控制switch的语句执行；

break语句同样可以使用在循环语句中，用来控制循环的执行；

break语句使用在for，while，do…while循环语句中用来跳出循环，终止循环的执行。

在默认情况下，break语句终止的是离它最近的循环语句，也可以指定终止某个循环，需要给循环起名，采用这种做法：break 循环名称；

continue

表示继续/go on/下一个

continue是一个continue关键字加分号构成单独的完整的Java语句，主要出现在循环语句中用来控制循环的执行

break和continue的区别？

break表示循环结束

continue表示直接进入下一次循环继续执行

注：只要continue语句执行，当前本次循环停止，直接进入下一次循环

接收用户键盘输入，从“键盘”到“内存”【输入的过程，到内存中去】

第一步：创建键盘扫描器对象

java.util.Scanner s = new java.util.Scanner(System.in);

第二步：调用Scanner对象的next()方法开始接受用户键盘输入

程序执行到此会停止，等待用户输入，当用户输入且敲回车键时，键入的信息会自动赋值给userInputContent

String userInputContent = s.next();

//将内存中的数据输出到控制台

System.outprintln(“您输入了：” + userInputContent);

总结：

第一步：

java.util.Scanner s = new java.util.Scanner(System.in);

第二步：

String str = s.next();或者 int num = s.nextInt();