0002 Java语言基础组成1

Java语言基础组成：
(1)关键字:被Java语言赋予了特殊含义的单词。关键字中所有的字母都为小写。

(2)标识符:在程序中自定义的一些名称。
由
26个英文字母大小写，
数字：0-9
符号：_  $
组成。
定义合法的标识符的规则：
(A)数字不可以开头。
(B)不可以使用关键字。
Java语言严格区分大小写。
注意：在起名字的时候，为了提高阅读性，要尽量有意义。
main也是标识符，但不是关键字。JVM识别main函数，包括main函数的格式。

(3)注释:用于注解说明解释程序的文字。还可以调试程序。
提高了代码的阅读性。
Java语言中的注释格式：
单行注释： //注释文字
多行注释： /*注释文字* /
文档注释: /**注释文字* /

对于单行和多行注释，被注释的文字，不会被JVM解释执行。
因为编译器不会对注释部分进行编译，不论注释的是文字或者程序代码，都不会包含在.class字节码文件中。
该两种注释方式，也是很多高级编程语言都有的注释方式。
单行注释可以嵌套单行注释。
单行注释可以嵌套多行注释。
多行注释中可以嵌套单行注释。
多行注释中不可以嵌套多行注释。


对于文档注释，是Java特有的注释，其中注释内容可以被JDK提高的工具javadoc所解析，
生成一套以网页文件形式体现的该程序的说明文档。

注释是一个程序员必须要具有的良好的编程习惯。
初学者编写程序可以养成习惯，先写注释再写代码。
将自己的思想通过注释先整理出来，再用代码去体现。
因为，代码仅仅是思想的一种体现形式而已。


建议：平时编程就要养成写注释的习惯。没有注释，代码的阅读性很差。


(4)常量和变量
为什么要对常量进行分类？？
目的：方便运算。
整数：有四种表现形式。二进制，八进制(以0开头)，十进制，十六进制(以0x开头)。
小数：
布尔型(boolean)常量：只有两个数值：true和false 。
字符常量：将一个数字，字母或者符号用单引号('')标识。
字符串常量：将一个或者多个字符用双引号("")标识。
null常量：只有一个数值，就是null 。


补充：进制的转换。
结论：
(1)八进制数:其实就是3个二进制位对应1个八进制位。
(2)十六进制数:其实就是4个二进制位对应1个十六进制位。
(3)二进制转换为十进制：按权展开多项式，乘以2的幂数。
(4)十进制转换为二进制：除以2取余数。


负数的二进制表现形式：对应的正数二进制取反加1
例如：-6=(1111-1010)
+6=(0000-0110)

~0000-0110

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

  1111-1001

+0000-0001

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

  1111-1010


负数的二进制位的最高位为1。负数的补码是正数的反码，再加1。
正数的二进制位的最高位为0。正数的补码是其本身。




变量的概念：
内存中的一个存储区域。
该区域有自己的名称(变量名)和类型(数据类型)。
该区域的数据可以在同一类型范围内不断变化。


为什么要定义变量？
用来不断的存放同一类型的常量，并可以重复使用。


什么时候使用变量？？
当用数据不确定的时候，需要使用变量。


使用变量注意：
变量的作用范围(一对{}之间有效)
初始化值。


定义变量的格式：
数据类型  变量名 = 初始化值


注：格式是固定的，记住格式，以不变应万变。
理解：变量就如同数学中的未知数。


Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，
在内存中分配了不同大小的内存空间。


数据类型：基本数据类型 和 引用数据类型 。
基本数据类型：数值型 、字符型(char) 、布尔型(boolean) 。
数值型：整数类型(byte,short,int,long)、浮点类型(float,double)。
引用数据类型：类(class)、接口(interface)、数组([]) 。
整数默认：int
小数默认：double


byte：1个字节(-128 ~ 127)
short:2个字节(-32768 ~ 32767)
int:4个字节( -2147483648 ~ 2147483647)
long:8个字节(-9223372036854775808 ~ 9223372036854775807)，结尾加小写字母l 。
例如：long l = 123l;


float:4个字节，结尾加小写字母f 。例如：float f = 2.3f;
double:8个字节


char:2个字节(0 ~ 65535)。char在Java中是16位的，因为Java用的是Unicode。
boolean：ture 、false。


变量必须初始化值。
变量有自己作用的范围。(变量的作用域)


类型提升强制转换：
自动类型转换(也叫“隐式类型转换”)
强制类型转换(也叫“显式类型转换”)
类型转换的原理：
什么时候要用强制类型转换？？
表达式的数据类型自动提升
所有的byte型、short型和char型的值将被提升到int型。
如果一个操作数是long型，计算结果就是long型。
如果一个操作数是float型，计算结果就是float型。
如果一个操作数是double型，计算结果就是double型。
float和int运算，结果是float类型。
boolean类型不能进行算术运行。因为算术运算符的两边要求是数值型。而boolean不是数值型。 
char类型在内存中也是数值。JVM内置了一张unicode国际标准码表。支持世界各国文字，当然也包括了中文和英文。
当表达式中有char类型的数据和数值型数据进行算术运算的时候，是先找字符对应的数值，然后参与运算。
总之，无论是数值型，字符型，还是图片数据，在内存中都是二进制数据。

类型运算细节(一道面试题)：


byte b = 4; //4是int类型。编译器在编译时，做了这样一个动作。运算符的左边是byte类型，只能存储一个字节的数据，取值范围在128~127 。编译器去检查运算符右边，这个数值是否在这个范围内，如果在这个范围内的话，那么就做强制转换，只保留int类型的最后一个字节，赋值给byte 。
//编译器自动检查右边数据的范围，只要在byte的范围内，将int强制转换为byte 。

b = 3 + 7;


byte b1 = 3;
byte b2 = 7;
b = b1 + b2;//这里编译器要报可能损失精读，因为运算符的右边是变量，编译器无法确定其值的范围是否在byte允许的范围内，所以报错。

int x;
x = b1 + b2;//这里是可以的，原则：只要能装的下就行。

int x1 = Integer.MAX_VALUE;
int x2 = 2;

x = x1 + x2;//这里会发生溢出，两个正数相加，结果为一个负数。因为int 是整数的默认类型，所以，这里编译器没有报错。而是自动保留低32位，将多出的高位去掉。


分析：
System.out.println('a');
System.out.println('a'+1);


(5)运算符
算术运算符 +-*/(取整)%(取余:模运算)结果的正负取决于被模数(左边的数)+(连接)任何数据类型只要和字符串进行+运算，结果都是字符串连接。连接成了一个更大的字符串。
++(自增:在原有数据的基础上加1，再赋给原有数据)
例如：
int i = 3;
i = i++;
i的结果是？？结果：i = 3
分步：
temp = i;
i = i+1;  //i = 4
i = temp;  //i = 3


--(自减)

赋值运算符 =+=-=*= /= %=
例如：int a,b,c;
 int a = b = c = 4;


 int a = 4;
 a += 2;//a = a + 2;




 一道面试题：
 short a = 3;


 s += 4;//编译正常通过，并且可以运行。底层进行自动转换，将s+4的结果(int)，先检查是否在short的范围内，如果在的其范围内，将int类型自动转换为short类型。
 s = s + 4;//编译时报错，因为运算符右边有变量，编译器无法确定其值的范围是否在short的范围内。底层不进行转换。
s + 4结果是int类型，这里做了自动类型提升。int不能直接赋值给short，因为装不下，会损失数据精度。


 问：上面两个语句有什么区别？？
其实，s += 4;//与s = (short)(s + 4);才是等价的。
前者自动做强转；后者不自动强转，只能显示的强转。
自动转换，是赋值运算所具有的特点。



比较运算符:运算完的结果必须是true或者false 。
== !=>>=< <=
instanceof ：检查是否是类的对象 。
例如：“hello” instanceof String 
结果：true
注意：比较运算符“==” 不要写成赋值运算符“=”


逻辑运算符：& | ^ !&&||
逻辑运算符有什么用呢？？
用于连接两个BOOLEAN类型的表达式。


&:”与“。该运算符的特点：
true & true = true
true & false = false
false & true = false
false & false = false
运算规律：&运算符的两边只要有一个是false，结果肯定是false 。
只有两边都为true，结果才是true。


|:”或“。运算特点。
true | true = true
true | false = true
false | true = true
false | false = false
运算规律：|运算符两边只要有一个是true，结果肯定是true。
只有两边都是false，结果才是false。


^：”异或“。和或有点不一样。
true ^ true = false
true ^ false = true
false ^ true = true
false ^ false = false
运算规律：^运算符的两边的结果相同，结果是false。
两边的结果不同，结果是true.



！：”非“。运算特点。
!true = false
!false = true


面试题：


&&:和&的结果是一样的。但是运算过程有一点小区别。

&：无论左边的运算结果是什么。右边都参与运算。
&&：当左边为false时，右边不参与运算。




||：和|的结果是一样的。但是运算过程有一点小区别。


|：无论左边的运算结果是什么。右边都参与运算。
||：当左边为true时，右边不参与运算。




位运算符:
<<(左移):相当于乘以2的倍数。
<< ：可以完成2的次幂运算。
例如：3 << 2 = 3 * 2(2) = 12


>>(右移):相当于除以2的倍数。
右移几位其实就是该数据除以2的几次幂。
>> :对于高位出现的空位，原来的高位是什么就用什么补这个空位。
例如：6 >> 1 = 6 / 2(1) = 3
 6 >> 2 = 6 / 2(2) = 1
 -6 >> 1 = -6 / 2(1) = -3
 -6 >> 2 = -6 / 2(2) = -1

注：移N位，就是对乘以或者除以2的N次幂。




>>>(无符号右移) :数据进行右移时，高位出现的空位，无论原高位是什么，空位都用0补。




&(与)：这是&和&&的第二个区别，就是说&还可以进行位运算。
举例：6 & 3 = 2


   0000-0000  0000-0000  0000-0000  0000-0110
& 0000-0000  0000-0000  0000-0000  0000-0011
------------------------------------------------------------------
   0000-0000  0000-0000  0000-0000  0000-0010

&(与运算)的小特点：想保留哪些位，就可以与1进行&运算。




|(或)
举例：6 | 3 = 7

  0000-0000  0000-0000  0000-0000  0000-0110
| 0000-0000  0000-0000  0000-0000  0000-0011
--------------------------------------------------------------------------
  0000-0000  0000-0000  0000-0000  0000-0111


|(与运算)的小特点：两个二进制位串进行|或运算，凡是有1的位置全部保留。
1是有效位，或的特点在于可以将有效位保留。


例如：
   110
|  011
--------
   111






^(异或) ： 相同为0，不同为1。
一个数异或同一个数两次，结果还是该数本身。

举例：6 ^ 3 = 5 
 6 ^ 3 ^ 3 = 6 


    110
^   011
---------
    101
^   011
---------
    110




~(反码)：按位取反。
~ 0000-0000 0000-0000 0000-0000 0000-0110
--------------------------------------------------------------------------
   1111-1111 1111-1111 1111-1111 1111-1001

6的反码 + 1 = -6的补码
所以，6的反码 = -7的补码
两者在内存中的表现形式是一致的。




位运算：是直接对二进制位进行运算。


位运算练习：
(1)用最高效的方法计算2*8？
2 << 4 = 16


(2)对两个整数变量的值进行互换（不需要第三方变量）？
例如：a = 3, b = 5;


//借助第三方变量实现两个变量的互换。该种方式在实际开发中最常使用，建议使用该方式。
实际开发中使用，因为其阅读性最好。执行的效率也不会比位运算低多少，我们折中一下，所以，选择该种方式、
int c;
c = a;
a = b;
b = c;


//该种方式不建议使用。如果两个整数的数值过大，会超出int范围，会强制转换，数据会损失精度。
a = a + b; //a = 3+5 ; a = 8;
b = a - b; //b = 8 - 5;b = 3;
a = a - b; //a = 8 - 3;a = 5;


//通过位运算。规律：一个数异或另一个数两次，结果还是这个数。该种方式在实际开发中，不要使用，因为其阅读性差。
面试的时候用。
a = a ^ b;
b = a ^ b;
a = a ^ b;

三元运算符：三个元素参与运算。
格式： 
(条件表达式) ？表达式1 ：表达式2;
如果条件为true，运算后的结果是表达式1;
如果条件为flase，运算后的结果是表达式2;


示例：获取两个数中的大数。
int x = 3,y = 4,z;
z = (x>y) ? x : y;//z变量存储的就是两个数的大数。
条件表达式：其结果只能是true或者false 。


获取三个数中的大数。
int o,p,q;
int temp = o>p ? o : p;
int max2 = temp>q ? temp : q;