《Java基础入门》学习笔记—— java编程基础（更新二）我把统一章节的都统一更新到一篇文章里，这样就不会显得文章篇目太多啦嘻嘻

2.1 Java的基本语法

2.1.1 Java代码的基本格式

Java中的程序代码都必须放在一个类中，类可以简单理解为一个Java程序。 类需要使用class关键字定义，在class前面可以有一些修饰符，格式如下图所示：

编写代码时需要注意：
①程序代码可分为结构定义语句和功能执行语句
结构定义语句：声明一个类或方法；
功能执行语句：实现具体功能。 （每条功能执行语句以 英文分号 结束。）

②Java语言 区分大小写。
定义类时，不能将class写成Class, 否则编译会报错。
程序中computer和Computer是两个完全不同的符号，使用时务必注意。
③排版美观，增强可读性。
④Java程序中一句 连续的字符串不能分开在两行中书写。
错误示范如下：

强行拆分字符串，避免编译报错的解决方案如下：

2.1.2 Java中的注释

1. 单行注释：用"//“表示，”//"后面为被注释的内容；
2. 多行注释：以"/* "开头，以 "* /"结尾；
3. 文档注释：以"/**“开头，以”* /"结束。（可以使用javadoc命令将文档注释提取出来生成帮助文档）

注意：Java中，有的注释可以嵌套使用，有的则不可以。下面列出两种具体情况。
①多行注释"/＊……* /“中可以嵌套单行注释”//"’。例如：

②多行注释"/＊……＊ /“中不能嵌套多行注释＂/＊……* /”'例如：

    /* 
        /*int c=10;  */  
       int x=5;        
   */
无法通过编译是因为笫一个 "/*"会和第一个"*/"进行配对，而第二个"*/"则找不到匹配。

2.1.3 Java中的标识符

标识符可以由任意顺序的大小写字母、数字、下划线（_）和美元符号（＄）组成
标识符不能以数字开头，或是Java中的关键字

定义标识符时建议：
①包名所有字母一律小写，例如en. itcast. test。
②类名和接口名每个单词的首字母都要大写，例如ArrayList、Iterator。
③常量名所有字母都大写，单词之间用下划线连接，例如DAY_OF_MONTH。
④变量名和方法名的第一个单词首字母小写，从第二个单词开始每个单词首字母大写，例如lineNumber、getLineNumber。
⑤尽量使用有意义的英文单词来定义标识符，使程序便于阅读。 例如使用userName表示用户名，passWord表示密码。

2.1.4 Java中的关键字

关键字是编程语言里事先定义好并赋予了特殊含义的单词，也称作保留字。
每个关键字都有特殊的作用。
例如：package关键字用于包的声明， import关键字用于引入包，class关键字用于类的声明。

abstract 　　　 boolean　　　 break　　　　 byte　　　　 case　　　　　catch
char 　　　　　const 　　　　class 　　　 　continue　　 default　　　 　do　
double　　　 　else　　　　　extends　　　 false　　　　final　　　 　　finally　
float　　　　 　 for　　 　　　goto　　　　　if　　　　　 implements　 　import　
instanceof　　　int　　　　 　interface　　　 long　　　　native　　　　 new
null　　　　　　package　　 private　　　　 protected　　public　　　 　return
short　　　　 　static　　　　strictfp　　　　super　　　　switch　　　　this
throw　　　　　throws　　　 transient　　 　true　　　　　try　　　 　　 void
volatile　　　 　while　　　　synchronized

注意：
• 所有关键字都是小写；
• 程序中的标识符不能以关键字命名。

2.1.5 Java中的常量

1. 整型常量：整数类型的数据。有二进制、八进制、十进制和十六进制4种表示形式；

• 二进制：以 0b 或 0B 开头，如：0b01101100、0B10110101
• 八进制：以 0 开头，如：0342
• 十进制：如：198
• 十六进制：以 0x 或 0X 开头，如：0x25AF

2. 浮点数常量：数学中用到的小数。分为float单精度浮点数和double双精度浮点数两种类型，结尾不加后缀，默认为双精度浮点数；

• 单精度浮点数：以 F 或 f 结尾，如：2e3f
• 双精度浮点数：以 D 或 d 结尾，如：3.6d

3. 字符常量：用于表示单个字符。需用一对英文半角格式的单引号（’’）引起来。如：‘a’，‘l’，’&’，’\r’，’\u0000’
4. 字符串常量：用于表示一串连续的字符。需用一对英文半角格式的双引号（""）引起来。如：“HelloWorld”，“123”，“Welcome \n XXX”，""
5. 布尔常量：包含布尔型的两个值true和false。用于判断真假
6. null常量：只有一个值null，表示对象的引用为空。

字符常量中，反斜杠（＼）被称为转义字符，用来转义后面的字符。转义后的字符通常表示不可见的字符或具有特殊含义的字符，例如换行（\n）。
常用的转义字符：
• \r 　　 　　 回车符，将光标定位到当前行的开头，不会跳到下一行
• \n 　　 　　换行符，换到下一行开头。
• \t 　　 　　 制表符，将光标移到下一个制表符的位置，类似Tab键
• \b 　　 　　退格符，类似Backspace键。

以下字符都有特殊意义，无法直接表示，所以用斜杠加上另一个字符来表示：
• \’ 　　 　　单引号字符，表示字符的开始和结束。
• \" 　　 　　双引号字符，表示字符串的开始和结束。
• \\ 　　 　　反斜杠字符，斜杠（＼）是转义字符，因此需要表示字面意义上的＼，就需要使用双斜杠（\\ ）。

2.2 Java中的变量

用标识符标识的内存单元被称为变量。定义的标识符就是变量名，内存单元中存储的数据就是变量的值。

2.2.1 变量的数据类型

8种基本数据类型 是Java语言内嵌的，在任何操作系统中都具有相同大小和属性；
引用数据类型 是在Java程序中由编程人员自己定义的变量类型。

1. 整数类型变量
   存储整数数值，没有小数部分的值。
   整数类型分为4种。如下图：
   
   注：在为long类型的变量赋值时，需要在值的后面加上母“L”或“l”。如果值没有超出int型的取值范围，则可以省略字母。

[---------------------------------举例子-----------------------------]
 long num = 2200000000L;   //所赋值超出int型取值范围，后面必须加上字母L
 long num1 = 220L;         //所赋值未超出int型取值范围，后面可以加上字母L
 long num2 = 220;          //所赋值未超出int型取值范围，后面可以省略字母L
[----------------------------------举例子-----------------------------]

2. 浮点数类型变量
   存储小数数值；
   double型表示的浮点数比float型更精确。
   
   注：①Java中，小数会被默认为double类型的值。为float类型的变量赋值时，值后需要加上字母“F”或“f”，而为double类型的变量赋值时，值后可加字母“D”或“d”，也可以不加。

[---------------------------------举例子-----------------------------]
  float num = 123.4f;     //为一个float类型的变量赋值，后面必须加上字母f
  double num1 = 100.1;    //为一个double类型的变量赋值，后面可以省略字母d
  double num2 = 100.1d;   //为一个double类型的变量赋值，后面可以加上字母d
[----------------------------------举例子-----------------------------]

②程序中也可以为一个浮点数类型变量赋予一个整数数值。

[---------------------------------举例子----------------------------]
   float num = 100;           //声明一个float类型的变量并赋整数值
   double num1 = 100;         //声明一个double类型的变量并赋整数值
[---------------------------------举例子----------------------------]

3. 字符类型变量
   存储一个单一字符；
   每个char类型的字符变量都会占用2个字节（32位）；
   变量赋值时，需要用一对英文半角格式的单引号＇＇把字符括起来；
   可以将char类型的变量赋值为0-65535范围内的整数，计算机会自动将这些整数转化为所对应的字符，如数值97对应的字符为’a’。

[---------------------------------举例子-----------------------------]
   char c = 'a';     //为一个char类型的变量赋值字符 'a'
   char ch = 97;     //为一个char类型的变量赋值整数97, 相当于赋值字符'a'
[---------------------------------举例子-----------------------------]

4. 布尔类型变量
   存储一个布尔值；
   类型的变量只有两个值，即true和false。

[---------------------------------举例子-----------------------------]
   boolean flag = true;      //声明一个boolean类型的变量，初始值为true
   flag = false;             //改变flag变量的值为false 
[---------------------------------举例子-----------------------------]

2.2.2 变量的类型转换

把一种数据类型的值赋给另一种数据类型的变量时，需要进行数据类型转换。
数据类型转换可分为两种：自动类型转换和强制类型转换。

1. 自动类型转换
   也叫隐式类型转换，指两种数据类型在转换的过程中不需要显式声明。
   需要同时满足两个条件：一是两种数据类型彼此兼容，二是目标类型的取值范围大于源类型的取值范围。

[---------------------------------举例子-----------------------------]
byte b = 3;
int x = b;        //把byte型的变量b转换成int型，无须特殊声明

[由于int类型的取值范围大于byte类型的取值范围，编译器在赋值过程中不会造成数据
丢失，所以编译器能够自动完成这种转换，在编译时不报告任何错误。]
[---------------------------------举例子-----------------------------]

3种可以进行自动类型转换的情况：
　　　　①整数类型之间：
　　　　　　　　byte　-----> 　short,int,long
　　　　　　　　short　----->　int,long
　　　　　　　　int　----->　long
　　　　②整数类型转换为float型：
　　　　　　　　byte,short,int,long　-----> 　float
　　　　③其他类型转换：
　　　　　　　　byte,short,int,long,float　-----> 　double
　　　　　　　　char　-----> 　float,int,long,double

2. 强制类型转换
   也叫显式类型转换，指的是两种数据类型之间的转换需要进行显式地声明。
   当两种类型彼此不兼容，或者目标类型取值范围小于源类型时，自动类型转换无法进行，这时就需要进行强制类型转换。

错误示例：

public class Example{
	public static void main(String[] args){
		int num = 4;
		byte b = num;    //将一个int型的值赋给byte型变量b。int类型的取值范围
大于byte类型的取值范围，这样赋值会导致数值溢出。
		System.out.println(b);
	}
}

解决方案：

修改代码如下：

public class Example{
	public static void main(String[] args){
		int num = 4;
		byte b = (byte)num;   
		System.out.println(b);
	}
}

可以发现代码运行结果为：

注： 对变量进行强制类型转换时，如果是取值范围较大的数据类型向取值范围较小的数据类型的转换，极易造成数据精度的丢失。 （所占内存空间大小不同）

2.2.3 变量的作用域

变量需要先定义后使用，但这并不意味着在变量定义之后的语句中一定可以使用该变量。变量需要在它的作用范围内才可以被使用，这个作用范围称为变量的作用域。
变量一定会被定义在某一对大括号中，一对大括号所包含的代码区域便是这个变量的作用域。

2.3 Java中的运算符

运算符分为：
　　算术运算符、赋值运算符、比较运算符、逻辑运算符和位运算符。

2.3.1 算术运算符

用来处理四则运算的符号。

注：
①进行自增 ++ 和自减 - - 的运算时，如果运算符 ++ 或 - - 放在操作数的前面则是先进行自增或自减运算，再进行其他运算。反之，如果运算符放在操作数的后面则是先进行其他运算再进行自增或自减运算。

[---------------------------------举例子-----------------------------]
   int a = 1;               // a = 1
   int b = 2;               // b = 2
   int x = a+b++;           //因为是“自增(后)”，b先参与运算，再自增
   System.out.print("b="+b);        // 进行到这里,b自增1,b = 3  
   System.out.print("x="+x);        //进行运算时的b还未自增,x = 3
[----------------------------------举例子-----------------------------] 

②进行除法运算时，当除数和被除数都为整数时，得到的结果也是一个整数。如果除法运算有小数参与，得到的结果会是一个小数。

[---------------------------------举例子-----------------------------]
   2510/1000 = 2   //整数之间相除，会忽略小数部分，得到的结果是整数
   2.5/10 = 0.25   //运算中有小数参与,得到的结果会是一个小数
[----------------------------------举例子-----------------------------] 

③进行取模(%)运算时，运算结果的正负取决于被模数（％左边的数）的符号，与模数（％右边的数）的符号无关。

[---------------------------------举例子-----------------------------]
    (-5)%3 = -2       //被模数的符号为负
    5%(-3) = 2
[----------------------------------举例子-----------------------------] 

2.3.2 赋值运算符

将常量、变最或表达式的值赋给某一个变量。

注：
①可以通过一条赋值语句对多个变量进行赋值，

[---------------------------------举例子-----------------------------]
   int x,y,z;
   x=y=z=5;      //为三个变量同时赋值
[----------------------------------举例子-----------------------------] 

但不可以一条赋值语句将变量x,y,z的值同时赋为一个数。
错误示例：

[---------------------------------错误示例-----------------------------]
    int x=y=z=5;     //错误！！！！
[----------------------------------错误示例-----------------------------] 

②以上赋值运算符，除了＝，其他的都是特殊的赋值运算符，以+= 为例，x+=3就相当于x = x+3, 会先进行加法运算x+3, 再将运算结果赋值给变量x。-=、* =、/ = 、 ％＝赋值运算符都可依此类推。

2.3.3 比较运算符

对两个数值或变量进行比较，结果是布尔值。

注： 不能将比较运算符 == 误写成赋值运算符＝。

2.3.4 逻辑运算符

用于对布尔型的数据进行操作，其结果仍是布尔型。

注：
①逻辑运算符可以针对结果为布尔值的表达式进行运算。

[---------------------------------举例子-----------------------------]
         x>3 &&  y!=0 
[----------------------------------举例子-----------------------------] 

②& 和 && 都表示与操作，同真为真，一假则假
运算符 & 和 && 的右边为表达式时，两者在使用上有一定的区别。

在使用 & 进行运算时，不论左边为true或者false,右边的表达式都会进行 运算。
如果使用 && 进行运算，当左边为false时，右边的表达式不会进行运算，因此 && 被称作短路与。

③运算符 | 和 || 都表示或操作，一真则真，同假才假。
|| 表示短路或， 当运算符 || 的左边为true时，右边的表达式不会进行运算。

④运算符 ^ 表示异或操作，不同为真，相同为假。

2.3.5 位运算符

针对二进制数的每一位进行运算的符号，专门针对数字0和1进行操作。

总结：
①与运算符＆是将参与运算的两个二进制数进行“与”运算，如果两个二进制位都为1, 则该位的运算结果为1，否则为0。

②位运算符 l 是将参与运算的两个二进制数进行“或” 运算，如果二进制位上有一个值为1,则该位的运行结果为1，否则为0。

③位运算符～只针对一个操作数进行操作，如果二进制位是0’则取反值为1;如果 是1, 则取反值为0。

④位运算符 ^ 是将参与运算的两个二进制数进行 “异或”运算，如果二进制位相同，则值为0，否则为1。

⑤位运算符 << 就是将操作数所有二进制位向左移动一位。运算时，右边的空位补0。左边移走的部分舍去。

⑥运算符 >> 就是将操作数所有二进制位向右移动一位。 运算时，左边的空位根据原数的符号位补0或者1(原来是负数就补1，是正数就补0)。

⑦位运算符 >>> 就是将操作数所有二进制位向右移动一位。 运算时，左边的空位补0(不考虑原数正负）。

2.4 选择结构语句

分为 if条件语句 和 switch条件语句

2.4.1 if条件语句

三种语法格式：①if语句 ②if…else语句 ③if…else if…else
直接附题：

对一个学生的考试成绩进行等级的划分，如果分数大于80分等级为A，否则，如果分数大于70 分等级为B，否则，如果分数大于 60 分等级为C，否则，等级为D。

提醒：写代码时一定要确定好代码块的作用域！！否则容易出现结果错误！！！

//伪代码！
if(score > 80){
	grade = 'A';
}
else if(score > 70){  //不满足成绩大于80，才能执行这条语句，所以这里不用再繁琐的写"score <= 80 &&score >= 70"
	grade = 'B';
}
else if(score > 60){
	grade = 'C';
}
else{     //前面所有条件都不满足时，才执行这条语句
	grade = 'D';
}

2.4.2 switch条件语句

能针对某个表达式的值做出判断，从而决定程序执行哪一段代码
直接附题：

根据数字来输出中文格式的星期

注：JDK7.0以后，switch语句中的表达式可以是byte、short、char、int、enum枚举、一个String类型的值。

//伪代码
switch(week){
	case 1:   //符合就执行该条语句
		System.out.println("周一");
		break;  //执行完就跳出
	case 2:
		System.out.println("周二");
		break;
	case 3:
		System.out.println("周三");
		break;
	case 4:
		System.out.println("周四");
		break;
	case 5:
		System.out.println("周五");
		break;
	case 6:
		System.out.println("周六");
		break;
	case 7:
		System.out.println("周天");
		break;
	default: //处理和前面的case都不匹配的值
		System.out.println("输入有误");
		break;
}	

2.5 循环结构语句

分为while循环语句、do…while循环语句和for循环语句三种。

2.5.1 while循环语句

若循环条件为真，循环体就会执行。循环体执行完毕会继续判断循环条件，如果条件仍为真则继续执行，直到循环条件为假时才结束。流程图如下：

附题感受：

打印1~4之间的自然数

注：System.out.print("")；输出语句后不换行，输出接在刚才的语句后面
　　System.out.println("")；输出语句后换行，在新的一行输出

//伪代码
x=1;                      //x初始值为1
while(x<=4){              //满足x小于等于4，就进入循环语句
	System.out.println(x);
	x++;                  //x自增，如果不对x进行操作，代码将进入死循环
}

打印效果：

2.5.2 do…while循环语句

与前一种不同，do…while循环语句将循环条件放在循环体的后面。 意味着循环体会无条件执行一次，然后再根据循环条件来决定是否继续执行。流程图如下：

附相同题感受：

打印1~4之间的自然数

注：如果循环条件在循环语句开始时就不成立。
　　while循环的循环体一次都不会执行；
　　do…while循环的循环体仍然会执行一次。

//伪代码
x=1;                      //x初始值为1
do{                       //无论是否满足条件，都会执行一次
	System.out.println(x);
	x++;                  //x自增，如果不对x进行操作，代码将进入死循环
}while(x<=4)              //满足x小于等于4，就进入循环语句

打印效果：

2.5.3 for循环语句

一般用于循环次数已知的情况。for关键字后面( )中包括了三部分内容：初始化表达式、循环条件和操作表达式，它们之间用 ; 分隔，{ }中的执行语句为循环体语法格式如下：

for(初始化表达式；循环条件；操作表达式){
　　 执行语句；
}

附类似题感受：

对自然数1~4之间求和

//伪代码
sum=0;                     
for(i=1;i<=4;i++){          //i的值在1-4之间变化
	sum += i;               //依次计算sum加1、2、3、4的值
}                     
System.out.println(sum);    //打印求和的值

打印效果：

2.5.4 嵌套循环

指在一个循环语句的循环体中再定义一个循环语句的语法结构。
附题感受：

使用 “ * ” 打印直角三角形

//伪代码
for(i=1;i<=20;i++){          //外层循环
	for(j=1;j<=i;j++){		//内层循环
		System.out.print("*");
	}
	System.out.print("\n");
}

打印效果：

=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=未完待续=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=