黑马程序员---Java语言基础

Java语言基础

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

1.Java基础

1.1.基本数据类型

1.1.1整数类型

概念：  整数类型用来存储整数数值，即没有小数部分的数值。整数常量在Java程序中有3种表示形式，分别为十进制、八进制和十六进制。

1）  十进制：十进制不能以0开头，0除外。

2）  八进制：八进制必须以0开头。

3）  十六进制必须以0X或0x开头

整数的类型：

整型变量根据它在内存中所占的大小的不同，分为type、short、 int和long4种类型。

它们的取值范围为：

值得注意是：当byte ,short类型在进行 “++” 操作时，会自动转换为int 类型。在定义以上4种类型变量时，要注意变量能够接受的最大值与最小值，否则就会出错。对于long型值，若赋给的值大于int 的最大值或Int 的最小值，则需要在数字后加上L或l，表示该数值为长整数。

1.1.2 浮点类型

浮点类型表示有小数部分的数字。Java语言中浮点类型分为单精度（float）与双精度（double）,它们具有不同的取值范围。

 注：（一般情况下小数都默认为double,所以若想使用float型小数，则需要在其后加上F 或 f ）。

1.1.3 字符类型

1）char 型

字符类型（char）用于存储单个字符，占用16位（两个字节）的内存空间。在定义字符型变量时，要以单引号表示，如‘s’表示一个字符，但“s”则表示一个字符串了。

注：与c、c++一样，Java语言也可以把字符作为整数对待，由于unicode编码采用无符号编码，可以存储65536个字符（0x0000~0xffff）,所以Java中的字符几乎可以处理所有国家的语言文字，整数与字符之间也可以相互转换如下代码：

public class ValueRange {    /**    * @param args    */   public static void main(String[] args) {       // TODO Auto-generated method stub       System.out.println("a在unicode表中的顺序位置是：" + (int)'a');       //将char类强制转换为整型       System.out.println("unicode表中第97位是：" + (char)97);        //将整形强制转换为char类型    }}输出：a在unicode表中的顺序位置是：97unicode表中第97位是：a

以上代码可以说明char类型与int类型可以相互转换。

2）转义字符

转义字符是一种特殊的字符变量，其以反斜线”\”开头，后跟一个或多个字符。转义字符具有特定的含义，不同于字符原有的意义，故称“转义”。

Java常用转义字符如下：

将转义字符赋值给字符变量时，与字符常量一样需要使用单引号。 如 

public class ValueRange {     /**     * @param args     */    public static void main(String[] args) {        // TODO Auto-generated method stub     //将转义字符'\\的值赋给变量c1        char c1 = '\\';           //将转义字符'\052的值赋给变量c2        char c2 = '\052';                //输出\        System.out.println(c1);        //输出*        System.out.println(c2);       }}

1.1.4 布尔类型 

   布尔类型又称为逻辑类型，只有true 和false两个值，分别代表布尔逻辑中的“真”和“假”。布尔不能与整数类型进行交换。常用于流程控制中的判断条件。

1.2 变量与常量

   在程序执行过程中，其值不能改变的量称为常量，其值能被改变的量称为变量。变量与常量的命名都必须使用合法的标识符。

1.2.1 标识符与关键字

1）标识符

    定义：标识符可以简单理解为一个名字，用来标识类名、变量名、方法名、数组名、文件名的有效字符序列。

命名规范：Java语言规定标识符由任意顺序的字母、下划线（_）、美元符号（$）和数字组成，并且第一个字符不能是数字。标识符也不能是Java中的关键字。

注：Java中是严格区分大小写的，如 Man 和man 是不同的两个标识符。

2）关键字

   关键字是Java语言中已经被赋予特定意义的一些单词，不可以把这些字作为标识符来使用。

Java常用的关键字有：

1.2.2 声明变量 

对于变量的命名并不是任意的，应遵循以下几条规则：

1）  变量名必须是一个有效的标识符;

2）  变量名不可以使用Java中的关键字；

3）  变量名不能重复;

4）  应选择有意义的单词作为变量名。（Java中允许使用汉字或其他非英语文字作为变量名，编译并不会出错，但为了命名规范尽量不要如此使用）。

1.2.3 声明常量

在程序运行过程中一直不会改变的量称为常量（constant），通常也称为“final常量”。常量在整个程序只能被赋值一次。在为所有的对象共享值时，常量是非常有用的。

声明常量要使用关键字“final”

如 final 数据类型 常量名称[=值]

常量名一般使用大写字母，这并不是必须的，只是为了清楚表明正在使用常量。

注：1）当final变量是成员变量的时候，则必须设定初值，否则会编译错误。

2）常量只能进行一次赋值。

public class TestPart {//“成员常量”若没有赋值则会编译失败static final double PI =3.14;   //只是声明变量age，并不赋值，作为常量会自动赋初值的static int age ;     public static void main(String [] args){ //常量也可以先声明后赋值，但只能赋一次值final int number ;           number = 125; //再次赋值则报错//number = 126;                 int num = 124 ;     //而变量则可以一再赋值了num = 12;//输出3.14System.out.println("常量PI的值为：" + PI);      //输出0，默认值为0;System.out.println("int型变量age的值为：" + age);    //输出125System.out.println("常量number的值为：" + number);//输出12System.out.println("变量num的值为：" + num );       }}输出常量PI的值为：3.14int型变量age的值为：0常量number的值为：125变量num的值为：12 

1.2.4变量的有效范围

一般按变量的有效范围将变量分为“成员变量”和“局部变量”。

1）  成员变量

在类体中定义的变量称为成员变量，成员变量在整个类中都有效。成员变量又分为静态变量和实例变量；

如果在成员变量的类型前加上static 关键字，这样的成员变量称为静态成员变量。静态成员变量的有效范围可以跨类，甚至可以达到整个应用程序之内。对于静态方法，除了能在定义它的类中存取，还能直接以“类名.静态变量”的方式在其他类中使用。

2）  局部变量

在类的方法体中定义的变量（即是“{”与“}”之间定义的变量），称为局部变量。局部变量只在当前代码块中有效。关于局部变量应注意以下几点：

1.在类的方法中声明的变量，包括方法参数，都属于局部变量。

2.局部变量的生命周期取决于方法，方法调用时，Java虚拟机会为方法中的局部变量分配内存空间，方法结束，局部变量就会销毁。

3.局部变量可与成员变量重名，但此时成员变量将被隐藏，即这个成员变量在此方法中失效。

public class TestPart {//定义成员变量times    static int times = 35;                            public static void main(String [] args){    //定义局部变量times      int times = 36;        //输出36                             System.out.println(times);       //调用其他方法                  printTime();                                      }    public static void printTime(){       //输出35        System.out.println(times);              }}

由上代码可知：成员变量作为于全类，即使在main方法内被局部变量所覆盖，但只是有局部变量的有效范围失效而已，在printTime()内，times仍为35. 

1.2.5运算符

1）  赋值运算符

赋值运算符以符号“=”表示，它是一个二元运算符（对两个操作数作处理），其功能是将右方操作数所含的值赋给左方的操作数。（左方的操作数必须是一个变量，而右边的操作数则可以为任何表达式，包括变量、常量、有效表达式）。

2）  算术运算符

Java中的算术运算符主要有，如下表

具体代码：

public class TestCount {    /**     * @param args     */    public static void main(String[] args) {        // TODO Auto-generated method stub        double num1 = 12.2;        double num2 = 2.3;        System.out.println("数字一号为：" + num1);        System.out.println("数字二号为：" + num2);        //两数之和为：14.5        System.out.println("两数之和为：" + (num1 + num2));         //两数之差为：9.899999999999999        System.out.println("两数之差为：" + (num1- num2));         //两数之积为：28.059999999999995          System.out.println("两数之积为：" + num1 * num2);           //两数之商为：5.304347826086957        System.out.println("两数之商为：" + num1 / num2);      }}

 注：12.2-2.3=9.9，但是程序运算的结果却是有精度的误差，这是java中的bug，是难于避免的，如果需要用到高精度的运算，就需要用到 BigDecimal.

3）  自增和自减运算符

1. 自增与自减运算符是单目运算符，可以放在操作数之前，也可以放在操作数之后。
2. 操作数必须是一个整形或浮点变量。
3. 放在前面的自增、自减 会先进行加一、减一 操作，再将值进行表达式运算，而放在后面的则相反，先进行表达式运算，再进行加一、减一操作。如：

public class TestCount {     /**     * @param args     */    public static void main(String[] args) {        // TODO Auto-generated method stub        int i = 3 ;        int x = 3 ;                               //先赋值再加加输出i ++ = 3                    System.out.println("i ++ = " + i++ );          //先加加再赋值输出++ x  = 4        System.out.println("++ x  = " + ++x );     }}输出：i ++ = 3++ x  = 4

4）  比较运算符

比较运算符属于二元运算符，用于程序中的变量之间的、变量和自变量之间以及其他类型的信息之间的比较。其运算结果为boolean，比较运算符共有6种:如下图所示

5) 逻辑运算符 

    返回类型为布尔值的表达式，如比较运算符，可以被组合在一起构成一个更复杂的表达式。

逻辑运算符包括&（&&）（逻辑与）、 |（||）（逻辑或）、！(逻辑非)。

逻辑运算符的操作元都必须是boolean型的数据，只有！（逻辑非）为一元运算符。

逻辑运算符的逻辑运算如下图

具体运算如下代码：

public class TestCount {     /**     * @param args     */    public static void main(String[] args) {        // TODO Auto-generated method stub        int i = 3 ;        int x = 6 ;        boolean result = (i > x)&&(i < x);            //因为（i > x ）或（i < x）确定有一个为false，所以输出为false        System.out.println(result);               //因为（i > x ）或（i < x）确定有一个为true，所以输出为false        result = (i > x) || (i < x);           System.out.println(result);          result = !(i > x);        //输出非（i > x）因为（i > x ）为false,所以非（i > x）则为true        System.out.println(result);      }}输出：falsetruetrue 

小知识点：&&(短路与)和&(与) 、|| (短路或)和| (或)的分别，即短路与非短路的分别：

“与”是两者为true，结果才为true;而“或”则两者为false，结果才为false,所以所谓短路则如果第一个数为false,那么 “短路与”就不会与判断第二个操作元是否为false了，而 “短路或”也是一样，若第一个数是true,则不会判断第二个操作元是否为true了。不过其实如此一来，就算第二个操作元会报错也不会抛出异常了。

5）  位运算符

位运算是完全针对位方面的操作。整数数据在内存中以进制的形式表示，如int 型 变量 7 的二进制表示是 00000000 00000000 00000000 00000111；

左边最高位是符号位，最高是0的表示正数，若为1则表示负数。负数采用补码表示，如-8的二进制表示为 1111111111111111 11111111 11111000。 这样就可以对整型数据进行按位运算了。

1．“按位与”运算

   “按位与”运算的运算符为“&”，为双目运算符。“按位与”的规则是：如果两个整型数据a、b 对应位都是1 ， 则结果位才为1，否则为0.如果两个操作数的精度不同，则结果与精度最高的操作数最高的相同。

2.“按位或”运算

    顾名思义，就是两个整型数据a、b对应位都是0，则结果位才为0；

3.“按位非”运算

    为单目运算符，意思就是将操作数二进制中的1修改为0，将0修改为1的操作。

4.“按位异或”运算

    运算法则为：当两个操作数的二进制表示相同（同时为0或同时为1）时，结果为0；否则为1

6）移位操作

将对数据按二进制进行移位操作。Java中的移位操作符有3种。

1）  左移”<<”  左边的操作数在内存中的二进制数据左移右边操作数指定的位数，左边移空的部分补0；

2）  右移”>>” 当使用“>>”符号时，如果最高位为0，左移空的位就填入0 ；如果最高位为1 ， 右移空的位就填入1 。

3）  无符号右移”>>>”  无论最高位是0还是1，左侧移空的高位都被填入0.

注：（适用移位运算符的数据类型有byte 、short、char、int 和long）

7 )三元运算符

三元运算符其实就是if()…else…的简写。

使用格式为： 条件式 ? 值1:值2；

简写的格式一般都有功能的缺失：三元运算符只能进行赋值操作，不能输出语句。

如

public class TestCount {     /**     * @param args     */    public static void main(String[] args) {        // TODO Auto-generated method stub        int a = 18 ;        int b = 20;          //作出赋值判断  等效于if(a > b )max = a;else max = b;        int max = (a > b ) ? a : b ;            //输出20            System.out.println("最大数为：" + max);     }}

8）运算符的优先级

通常优先级由高到低的顺序依次是：

增量和减量运算 > 算术运算 > 比较运算 > 逻辑运算 > 赋值运算

1.3 数据类型转换

类型转换是将一个值从一种类型更改为另一种类型的过程。如 String str = “456”;

可以将str 转换为一个数值型，而且任意类型都可以转换为String类型。

关于精度问题：

1.如果低精度数据类型向高精度数据类型转换，则总是成功，不会有精度的缺失。

2.如果高精度数据向低精度类型转换，则必须会有信息缺失，且可能失败。

3.数据类型的转换有两种方式：隐式转换与显式转换。

1）隐式类型转换

即低精度向高精度转换，系统会自动执行，无须其他操作。

数据类型的精度由“低”到“高”排列的顺序为 byte --> short --> int --> long -->float -->double

由上图可知，当精度不同的数据类型在进行运算时，结果与精度最大的一致。

2）把高精度的变量赋给低精度的变量时，必须使用显式类型转换运算（又称为强制类型转换）

格式如下：

（类型名）要转换的值。

public class TestCount {     /**     * @param args     */    public static void main(String[] args) {        // TODO Auto-generated method stub       //浮点类型向整形转换        int a = (int)182.23 ;        int b = (int)20.12;         //显式转换后float会失去小数点后的小数的输出182        System.out.println("显式转换后的数a：" + a);           //输出20            System.out.println("显式转换后的数b：" + b);                 }}输出：显式转换后的数a：182显式转换后的数b：20

1.4 代码注释

1.单行注释：// 直到换行为止，其内容均为注释。

2.多行注释：/*

          */ 间的东西都会变成注释

3.文档注释：/**

              */间的东西都会变成注释 ; JVAV中的特有注释，经过java中javadoc.exe 生成网页。相当于程序说明书。

注释也可用于调试程序。

没有注释的代码是垃圾代码。

2.代码实例

用^实现变量之间的交换，与传统的移位操作作一比较。

public class NumChance {     /**     * @param args     */    public static void main(String[] args) {        // TODO Auto-generated method stub        int a = 12 ;        int b = 20 ;        System.out.println("移位前 a  = " + a + ", b = " + b );        numChance(a, b);        numChance2(a, b);    }    public static void numChance(int a , int b){                    //传统方法的移位操作，需要第三方的加入        int temp ;        temp = a;        a = b;        b = temp;        System.out.println("传统方法的移位 a  = " + a + ", b = " + b );    }     //而用异或操作进行移位操作，只需二个数相互异或，不需要第三方加入    public static void numChance2(int a , int b ){                 a = a ^ b ;        b = a ^ b;        a = a ^ b;        System.out.println("用异或移位 a  = " + a + ", b = " + b );       }}输出：移位前 a  = 12, b = 20传统方法的移位 a  = 20, b = 12用异或移位 a  = 20, b = 12

加密的原理：与同一个数异或一次，即乱码，再与这个数异或一次就回复正常

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