二、Java语言基础

2.1基础语言要素

1）标识符：给类、方法、变量起的名字

A．必须以字母或下划线或 $ 符号开始，其余字符可以是字母、数字、$ 符号和下划线。

B．只能包含两个特殊字符，即下划线 _ 和美元符号 $ 。不允许有任何其他特殊字符。

C．标识符不能包含空格。

D．区分大小写。

2）关键字：只有系统才能用的标识符

注意事项：

① true、false、null不是关键字！是字面量。

② main不是关键字！但是是一个特殊单词，可以被JVM识别，主函数是固定格式，作为程序的入口。

3）注释：

　　单行注释：//

　　多行注释：/* ……*/

　　文档注释：/**……*/

注意事项：开发中类前、属性前、方法前，必须有文档注释。

2.2八种基本数据类型

1）四种整数类型(byte、short、int、long)：

byte：8位，用于表示最小数据单位，如文件中数据，-128~127

short：16位，很少用，-32768 ~ 32767

int：32位、最常用，-2^31-1~2^31 （21亿）

long：64位、次常用

注意事项：

① int i=5; // 5叫直接量（或字面量），即直接写出的常数。

② 整数字面量默认都为int类型，所以在定义的long型数据后面加L或l。

③ 小于32位数的变量，都按int结果计算。

④ 强转符比数学运算符优先级高。见常量与变量中的例子。

2）两种浮点数类型(float、double)：

float：32位，后缀F或f，1位符号位，8位指数，23位有效尾数。

double：64位，最常用，后缀D或d，1位符号位，11位指数，52位有效尾数。

注意事项：

① 二进制浮点数：1010100010=101010001.0*2=10101000.10*2^10(2次方)=1010100.010*2^11(3次方)= . 1010100010*2^1010(10次方)

② 尾数： . 1010100010 指数：1010 基数：2

③ 浮点数字面量默认都为double类型，所以在定义的float型数据后面加F或f；double类型可不写后缀，但在小数计算中一定要写D或X.X。

④ float 的精度没有long高，有效位数（尾数）短。

⑤ float 的范围大于long 指数可以很大。

⑥ 浮点数是不精确的，不能对浮点数进行精确比较。

3）一种字符类型(char)：

char：16位，是整数类型，用单引号括起来的1个字符（可以是一个中文字符），使用Unicode码代表字符，0~2^16-1（65535）。

注意事项：

① 不能为0个字符。

② 转义字符：换行

　　　　　　回车

　　　　　　 Tab字符

　　　　　　" 双引号

　　　　　　\ 表示一个

③ 两字符char中间用“+”连接，内部先把字符转成int类型，再进行加法运算，char本质就是个数！二进制的，显示的时候，经过“处理”显示为字符。

4）一种布尔类型(boolean)：true真和false假。

5）类型转换： char-->

自动转换：byte-->short-->int-->long-->float-->double

强制转换：① 会损失精度，产生误差，小数点以后的数字全部舍弃。

　　　　 ② 容易超过取值范围。

2.3常量和变量

变量：内存中一块存储空间，可保存当前数据。在程序运行过程中，其值是可以改变的量。

1）必须声明并且初始化以后使用（在同一个作用域中不能重复声明变量）！

2）变量必须有明确类型（Java是强类型语言）。

3）变量有作用域（变量在声明的地方开始，到块｛｝结束）。变量作用域越小越好。

4）局部变量在使用前一定要初始化！成员变量在对象被创建后有默认值，可直接用。

5）在方法中定义的局部变量在该方法被加载时创建。

常量：在程序运行过程中，其值不可以改变的量。

注意事项：

① 字面量、常量和变量的运算机制不同，字面量、常量由编译器计算，变量由运算器处理，目的是为了提高效率。

eg：小于32位数的字面量处理

byte b1 = 1;

byte b2 = 3;

//byte b3 = b1+b2;//编译错误，按照int结果，需要强制转换

byte b3 = (byte)(b1+b2);

//byte b3 = (byte)b1+(byte)b2;//编译错误！两个byte、short、char相加还是按int算

System.out.println(b3); //选择结果：A编译错误 B运行异常 C 4 D b3

byte b4 = 1+3;//字面量运算，编译期间替换为4，字面量4

//byte b4 = 4; 不超过byte就可以赋值

② 不管是常量还是变量，必须先定义，才能够使用。即先在内存中开辟存储空间，才能够往里面放入数据。

③ 不管是常量还是变量，其存储空间是有数据类型的差别的，即有些变量的存储空间用于存储整数，有些变量的存储空间用于存储小数。

2.4运算符与表达式

1）数学运算：+ - * / % ++ --

注意事项：

① + - * / 两端的变量必须是同种类型，并返回同种类型。

② % 取余运算，负数的余数符号与被模数符号相同， - 1 % 5 = - 1，1 % - 5 = 1；Num % n，n>0，结果范围[0,n)，是周期函数。

③ 注意整除问题：1 / 2 = 0（整数的除法是整除）1.0 / 2 = 0.5 1D / 2 = 0.5

④ 单独的前、后自增或自减是没区别的，有了赋值语句或返回值，则值不同！

eg1：自增自减

　　int a = 1;

　　a = a++;

　　System.out.println("a的值："+a);

　　分析：

　　第1步：后++，先确定表达式a++的值（当前a的值） a++ ---->1

　　第2步：++，给a加1 a ---->2

　　第3步：最后赋值运算,把a++整个表达式的值赋值给a a ---->1

　　综上：a被赋值两次，第1次a = 2，第2次把1赋值给a

eg2：自增自减

　　x，y，z分别为5，6，7 计算z + = -- y * z++ ；

　　结果： x = 5，y = 5，z = 42

　　分析：　z = z + -- y * z++ => 42 = 7 + 5 * 7 从左到右入栈，入的是值

eg3：取出数字的每一位

　　d = num%10;//获取num的最后一位数 num/=10; //消除num的最后一位

2）位运算：& | ~（取反） ^（异或）>> << >>>

注意事项：

① 一个数异或同一个数两次，结果还是那个数。

② |：上下对齐，有1个1则为1；

　　&：上下对齐，有1个0则为0；（都为二进制）

③ &相当于乘法，| 相当于加法；

&：有0则为0，| ：有1则为1，^：两数相同为0，不同为1。

3）关系运算符：> < >= <= == !=

4）逻辑运算符：&& ||（短路） ! & |

　　eg：短路运算：&&：前为flase，则后面不计算；|| ：前为true，则后面不计算

　　　　int x=1,y=1,z=1;

　　　　if(x--==1 && y++==1 || z++==1) // 前面&&运算结果已经为true，则 || 短路运算后面的不执行了！

　　　　System.out.println(“x=”+x+”,y=”+y+”,z=”+z);// 0 , 2, 1

5）赋值运算符：= += -= *= /= %=

　　eg：正负1交替

　　int flag= -1;

　　System.out.println(flag *= -1); ……

6）条件（三目）运算符：表达式1 ？表达式2 ：表达式3

注意事项：

① 右结合性：a > b ? a : i > j ? i : j 相当于 a > b ? a : ( i > j ? i : j )

②三目运算符中：第二个表达式和第三个表达式中如果都为基本数据类型，整个表达式的运算结果类型由容量高的决定。

　　如：int x = 4;

　　　　 x > 4 ? 99.9 : 9; // 99.9是double类型，而9是int类型，double容量高，所以最后结果为9.0。

　　　　 x > 4 ? 10 : 9; // 两个数据类型一致 int，则最后结果为9

7）运算符优先级：括号 > 自增自减 > ~ ! > 算数运算符 > 位移运算 > 关系运算 > 逻辑运算 > 条件运算 > 赋值运算

2.5编程风格

MyEclipse/Eclipse中出现的红色叉叉：编译错误

编译错误：java编译器在将Java源代码编译为class文件的过程出现的错误，一般是语法使用错误！当有编译错误时候，是没有class文件产生，也就不能运行程序。

Java 程序结构：

2.6流程控制语句

1）选择控制语句

if语句：if 、if-else、if-else-if：可以处理一切分支判断。

格式：if(判断){…}、if(判断){…}else{…}、if(判断){…}else if(判断){…}

switch语句：switch(必须整数类型){case 常量1：…; case 常量2：… ; ….}

注意事项：

① int类型指：byte、short、int，只能写long类型，要写也必须强转成int类型；而byte、short为自动转换成int。

② swtich-case：若case中无符合的数，并且default写在最前（无break时），则为顺序执行，有break或 } 则退出。

③ swtich-case：若case中无符合的数，并且default写在最后，则执行default。

④ swtich-case：若case中有符合的数，并且default写在最后，并且default前面的case没有break时，default也会执行。

2）循环控制语句

①for：最常用，用在与次数有关的循环处理，甚至只用for可以解决任何循环问题。

注意事项：for中定义的用于控制次数的循环变量，只在for中有效，for结束则循环变量被释放（回收）。

②while：很常用，用在循环时候要先检查循环条件再处理循环体，用在与次数无关的情况。

　　　　如果不能明确结束条件的时候，先使用while(true)，在适当条件使用if语句加break结束循环。

③do-while：在循环最后判断是否结束的循环。

　　　　如：使用while(true) 实现循环的时候，结束条件break在while循环体的最后，就可以使用 do-while 。

　　　　　　do-while 的结束条件经常是“否定逻辑条件”，不便于思考业务逻辑，使用的时候需要注意。可以利用while（true）+ break 替换。

④循环三要素：A．循环变量初值 B．循环条件 C．循环变量增量（是循环趋于结束的表达式）

⑤for和while循环体中仅一条语句，也要补全{ }，当有多条语句，且不写{ }时，它们只执行紧跟着的第一条语句。

⑥循环的替换：

　　while(布尔表达式){} 等价 for(;布尔表达式;){}

　　while(true){} 等价 for(;;)

　　while(true){} + break 替换 do{}while(布尔表达式);

　　for(;;) + break 替换 do{}while(布尔表达式);

3）跳转控制语句

continue：退出本次循环，直接执行下一次循环

break：退出所有循环

2.7数组

类型一致的一组数据，相当于集合概念，在软件中解决一组，一堆XX数据时候使用数组。

1）数组变量：是引用类型变量（不是基本变量）引用变量通过数组的内存地址位置引用了一个数组（数组对象），即栓到数组对象的绳子。

eg：数组变量的赋值

int[] ary = new int[3];// ary----->{0,0,0}<----ary1

int[] ary1 = ary; // ary 的地址赋值给ary1，ary 与 ary1 绑定了同一个数组

//ary[1] 与 ary1[1] 是同一个元素，数组变量不是数组（数组对象）

2）数组（数组对象）有3种创建（初始化）方式：

　　①new int[10000] 给元素数量，适合不知道具体元素，或元素数量较多时

　 ②new int[]{3,4,5} 不需要给出数量，直接初始化具体元素适合知道数组的元素。

　　③ {2,3,4} 静态初始化，是②简化版，只能用在声明数组变量的时候直接初始化，不能用于赋值等情况。

　　eg：数组初始化

　　　　int[] ary1 = new int[]{2,3,4}; //创建数组时候直接初始化元素

　　　　int[] ary2 = {2,3,4}; //数组静态初始化，只能在声明变量的同时直接赋值

　　　　//ary2 = {4,5,6};//编译错误，不能用于赋值等情况

　　　　ary2 = new int[]{4,5,6};

3）数组元素的访问：

　　①数组长度：长度使用属性访问，ary.length 获取数组下标。

　　②数组下标：范围：0 ~ length-1就是[0,length)，超范围访问会出现下标越界异常。

　　③使用[index] 访问数组元素：ary[2]。

　　④迭代（遍历）：就是将数组元素逐一处理一遍的方法。

4）数组默认初始化值：根据数组类型的不同，默认初始化值为：

　　0（整数）

　　0.0（浮点数）

　　false（布尔类型）

　　u0000（char字符类型，显示无效果，相当于空格，编码为0的字符，是控制字符，强转为int时显示0）

　　null（string类型，什么都没有，空值的意思）。

5）数组的复制：数组变量的赋值，是并不会复制数组对象，是两个变量引用了同一个数组对象。

　　　　　　　　数组复制的本质是创建了新数组，将原数组的内容复制过来。

6）数组的扩容：创建新数组，新数组容量大于原数组，将原数组内容复制到新数组，并且丢弃原数组，

　　　　　　　　简单说：就是更换更大的数组对象。

　　　　　　　　System.arraycopy() 用于复制数组内容，简化版的数组复制方法：Arrays.copyOf()方法，但需JKD1.5+。

2.8字符串

字符串(string)：永远用“”双引号（英文状态下），用字符串连接任何数据（整数），都会默认的转化为字符串类型。

字符串与基本数据类型链接的问题：

①如果第一个是字符串那么后续就都按字符串处理，

　　如System.out.println("(Result)"+6 + 6 ); 那么结果就是(Result)66，

②如果第一个和第二个…第n个都是基本数据，第n+1是字符串类型，那么前n个都按加法计算出结果在与字符串连接。

　　如下例中的System.out.println(1+2+”java”+3+4); 结果为3java34。

eg：字符串前后的“+”都是连接符！不是加法运算符！

　　System.out.println("A"+'B');//AB

　　System.out.println('A'+'B');//131

　　System.out.println(1+2+”java”+3+4);//3java34

注意事项：比较字符串是否相等必须使用equals方法！不能使用==。

　　 "1".equals(obj) 比 obj.equals("1") 要好。因为若obj= null，那么obj.equals("1") 会报 NullPointerException,而前面的表达式不会

2.9方法三要素

方法：method（函数function = 功能） y=f(x)

1）方法的主要三要素：方法名、参数列表、返回值。

2）什么是方法：一个算法逻辑功能的封装，是一般完成一个业务功能，如：登录系统，创建联系人，简单说：方法是动作，是动词。

3）方法名：一般按照方法实现的功能定名，一般使用动词定义，一般使用小写字母开头，第二个单词开始，单词首字母大写。如：createContact() 。

4）参数列表：是方法的前提条件，是方法执行依据，是数据。如：

5）方法返回值：功能执行的结果，方法必须定义返回值，并且方法中必须使用return语句返回数据；如果无返回值则定义为void，此时return语句可写可不写；返回结果只能有一个，若返回多个结果，要用数组返回（返回多个值）。

注意事项：递归调用：方法中调用了方法本身，用递归解决问题比较简练，只需考虑一层逻辑即可！但是需要有经验。一定要有结束条件！如：f(1)=1; 递归层次不能太深。总之：慎用递归！

2.10插入排序

将数组中每个元素与第一个元素比较，如果这个元素小于第一个元素，则交换这两个元素循环第1条规则，找出最小元素，放于第1个位置经过n-1轮比较完成排序。

for(inti = 1; i < arr.length; i++) {

int k = arr[i];// 取出待插入元素

int j;// 找到插入位置

for (j = i - 1; j >= 0 && k < arr[j]; j--) {

arr[j + 1] = arr[j];// 移动元素

}

arr[j + 1] = k;// 插入元素

System.out.println(Arrays.toString(arr));

}

2.11冒泡排序

比较相邻的元素，将小的放到前面。

for(inti = 0; i < arr.length - 1; i++) {

boolean isSwap = false;

for (int j = 0; j < arr.length - i - 1; j++) {

if (arr[j] > arr[j + 1]) {

int t = arr[j];

arr[j] = arr[j + 1];

arr[j + 1] = t;

isSwap = true;

}

if (!isSwap){ break; }

System.out.println(Arrays.toString(arr));

}

2.12冒泡排序：轻气泡上浮的方式

冒泡排序法可以使用大气泡沉底的方式，也可以使用轻气泡上浮的方式实现。如下为使用轻气泡上浮的方式实现冒泡排序算法。

for (int i = 0; i < arr.length - 1; i++) {

boolean isSwap = false;

for (int j = arr.length - 1; j > i; j--) {

if (arr[j] < arr[j - 1]) {

int t = arr[j];

arr[j] = arr[j - 1];

arr[j - 1] = t;

sSwap = true;

}

if (!isSwap){ break; }

System.out.println(Arrays.toString(arr));

}

2.13二分法查找

intlow = 0; inthigh = arr.length - 1; intmid = -1;

while(low <= high) {

mid = (low + high) / 2;

if (arr[mid] < value){ low = mid + 1; }

else if (arr[mid] > value){ high = mid - 1; }

else{ break;}

}

if (low <= high) { System.out.println("可以找到：index = " + mid + "。");

} else { System.out.println("无法找到！"); }

二分法思想是取中，比较：

1）求有序序列arr的中间位置mid。 2）k为要查找的数字。

若arr[mid] == k，查找成功；

若arr[mid] > k，在前半段中继续进行二分查找；

若arr[mid] < k，则在后半段中继续进行二分查找。

假如有一组数为3、12、24、36、55、68、75、88要查给定的值k=24。可设三个变量low、mid、high分别指向数据的上界，中间和下界，mid=（low+high）/2.

1）开始令low=0（指向3），high=7（指向88），则mid=3（指向36）。因为k<mid，故应在前半段中查找。

2）令新的high=mid-1=2（指向24），而low=0（指向3）不变，则新的mid=1（指向12）。此时k>mid，故确定应在后半段中查找。

3）令新的low=mid+1=2（指向24），而high=2（指向24）不变，则新的mid=2，此时k=arr[mid]，查找成功。

如果要查找的数不是数列中的数，例如k=25，当第四次判断时，k>mid[2]，在后边半段查找，令low=mid+1，即low=3(指向36)，high=2（指向24）出现low>high的情况，表示查找不成功。

2.14 Java系统API方法调用

Arrays类，是数组的工具类，包含很多数组有关的工具方法。如：

1）toString() 连接数组元素为字符串，方便数组内容输出。

2）equals 比较两个数组序列是否相等。

3）sort() 对数组进行排序，小到大排序。

4）binarySearch(names, "Tom") 二分查找，必须在有序序列上使用。

2.15二进制基础

1）计算机中一切数据都是2进制的! 基本类型，对象，音频，视频。

2）10进制是人类习惯，计算按照人类习惯利用算法输入输出。

"10" -算法转化-> 1010(2) 1010 -算法转化-> "10"

3）16进制是2进制的简写，16进制就是2进制！

4）计算机硬件不支持正负号，为了解决符号问题，使用补码算法，补码规定高位为1则为负数，每位都为1则为-1，如1111 1111 = -1 = 0xff

5）二进制数右移>>：相当于数学 / 2(基数)，且正数高位补0，负数高位补1；

　二进制字左移<<：相当于数学 * 2(基数)，且低位补0；

二进制数无符号右移>>>：相当于数学 / 2(基数)，且不论正负，高位都补0。

6）注意掩码运算：把扩展后前面为1的情况除去，与0xff做与运算。

eg1：二进制计算

int max = 0x7fffffff; long l = max + max + 2; System.out.println( l );// 0

eg2：二进制运算（拼接与拆分）

int b1 = 192; int b2 = 168; int b3 = 1; int b4 = 10; int color = 0xD87455;

int ip = (b1<<24) + (b2<<16) + (b3<<8) + b4; // 或者ip = (b1<<24) | (b2<<16) | (b3<<8) | b4;

int b = color&0xff; // 85 int g = (color >>> 8)&0xff; // 116 int r = (color >>> 16)&0xff;// 216

2.16 Java基础其他注意事项

① Java程序严格区分大小写。

② 类名，每个单词首字母必须大写（公司规范！）。

③ 一个Java应用程序，有且只有一个main方法，作为程序的入口点。

④ 每一条Java语句必须以分号结束。

⑤ 类定义关键字class前面可以有修饰符（如public），如果前面的修饰符是public，该类的类名必须要与这个类所在的源文件名称相同。

⑥ 注意程序的缩进。

⑦ double a[] = new double[2]; //语法可以，但企业中一定不要这么写，Java中[]建议放前面如： double[] a = new double[2]; 。

⑧ Java中所有范围参数都是包含0，不包含结束，[ ) : 如int n = random.nextInt(26); //生成0到26范围内的随机数，不包括26。

⑨ 任何数据在内存中都是2进制的数据，内存中没有10进制16进制。

⑩ int n = Integer.parseInt(str);//将字符串--> int 整数。

⑩①　System.out.println(Long.toBinaryString(maxL)); Long类型用Long.XXXX 。

⑩②　程序：数据+算法数据即为变量，算法为数据的操作步骤，如：顺序、选择、循环。

⑩③　字符串按编码大小排序。