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

原文地址：http://blog.csdn.net/zzamk/article/details/43969205

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

基本数据类型
引用数据类型

基本数据类型

基本数据类型大致可以分为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; //结果为15
b1 = 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）^b2
a2 = 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{
执行语句;
}

*/
//第一种 if
int x = 5;
if(x == 5){
/*当“x == 5”成立，则执行该语句，反之则跳过“{}中的语句块，直接执行后面的其他代码”
System.out.println("条件成立，该语句成功执行");
}

//第二种 if else
if(x == 5){
//当“x==5”成立，执行该语句
System.out.println("条件成立，该语句成功执行");
}
else{
//当条件不成立时，执行该语句
System.out.println("条件不成立，该语句不执行");
}

//第三种 if else if else
if(x > 5)
System.out.println("x > 5成立，执行该语句");
else if(x < 5)
System.out.println("x < 5成立，执行该语句");
else
System.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、char
2、case和default是没有书写顺序的，当没有匹配的case时，执行default
4、结束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、打印
1
1 2
1 2 3
1 2 3 4
1 3 3 4 5
4、打印
1
1 2 1
1 2 3 2 1
1 2 3 4 3 2 1
1 2 3 4 5 4 3 2 1
第四题图例：
7777778888881
77777888881 2 1
777788881 2 3 2 1
7778881 2 3 4 3 2 1
77881 2 3 4 5 4 3 2 1
781 2 3 4 5 6 5 4 3 2 1
1 2 3 4 5 6 7 6 5 4 3 2 1
5、打印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){
//如果是则次数+1
index_1++;
}
}
System.out.println("1-100之间包含7的倍数的个数为"+index_1);
}

}