黑马程序员_二 【注释】【标识符】【常量】【变量】【进制】【运算符】

--------------------- android培训、java培训、java学习型技术博客、期待与您交流！ -------------------

 0小小论述：

       终于开始做新的笔记，过多的文字笔记稍微有点乏味，编程还是代码来的更实在一些。随着这时基础部分，但是在大学期间也没有学的这么细致，相比笔记只是略懂一二，现在会更加努力的把每一部分笔记作好，把每一部分基础学好，OK，开始吧！本篇主要讲述：注释、标示符、常量和变量、进制、运算符关键字。

 1 注释：

       每种编程语言都有属于自己的注释规范，Java语言的注释有这两种，单行注释和多行注释。单行注释更适合用于解释某一句语句，当然也可以简单地注释某一段语句。用 “//注释的话语” 形式表示。多行注释用 “/*注释的话语*/” 形式来表示。看下面的例子解析：

[java] view plaincopy

1. //下面是一个简单的Java小程序  
2. class Demo  
3. {  
4.     /* 
5.     main方法是一个静态方法，参数是一个字符串数组类型的， 
6.     没有返回值。是程序的入口。 
7.     */  
8.     public static void main(String[] args)   
9.     {  
10.         System.out.println("我要去黑马！");//这是一个输出语句；  
11.     }  
12. }  

注释的用法很简单，但也有需要注意的地方。当用到多行注释时，/* 注释语句/*    */  注释语句  */  这种写法是不允许的，会出现错误，好在Java的集成开发环境会有错误提示。

 2标识符：

是指在程序中自定义的一些名称。可以简单的理解为像标识一样的符号，也有特殊的含义，能够被识别。其组成由26个英文字母（大小写皆可），数字（0-9）和符号（_ $）几个部分。其有一定的规则，也就是书写规范：数字不可以开头，不可以使用java中的关键字。 Java中是区分大小写的。自定义名称是尽量让名称有意义。

如我们定义类名，函数名等，一个类定义成 class Person_1，名称Person_1是合法的，定义成1_Person是不合法的（数字不能开头）；如果想定义一个类来说明人这类事物的特性，定义成  class Demo ，这虽然是合法的，但是当读到这个名字的时候不能够理解它是要描述什么的，阅读性差，没有特定的含义，定义成Person，就能知道是用来描述人的，名称尽量有意义。

值得注意的一点是：main 在java中不是关键字，但是它是可以被识别的，是虚拟机执行程序时的入口。

Java中的命名规范：

@包名：多个单词组成时所有字母都小写，如package1

@类或接口名：多个单词组成时，所有单词的首字母大写，如PersonBoy、PersonGirl，这样书写易读，如果是personboy、persongirl，并不会出现错误，但阅读起来就不那么容易了。

@变量名和函数名：多个单词组成时，第一个单词首字母小写，后面的单词首字母都大写，如personSetName()、personName()。

@常量名：所有字母都大写，多单词时每个单词用下划线连接，如NAME_MAX。

 3标识符 常量和变量：

常量 表示不能改变的数值。Java中的常量分为：

   @整数型常量，包含所有整数。

   @小数型常量，包含所有小数。

   @布尔型常量，只有两个数值：true和false。

   @字符型常量，将一个数字、字母或者符号用单引号（' '）标识。

   @字符串常量，将一个或多个字符用双引号（" "）标识。

   @null常量，只有一个值就是null。

 变量 实在内存中开辟的一个空间，将不确定的数据进行内存存储。也就是说，要想使用变量就要在内存开辟空间，要定义变量名称来用。空间开皮厚，该空间只能存放同一种类型的数据，若是整数都是整数，若是字符都是字符，要分空间类型，即所定义的 变量名称 的类型，也就是数据类型。Java中对类型的划分是非常细致的。

 使用变量有三个要素：明确数据类型、变量名称和数据。在Java中有各种类型的定义关键字：

                                                                   ——整数类型（byte、short、int、long）

                                               ——数值型-|

                                              |                    —— 浮点类型（flost、double）

                 ——基本数据类型-——字符型（char）

                |                             |

                |                             ——布尔型（boolean）

@数据类型-

                |                             —— 类（class）

                |                            |

                ——引用数据类型- ——接口（interface）

                                             |

                                              ——数组（ [ ] ）

@其中整数型的Java默认： int，小数型的Java默认：double。

@定义变量，简单的例子：int num=9；//定义一个int类型的整数num，数值是9; char ch='h';//定义一个字符'h'； double d=3.14;//定义一个double类型的小数，数值是3.14；既然是变量，那么其空间可以被重新利用，int num=9；之后再定义num=10；num的值就变成了10，折是变量的特带你，以不变（变量名称）应万变（数值）。

 4 进制：

对于整数，进制在Java中有三种表现形式：十进制、八进制、十六进制。十进制数由0-9数字组成，满10进1，者最为熟悉； 八进制数由0-7数字组成，满8进1，开头用0表示，如091，八进制不常用，因为容易和二进制混淆，如0110；十六进制有0-9数字和大写字母A-F，其中A-F分表表示10-15，满15进1，开头用0x表示。

而计算机识别的是二进制，只有0和1 。满2进1。如同开关一般，容易识别。而其他进制在进行运算时就需要转换成二进制让计算机识别，就产生了进制之间的转换。

 @十进制转二进制： 原理是对十进制进行除2运算。如下图：

                                                                             

十进制数6换二进制，执行除2取余动作，然后将余数从下往上排列得出110二进制数。                                                    

  @二进制转十进制：这个转换是乘2的过程。如二进制的110，最低位0成2的0次幂。加上上一位1乘2的1次幂。再加其傻瓜一位1成2的2次幂。如下所示：

                                      

          

二进制转换十进制，从最低位以0号开始计算，二进制数对应的位上的数 乘2的 对应号次幂相加的和。 

@其他进制转换：如八进制转换成二进制，十六进制转换成二进制等，先把其转换成十进制，再转换成二进制。四个二进制位表示一个十六进制位，0101-1010对应两位十六机制。所以其转换成十六进制是5A。三个二进制位表示一个八进制位 ，如010-110对应两位八进制数：26。这部分还算简单。

 5 运算符：

常量和变量有了，接下来就是用它们。运算符就是在用常量或者变量进行运算时，经常用到的符号，目前常用的一共有10种：算术运算符、赋值运算符、关系运算符、逻辑运算符、位运算符、移位运算符、三元运算符、逗号运算符、字符串运算符、转型运算符。

@算术运算符：最常见的加、减、乘、除、余，在Java中是+、 -、 *、 /、 %。/是取除完的整数部分，%是取余数部分。Java中还有功能更加强大的算术运算符，++、--运算符，++是自加，分为前自加和后自加，如int i=1；i++；++i；自减用法也是一样。用代码来演示++和--的用法：

[java] view plaincopy

1. <span style="font-size:18px;">class AddReduce  
2. {  
3.     int i=8;//定义一个整数8，挺吉利的数字。  
4.     public static void main(String[] args)   
5.     {  
6.         System.out.println("i="+(i--));//后自减  
7.           
8.         System.out.println("i="+(--i));//前自减  
9.   
10.         System.out.println("i="+(i++));//后自加  
11.   
12.         System.out.println("i="+(++i));//前自加  
13.   
14.     }  
15. }  
16. /*运算结果是: 
17. a=8 
18. a=6 
19. a=6 
20. a=8 
21. */</span>  

对于后++，是先运算后自加，前++是先自加后运算，--也是一样的道理。

 @赋值运算符：就是"="，在java中不是相等的意思，而是把右边的值赋给左边的变量。如int num=9；就是把9赋给变量num。

特点是 可以进行连续赋值，原因：java中的赋值是具有返回值特点的，如a=b；相当于一个表达式（称为赋值表达式），该表达式返回b的值。
如：int a=b=c=d=12;//连续进行复制操作
相当于：int a=(b=(c=(d=12)));//d=12；表达式返回值为12，再赋给c，以此类推，完成连续赋值操作。

■注意：
boolean b=true;

if(b=true)//把条件写成true==b会更好，若写错：true=b 编译不通过。
  System.out.println("a");

 @关系运算符：包括">"（大于）、"<"（小于）、">="（大于等于）、"<="（小于等于）、"=="（等于）、"!="（不等于），关系运算符的运算结果是布尔型（boolean）的，结果只有true和false。示例代码：

[java] view plaincopy

1. <span style="font-size:18px;">class TrueFalse  
2. {  
3.     boolean b;  
4.     public static void main(String[] args)   
5.     {  
6.         System.out.println("b="+(1>2));  
7.           
8.         System.out.println("b="+(1<2));  
9.   
10.         System.out.println("b="+(1==2));  
11.   
12.         System.out.println("b="+(1!=2));  
13.           
14.         System.out.println("b="+(1<=2));  
15.           
16.         System.out.println("b="+(1>=2));  
17.   
18.     }  
19. }  
20. /*运算结果是: 
21. b=false 
22. b=true 
23. b=false 
24. b=true 
25. b=true 
26. b=false 
27. */</span>  

这就一目了然了，关系运算符的用法也是很简单的。

       @逻辑运算符：逻辑运算符有三种，非别是"&&"（双与）、"||"（双或）、"！"（非）。示例代码：

[java] view plaincopy

1. <span style="font-size:18px;">class NotAndOr  
2. {  
3.     public static void main(String[] args)   
4.     {  
5.         int a=10;  
6.         int b=21;  
7.         int c=11;  
8.   
9.         System.out.println("!(a>b):"+!(a>b));  
10.           //双与&&运算符，当判断第一个条件为false时，就不进行后面的判断
11.         System.out.println("a既大于b又小于c么？："+((a>b)&&(a<c)));  
12.   //双或||运算符，当潘达U难第一个条件为true时，就不进行后面的判断
13.         System.out.println("a大于b或小于才么？："+((a>b)||(a<c)));  
14.     }  
15. }  
16. /*运算结果是: 
17. !(a>b):true 
18. a既大于b又小于c么？：false 
19. a大于b或小于才么？：true 
20. */</span><span style="font-size: 18px;">  
21. </span>  

结果也是一目了然，对于逻辑运算符的用法也是比较简单的。

      

 @位运算符：位运算符主要针对二进制进行运算，包括"&"(与)、"|"(或)、"~"(非)和"^"(异或)，和逻辑运算符有些容易混淆。位运算符主要针对两个二进制数的位进行运算。二进制数满2进1，用0和1表示，如：10110100、110等。"&"（与）运算符：两个二进制数中对应的位数都为1时，结果为1，否则结果为0。"|"（或）运算符：两个对应为数的数有一个为1或两个都为1时结果就为1，否则结果为0。"~"（非）非运算符：属于单目运算符，对一个二进制数进行操作，位是0结果为1，位为1结果位0。"^"(异或)异或运算符：两个二进制数中对应为数相同为0，不同结果为1。示例代码：

[java] view plaincopy

1. <span style="font-size:18px;">class BitOperation  
2. {  
3.     public static void main(String[] args)   
4.     {  
5.         int a=10;  
6.         int b=12;  
7.   
8.         System.out.println("a|b="+(a|b));  
9.           
10.         System.out.println("a&b="+(a&b));  
11.   
12.         System.out.println("~a="+(~a));  
13.   
14.         System.out.println("a^b="+(a^b));  
15.   
16.     }  
17. }  
18. /*运算结果是: 
19. a|b=14 
20. a&b=8 
21. ~a=-11 
22. a^b=6 
23. */</span>  

■ ~非运算符简提：

   取反 如~2的结果是-3
原理：2的2进制表现形式：    00000000 00000000 00000000 00000010
求非后：11111111 11111111 11111111 11111101（求非后为负数）

求非后其实就是得到的结果，只是负数的2进制不能直接转化成10进制，需要先求得其绝对值，再取得相反数。
求绝对值：
原理：求非后的二进制数取反加
 1--->00000000 00000000 00000000 00000010
+00000000 00000000 00000000 00000001
_____________________________________
00000000 00000000 00000000 00000011

得到的数值为3，再取相反数，即为-3，就是得到的~2的运算结果。                        

■位运算符运用非常的灵活，如int a=10；int b=12；a^b^b=a;一个数连续异或两次另一个数得到原来的数。可以运用这个方法进行数值的交换，如：让a=12;b=10;     a=a^b;b=a^b;a=a^b;利用异或的特性完成交换值。                              

  @移位运算符：一位运算符有左移位和右移位。移位运算符也是针对二进制的"位"，左移位是"<<"，右移位有">>"（带符号右移）、">>>"（不带符号右移）。

所谓的移动是数串相对于看不见的小数点的移动，示例代码：

[java] view plaincopy

1. <span style="font-size:18px;">class  ShiftOperator  
2. {  
3.     public static void main(String[] args)   
4.     {  
5.         int a=2;  
6.         int b=3;  
7.         int c=-16;  
8.         int d=8;  
9.   
10.         System.out.println("a左移b位："+(a<<b));  
11.   
12.         System.out.println("a右移b位："+(a<<b));  
13.   
14.         System.out.println("c左移a位："+(c<<a));  
15.   
16.         System.out.println("a带符号右移b位："+(c>>d));  
17.   
18.         System.out.println("a无符号右移b位："+(c>>b));  
19.   
20.     }  
21. }  
22. /* 
23. 运行结果： 
24. a左移b位：16 
25. a右移b位：16 
26. c左移a位：-64 
27. a带符号右移b位：-1 
28. a无符号右移b位：-2 
29. */

        左移运算符，相当于把原数乘上2的移位数次幂，右移相当于除以2的移位数次幂，带符号右移，在缺省的位置上补充上原最高位，无符号右移在最高位补零。

■值得注意：

int i=88>>32;
long l=67<<64;

移位后的结果还是原值，原因：int是32位的，java的低层级制是将移的位数与数值类型的位数（这里是int32bit位） 求余，得到的余数就是将移动的位数。long类型的同理。这时java中比较聪明的一个机制，这样做可以减少一些不必要的步骤，超过了位数再去做移位运算是没有必要的，所以求余数。

 @三元运算符：格式为    布尔表达式 ？值1：值2

布尔表达式如果是true，结果就是值1，否则为值2。简单示例代码：

[java] view plaincopy

1. class  ThrBinOperator  
2. {  
3.     public static void main(String[] args)   
4.     {  
5.         int a=10;  
6.         int b=12;  
7.   
8.         System.out.println("我学习："+((a>b)?"C++":"Java"));  
9.   
10.     }  
11. }  
12. /* 
13. 运行结果： 
14. 我学习：Java 
15. */  

三运运算符运用简单，可以替换一些简单的if语句。

       @逗号运算符：就是"," ，逗号也是一种运算符，比较简单。有一点要注意的是，在定义数组时最后的逗号可有可无，如 int [] n={1,2,3,4,};//最后的逗号带着也不错，去掉也不错。

       @字符串运算符：在这里不多论述，在后面的学习再阐述。

       @转型运算符：转型运算符就是"( )"和数值类型的结合用法，将一种类型的对象或数据，经过强制转换而转变为另一种类型的数据。把需要转换成的数据类型放在"( )"里面。示例代码：

[java] view plaincopy

1. class  ConvOperation  
2. {  
3.     public static void main(String[] args)   
4.     {  
5.         int a=10;  
6.         double d=12.56;  
7.         //强转开始  
8.           
9.         System.out.println("原来a+d="+(a+d));  
10.   
11.         int x=(int)d+a;  
12.         System.out.println("强转之后a+d="+x);  
13.   
14.     }  
15. }  
16. /* 
17. 原来a+d=22.560000000000002 
18. 强转之后a+d=22 
19. */  

强转的作用是非常大的，在以后的学习中还是用到强转，包括对象的强转，在以后的学习中再作阐述。

 6 关键字：

每种编程语言也有相应的关键字，直接介绍Java中的关键字吧。Java中的关键字是被Java语言赋予了特殊含义的单词，特点是：这些关键字中的所有字母都是小写的。关键字也分种类：用于定义数据类型的，用于定义数据类型值的，用于定义流程控制的，用于定义访问权限的，用于定义类、函数、变量修饰符的等等。下面列出了一部分，在学习中都会用到这些关键字，没有这些关键字是边写不出程序的。

 @用于定义数据类型的：

classinterfacebyteshortintlongfloatdoublecharbooleanvoid    

@用于定义数据类型值的：

truefalsenull

@用于定义流程控制的：ifelseswitchcasedefaultwhiledoforbreakcontinuereturn    

本篇博文到此结束！

                                                                                                   

                                                                                               @感谢老师的辛苦批阅