Java基础知识（数据类型、标识符、变量、运算符和流程控制语句）

一、Java中的数类型分为两种：

1. 基本数据类型
2. 引用数据类型

基本数据类型

基本数据类型大致可以分为4种八类

4种

整型、浮点型、字符型和布尔型

八类

整型（byte、short、int、long）默认类型为int类型

浮点型（float、double）           默认类型为double类型

字符型（char）

布尔型（boolean）

基本数据类型各个类型的取值范围（其中大小指在存储过程中需要占的二进制位）

引用数据类型

引用数据类型包括数组、类和接口（后面会详细介绍）

二、Java中的标识符

定义：标识符是用来标识某个对象（变量名、常量名、函数、类名、包名、接口名等）的名称

标识符的命名规则

标识符可以有字母、数字、下划线和$中的任意字符组成

标识符首字母必须是字母、下划线或$，绝不能以数字开头

标识符的命名要有一定的意义，不能使用关键字作为标识符（关键字下面会介绍到）

标识符严格区分大小写

Java中每个对象的命名规范

包名（多单词组成时所有字母都小写   如:xxxyyyzzz）

类名和接口名（多单词组成时，每个单词的首字母都大写    如：XxxYyyZzz ）

变量名和函数名（多单纯组成时，第一个单词的首字母小写，以后每个单词的首字母都大写    如：xxxYyyZzz）

常量名（多单词组成时，每个单词都大写，单词与单词之间使用下划线隔开   如：XXX_YYY_ZZZ）

三、Java中的关键字

定义：被Java赋予了特殊含义的单词

特点：关键字中所有字母都小写

常用关键字分类

用于定义数据类型的关键字（byte、short、int、ling、float、double、char、boolean、class、interface、void）

用于定义数据类型值得关键字（null、false、true）

用于定义流程控制语句的关键字（if、else、switch、case、default、break、return、do、 while、for、continue、try）

用于定义访问权限修饰符的关键字（public、private、protected）

用于定义修饰类、变量、函数修饰符的关键字（static、final、abstract）

用于定义类与类，类与接口之间关系的关键字（extends、implements）

用于定义建立实例及引用实例，判断实例的关键字(this、super、new、instanceof)

用于处理异常的关键字（try、catch、finally、throw、throws）

用于包的关键字（package、import）

四、Java中的常量

定义：常量表示不能被改变的数值

Java中常量的分类：

1，整数常量。所有整数

2，小数常量。所有小数

3，布尔型常量。较为特有，只有两个数值。true false。

4，字符常量。将一个数字字母或者符号用单引号( ' ' )标识。

5，字符串常量。将一个或者多个字符用双引号标识。

6，null常量。只有一个数值就是:null

Java中对于整数的三种表现形式

十进制     0-9，满十进一

八进制      0-7   满八进一   开头用0标识

十六进制    0-9，A-F,满十六进一，用0x开头标识

进制的基本转换

十进制转二进制

原理：其实就是除以2的过程把每次除以2得到的余数连接。如图：

15的二进制表现形式为：1111

十进制转八进制

原理：其实就是用三个二进制位代替一个八进制位

十进制转十六进制

原理：其实就是用四个二进制位代替一个八进制位

负数的二进制表现形式

原理：其实就是该数的二进制取反再+1

五、Java中的变量

变量的概念

变量指的是内存中的一块存储区域，该区域有自己的名称（变量名）和类型（数据类型），该区域的数据可以在同一类型范围内不断变化

为什么要定义变量？

因为变量可以重复的用来存放同一类型的常量

变量的作用范围

变量的作用范围只在该“{}”中有效

定义变量的格式

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

注意：变量的格式是固定的，变量就如同数学中的未知数

六、数据类型转换

Java中常见的两种转换方式

自动类型转换（隐身类型转换）

强制类型专换（显式类型转换）

自动类型转换

定义：容量小的数据类型与容量大的数据类型进行计算，默认转换为容量大的类型；

如：short + int = int;

数据类型按照容量的大小排序为：

byte、short、char、> int > long > float > double

注意：byte、short运算时不能喝char之间互相转换，byte可以赋值给short，但是他们三个在计算时会首先转换为int类型

强制类型转换

定义：容量大的数据类型转换为容量小的数据类型时，要加上强制转换符，但可能造成精度降低或溢出，所以使用时要格外注意

如  short  =  int; 如果出现这种情况是会出现编译报错的，应使用强制转换符把int 强制转换为 short   如: short = (short) int;

注意：当有多种类型的数据混合运算时，系统会自动的将所有数据转换为容量里最大的哪一种数据类型，然后在进行计算

强制转换符格式：（数据类型）（要被转换的数据）byte b =(byte) short;

类型转换时有字符型参与运算

当有字符参与运算时，系统首先回去找对应的ASCII码值，然后在参与运算   如  ‘a’ + 6 = 103

注意：int类型是可以赋值给char类型的   如 char  a  = (char) 97;

ASCII码表：

七、Java中的运算符

常见的几种运算符

 算术运算符

 赋值运算符

 比较运算符

 逻辑运算符

 位运算符

 三元运算符(条件运算符)

 运算符的优先级

说白了就是  算术运算符 > 位运算符 > 比较运算符 > 逻辑运算符 > 条件运算符 > 赋值运算符

算术运算符（+、-、*、/、%、++、- -）

 %

 定义：取模（取余）运算符，用于获取余数、

 小技巧：

 当左边的绝对值小于右边，结果为左边

 当左边的等于右边，或是右边的倍数时，结果为0；

 当有正负数时，余数是正数还是负数取决于左边，左边为正数，则余数为正数，左边为负数，则余数为负数

 ++、- -

 定义：就是递增或递减运算符，相当于+1或—1，++、——可以在操作数的前面也可以在操作数的后边  如：x++就等同于x+1;

 使用技巧：

 单独存在时：放在操作数的前面和后面，结果一样

 参与运算时：

 ++、——放在变量的前面，是先自增或自减1，在参与其他运算

 ++、——放置在变量的后面，是先参与运算，后再自增或自减1

不管++、——在前还是在后，操作数都会+1或—1；

 +

 “+”号的两种不同的作用

当“+”号两边都为整型没有字符串参与运算时：此时“+”号是做求和运算

当“+”号两边有字符串参与运算时：此时“+”号是做连接使用，是在原有的字符串的基础上追加另一个字符

赋值运算符（+=、—=、/=、*=、%=、=）

定义：把运算符左边和右边的和（积、商、差、求余）赋给左边 如： int x=5; x+=5;等同于 x = x+5;

关于 short x = 5; x = x+5和x+=5;的区别：

这个问题就要牵扯到类型转换了，试过的朋友肯定都知道“x = x+5”会出现编译报错，而“x+=5”却不会报错，为什么呢？先说说“x = x+5”吧，因为x原本为“short”类型，而在计算时系统是先进行的加法运算（也就是先计算的x+5），所以根据当容量小的数据类型与容量大的数据类型进行计算时，会自动转换为容量大的类型（5为整型，整型默认是int类型），所以此时“=”右边的数据类型已经自动提升为了"int"类型，而“=”两边的类型不一致，当然会编译报错了，所以“x = x+5”是需要强制类型转换的。

而"x+=5"是单纯的赋值预算，虽然上面说相当于“x = x+5”,但是本质上还是有区别的，它自带的有一个自动类型转换动作，所以不会报错

比较运算符（==、!=、>=、<=）

比较运算符的结果只有连个值，要么“true”，要么“false”

逻辑运算符（&、&&、|、||、！、^）

逻辑运算符&和&&

true    &（&&）  true   =  true

true    &（&&）  false  =  false

false   &（&&）  false  =  false

false   &（&&）  true   =  false

相同点：只要表达式的结果有一边为false，则结果为false，只有两边都为true时，结果才为true。

不同点：

1、在效率上：

单&，无论左边表达式结果为true还是false，右边都参与运算

双&，当左边表达式结果为false时，右边不参与运算

2、在作用域上:

单&，一般不用于条件运算中，通常作为位运算使用，而得到的结果是二进制结果

双&，一般用于条件运算中，得到的结果是布尔型

逻辑运算符|和||

true    |(||)    true    =  true

true    |(||)    false   =  true

false    |(||)  false   =  false

false    |(||)   true    =  true

相同点：只要表达式的结果有一边为false，则结果为false，只有两边都为true时，结果才为true。

不同点：

1、在效率上：

单|，无论左边表达式结果为true还是false，右边都参与运算

双|，当左边表达式结果为false时，右边不参与运算

2、在作用域上:

单|，一般不用于条件运算中，通常作为位运算使用，而得到的结果是二进制结果

双|，一般用于条件运算中，得到的结果是布尔型

逻辑运算符^

true     ^   true   =  false

true     ^   false  =  true

false    ^   false  =  false

false    ^    true  =   true

^：两边相同结果为false，不同结果为true

位运算符（<<、>>、>>>、&、|、^、~(反码)）

位运算符<<（左移）

原理：其实就是乘以2的位移次幂 注意：位移后会出现左边空出的情况，此时用“0”补齐即可

图例：

位运算符>>(右移)

原理：其实就是除以2的位移次幂 注意：位移后会出现右边空出的情况，此时，应看此二进制的最高位，最高位如果是“1”，则用“1”补齐空位，如果是“0”，则用“0”补齐空位

图例：

位运算符>>>(无符号右移)

原理：其原理和右移（>>）原理相同，需要注意的是，位移后无论二进制的最高位是“0”还是“1”，都用“0”补齐 （位运算时建议使用无符号右移）

位运算符&、^、|和~(反码)

&:二进制位进行&运算，只有1&1时才为1，否则都为0；

|：二进制位进行|运算，只有0 | 0时才为0，否则都为1；

^:二进制位进行运算，只有当1 ^ 1和 0 ^ 0时才为0，否则都为1

反码：对二进制进行取反

^的应用：

class Demo {//需求：对两个整型进行互换public static void main(String[] args) {//第一种方式：使用第三方变量实现互换int a = 5,b = 10,temp = 0;temp = a;a = b;b = temp;//第二种方式：不使用第三方变量，利用两个数之间的和与差完成互换int a1 = 5,b1 = 10,temp1 = 0;a1 = a1+b1;//结果为15b1 = a1-b1;//结果为15-10 = 5；a1 = a1-b1;//结果为15-5 = 10；//第三种方式：不使用第三方变量，利用逻辑运算符^实现互换int a2 = 5,b2 = 10,temp2 = 0;a2 = a2^b2;b2 = a2^b2;//他就相当与（a2^b2）^b2a2 = a2^b2;//它就相当于（a2^b2）^((a2^b2)^b2)}}

^能实现互换的原理

三元运算符

格式：（条件表达式）？ 表达式1 ：表达式2;

如果“条件表达式”的结果为“true”，则运算后的结果为“表达式1”，如果“条件表达式”的结果为“false”,则运算后的结果为“表达式2”

示例：

class  Demo{//使用三元运算符，求两个数之间的最大数public static void main(String[] args) {int a = 5,b = 10,c = 0;;c = a>b?:a:b;//如果a>b成立 c = a;如果a>b不成立 则c=b;System.out.println(c);}}

八、流程控制语句

流程控制语句大致分为三种结构：判断结构、选择结构、循环结构

class Demo01{/***流程控制语句*定义：流程控制语句是控制程序中各语句顺序的语句*/public static void main(String[] args) {//由于属于一个知识点，就直接写在一个main方法中了/**三种常用的流程控制语句1、判断结构2、选择结构3、循环结构*//*--------判断结构--------常用的几种格式：1、if(条件表达式){执行语句;}2、if(条件表达式){执行语句;} else{执行语句;}3、if(条件表达式1){执行语句} else if（条件表达式2）{执行语句;} else{执行语句;}4、if(条件表达式1){if(条件表达式2){执行语句}else{执行语句;}} else{执行语句;}*///第一种ifint x = 5;if(x == 5){/*当“x == 5”成立，则执行该语句，反之则跳过“{}中的语句块，直接执行后面的其他代码”System.out.println("条件成立，该语句成功执行");}//第二种if elseif(x == 5){//当“x==5”成立，执行该语句System.out.println("条件成立，该语句成功执行");}else{//当条件不成立时，执行该语句System.out.println("条件不成立，该语句不执行");}//第三种if else if elseif(x > 5)System.out.println("x > 5成立，执行该语句");else if(x < 5)System.out.println("x < 5成立，执行该语句");elseSystem.out.println("前面条件都不成立时，执行该语句");//第四种嵌套int m =6;if(x < 10){if(m == 6){System.out.println("当x < 10并且m == 6时执行该语句");}else{System.out.println("当x < 10并且m != 6时执行该语句");}}else{System.out.println("当x < 10不成立时执行该语句");}/*--------选择结构--------格式：switch（条件表达式）{case 匹配值1:break;case 匹配值2:break;....default:break;}*/switch(x){case 2:System.out.println("x="+x);break;case 3:System.out.println("x="+x);break;case 4:System.out.println("x="+x);break;case 5:System.out.println("x="+x);break;case 6:System.out.println("x="+x);break;default:System.out.println("x="+x);break;/*注意：使用switch选择结构时，1、条件表达式的结果只能是byte、int、short、char2、case和default是没有书写顺序的，当没有匹配的case时，执行default4、结束switch语句的方法有两种：遇到break或者执行到switch语句结尾3、case或default后面的break是可以省略的，当时当如果匹配的case或default没有对应的break，那么程序会继续往下执行，直到程序遇到break或者结束*/}/*--------循环结构--------常用的三种格式1、while(条件表达式){循环体;}2、do{循环体;}while(条件表达式);3、for(表达式1; 条件表达式; 表达式2){循环体}*///第一种：while();while(x<=10){//循环体System.out.println("x="+x);x++;//使用x自增控制循环次数，防止死循环}//第二种：do while();do{//循环体System.out.println("x="+x);x++;//使用x自增控制循环次数，防止死循环}while(x<=10);/*注意：while和do while是由区别的，while是先判断后执行，而do while是先执行后判断，也就是说，使用do while时，无论条件是否成立，循环体都会执行一次*///第三种：for();for(System.out.println("a"); x<=7;System.out.println("c"),x++){System.out.println("b");}/*总结：通过运行程序发现控制台打印结果为：abcbcbc所以在使用for循环时应注意：for循环的执行顺序是先执行“表达式1”，然后再判断“条件表达式”是否成立，如果成立，则执行循环体，然后再执行“表达式2” 然后再判断“条件表达式”是否成立，成立在执行循环体然后.....但是当“条件表达式”不成立时，会结束循环*//*-------语句的嵌套应用--------1、打印***************2、打印***************3、打印11 21 2 31 2 3 41 3 3 4 54、打印      1    1 2 1  1 2 3 2 11 2 3 4 3 2 1  1 2 3 4 5 4 3 2 1第四题图例：777777888888177777888881 2 1777788881 2 3 2 17778881 2 3 4 3 2 177881 2 3 4 5 4 3 2 1781 2 3 4 5 6 5 4 3 2 11 2 3 4 5 6 7 6 5 4 3 2 15、打印99乘法表规律：尖朝上，改变内循环的条件，让条件随着外循环变化，  尖朝下，改变内循环的初始化值，让初始化值随着外循环变化*///第一题：for(int x = 0; x<5; x++){//用于控制行数for(int i = 0; i<=x; i++){//用于控制每一行打印“*”的个数//此处不能换行System.out.print("*");//用于打印“*”}//等内循环循环完毕后，打印换行System.out.println();//每打印一行，换行}//第二题for(int i= 0; i<5;i++){//用于控制行数for(int x=i;x<5;x++){//用于控制每一行打印“*”的个数System.out.print("*");//用于打印“*”}System.out.println();//每打印一行，换行}//第三题for(int i=1;i<=5;i++){//用于控制行数for(int x=1;x<=i;x++){//用于控制输出的数字及个数System.out.print(x+" ");//用于按顺序输出每个数字}System.out.println();//输出换行}//第四题for(int x=1;x<=7;x++){//用于控制行数for(int j=0;j<7-x;j++){//用于输出空格System.out.print(" ");}for(int i=1;i<=x;i++){//用于控制左边数字的输出System.out.print(i+" ");}for(int k=x-1;k>=1;k--){//用于控制右边数字的输出System.out.print(k+" ");}System.out.println();//输出换行}//第五题打印99乘法表for(int i=1;i<=9;i++){//用于控制行数for(int j=1;j<=i;j++){//用于控制每列输出的口诀System.out.print(j+"*"+i+"="+i*j+"\t");}System.out.println();//用于输出换行}/*--------使用循环完成累计求和、计算器操作------1、需求：使用循环求1-50之间的和2、需求：使用循环找出1-100之间包含“7”的个数3、需求：使用循环找出1-100之间7的倍数的个数*///求1-50之间的和int sum=0;for(int i=1;i<=50;i++){sum+=i;}System.out.println(sum);//求1-100之间包含7的个数int index = 0;for(int i=1;i<=100;i++){//定义循环，对1-100进行遍历//把遍历到的数字转换为String类型String num = i+"";//使用String的contains方法查询该字符串中是否包含“7”if(num.contains("7")){//如果包含则让次数+1；index++;}}System.out.println("1-100之间包含7的个数为"+index);//求1-100之间7的倍数的个数int index_1 = 0;for(int i=1;i<=100;i++){//定义循环，对1-100进行遍历//判断是否是7的倍数if(i%7==0){//如果是则次数+1index_1++;}}System.out.println("1-100之间包含7的倍数的个数为"+index_1);}}