Java基础（二）

一、Java数据类型

1、基础数据类型（8种）

1、整数类型 （4种）

　　byte 1个字节8位，-2^8--2^8-1范围是-128到127

　　short 2个字节16位，-32768—32767

　　int  4个字节32位，-2147483648—2147483647  常用

　　long  8个字节64位，-9223372036854775808—9223372036854775807 

　　注意：给long赋值时，因为整数默认是int类型，要转换为long类型的值，后面加上l或L，一般用L，l容易与1混淆。

2、浮点类型（2种）

　　float 单精度 4个字节32位，直接赋值时必须在数字后加上f 或F

　　double 双精度 8个字节64位  常用

　　注意：浮点运算很少是精确的，只要是超过精度能表示的范围就会产生误差。往往产生误差不是 因为数的大小，而是因为数的精度。因此，产生的结果接近但不等于想要的结果。尤其在使用 float 和 double 作精确运算的时候要特别小心。

　　商业中精准计算使用java.math包中提供的API类BigDecimal。

3、字符类型（1种）

　　char 2个字节16位，字符常量使用单引号 ‘ ’包裹起来。char c = 65;//表示 ’A’ 这个字符，使用一个数字表示，对应有一个ASCII码表。

4、布尔类型（1种）

　　boolean 两个值 true 和 false

2、引用数据类型

　　类、数组、接口、枚举。。。

3、数据类型转换

　　下面这7种数据类型，它们之间都可以进行转换，但是可能会存在精度损失或者其他一些变化：

　　byte --》 short ，char --》  int  --》 long  --》  float  --》  double

　　如果从小转换到大，（除了byte不能自动转换char ，以及char不能自动转换short）可以自动完成转换。而从大到小，必须强制转换(强制转换前必须知道被转换的值在要转换的类型范围内)。

　　规律：有包含关系的可以由低精度赋值给高精度。高转低会导致精度丢失,不同类型的强制转换，可能会导致精度的下降.

　　问：为什么float 在long 后面？ 因为小数(浮点数) 的存储方式，结构和整数不一样。

public class TypeCast {
    @Test
    public void testIntToDouble(){
        int num = 10;
        double d = 10.1;
        double c = d + num;
        System.out.println(c);
    }

    @Test
    public void testShortToInt(){
        short s = 10;
        int num = 20;
        int n = num + s;
        System.out.println(n);
    }

    /**
     * 从大到小，必须强制转换
     */
    @Test
    public void testByteToInt(){
        byte b=3;
        b=(byte)(b*3);//必须声明byte。
        System.out.println(b);
    }

    /**
     * char类型向更高长度类型（例如整型）转换时，会转换为对应的ASCII码值，再做其他类型的自动转换
     */
    @Test
    public void testCharToInt(){
        char c = 'A';
        int num = 10;
        int a = c + num;
        System.out.println(a);
    }
}

　　注意：char型具有两个字节，其数值范围是0 ~ 2^16-1，这直接导致byte型不能自动类型提升到char，char和short直接也不会发生自动类型提升（因为值范围问题），同时，byte当然可以直接提升到short型。所以，char 不能和byte short 相互自动转换

　　小结：在 Java 的领域里，基本数据类型变量存的是数据本身，而引用类型变量存的是保存数据的内存空间地址。基本数据类型变量里存储的是直接放在抽屉里的东西，而引用数据类型变量里存储的是 这个抽屉的钥匙，钥匙和抽屉一一对应。

二、常量

1. 常量介绍

　　Java中的常量，常量就是一个固定不变的量（或者值）。例如 123,45,1.2，false等。

常见的分类

① 整数常量     例如：123 ，250,666

② 小数常量    例如：1.2,3.14

③ 字符串常量   例如：”12345”

④ 字符常量      例如： ‘2’,‘B’

⑤ 布尔常量     例如：true  ,false

上面的 5种表示形式的常量都可以直接放在打印语句中打印。

2. 常见转义字符

①\n表示换行；

②\t表示制表符，相当于Table键；

③\b表示退格键，相当于Back Space键；

④\'表示单引号；

⑤\''表示双引号；

⑥\\表示一个斜杠\

三、变量

1、变量的语法

1、先声明再赋值

　　int a;

　　a = 1;

2、声明时同时赋值

　　int a = 1;

2、变量的分类

1、成员变量

　　1、直接声明在类中的变量。（类中成员）

　　2、如果成员变量没有赋值，系统会分配默认值

　　3、作用域范围，整个类的范围

2、局部变量

　　1、直接声明在方法内部,比如main方法的形参 或者 大括号中

　　2、作用域范围，只能在方法内使用，局部变量，必须放在使用的功能语句前面

3、变量分类的详解

成员变量(也叫字段) ： 静态的（类变量）和非静态的（实例变量）

局部变量：不能使用static修饰

分类详解：

	位置	是否有static	生命周期（开始）	生命周期（结束）
类变量	类中	√	类被加载的时候	类被卸载的时候
实例变量	类中		创建对象的时候	对象被销毁
局部变量	方法内部（形参，代码块）		方法被调用的时候	方法调用完毕

 

 

            

 

 

 

 

理解：

类被加载的时候 ：把类的字节码文件加载到JVM中；

局部变量的作用 ：一般都是方法中，为了辅助方法完成功能而临时定义的变量；

类变量  ： 有static修饰的成员变量（字段）；

实例变量： 没有static修饰的成员变量（字段）；

3、表达式

　　由一系列的 常量、 变量 、运算符，括号()组成的一个算式，为了按照一定的运算规则计算出结果值。

四、运算符

1、算数运算符

　　加（+）减（-）乘（*）除（/）取模（%）

public class Modulo {
    /**
     * 取模，对整数取余2,结果为0是偶数，为1是奇数
     */
    @Test
    public void modulo() {
        System.out.println(6 % 2); //余数是0
        System.out.println(7 % 2); //余数是1
    }
}

　　一些常量表示符：NaN、Infinity 表示无穷大

2、自增自减

++（自增）    --（自减）

自增自减只能够用于变量，不能用于常量，自增自减运算的优先级，比算术运算符高

public class AutoAdding {
    /**
     * 自增
     */
    @Test
    public void autoAdding1() {
        int i = 3;  // 表示把3赋值给变量i
        i++;      //表示变量i的值加1，i的值变成4
        System.out.println(i);
        ++i;      //表示变量i的值加 1，i的值变成5
        System.out.println(i);
    }

    /**
     * 变量名在前 i++,先赋值再自增
     */
    @Test
    public void autoAdding2() {
        int i = 3;
        int j = i++;
        System.out.println(j); //3
        System.out.println(i); //4
    }

    /**
     * 变量名在前 ++i，先自增再赋值
     */
    @Test
    public void autoAdding3() {
        int i = 3;
        int j = ++i;
        System.out.println(j); //4
        System.out.println(i); //4
    }

    @Test
    public void autoAdding4() {
        int i = 3;
        int a = i++ + i++ + i++; //3(4) 4(5) 5(6)
        int b = ++i + ++i + ++i; //7 8 9
        System.out.println(a); //12
        System.out.println(b); //24
        System.out.println(i); //9
    }

    @Test
    public void autoAdding5() {
        int i = 5;
        i++;
        System.out.println("i=" + i);//6
        ++i;
        System.out.println("i=" + i);//7
        int a = ++i;
        System.out.println("a=" + a);//8 i=8
        a = a++;
        System.out.println("a=" + a);//8
        a = ++a;
        System.out.println("a=" + a);//9
    }
}

3、赋值运算

=    +=     -=     *=     /=    %=

从右到左，把符号右边的值赋值到左边的变量中

public class AssignmentOperator {
    /**
     * 赋值运算
     */
    @Test
    public void test1() {
        int i = 3;
        i += 2;// 表示把2 累加到变量 i 中
        System.out.println(i); //5
        i -= 1;
        System.out.println(i); //4
        i *= 3;
        System.out.println(i); //12
        i /= 3;
        System.out.println(i); //4
        i %= 3;
        System.out.println(i); //1
    }
}

4、比较运算符

==    !=     >    <    >=    <=    instanceof

1、比较运算的结果是一个布尔类型的值（true 或false）

2、instanceof 是判断一个对象是否属于某种类型

public class ComparisonOperator {
    @Test
    public void test(){
        int a = 3;
        System.out.println(1 == 1); //true
        System.out.println(a != 2); //true
        System.out.println(a > 2); //true
        System.out.println(a < 5); //true
        int b = 5;
        System.out.println(a >= b); //false
        System.out.println(b <= 6); //true
        System.out.println("hello" instanceof String); //true
    }
}

5、逻辑运算符

&    |     &&     ||   ^    ！

1、应用于多个条件的组合判断。

2、逻辑运算符两边结果值的都必须是布尔类型。

&   ：两边都为true ，结果为true

|    ：只要有一边为true，结果为true

&& ：两边都为true ，结果为true

||   ：只要有一边为true，结果为true

^   ：两边不一样，结果为true ，否则为false

！ ：逻辑非

3、&&  ||   和   & |    区别？

1)  & | 既可以充当逻辑运算，也可以是位运算符。

　　根据表达式的结果是否为布尔类型来判断

2) 双与 、双或具有短路行为

如果逻辑运算左边的值能够确定整个逻辑运算表达式的值，那么右边就不执行了，短路了。

　　&& 短路，左边表达式结果为false

　　 ||  短路 ，左边表达式结果为true

public class Demo {
    /**
     * 要判断1 / 0 == 0 出现异常
     */
    @Test
    public void test1() {
        System.out.println(1 < 0 & 1 / 0 == 0);  //java.lang.ArithmeticException: / by zero
    }

    /**
     * 短路，不判断1 / 0 == 0，返回false
     */
    @Test
    public void test2() {
        System.out.println(1 < 0 && 1 / 0 == 0);  //false
    }

    /**
     * 要判断1 / 0 == 0 出现异常
     */
    @Test
    public void test3() {
        System.out.println(1 > 0 | 1 / 0 == 0);  //java.lang.ArithmeticException: / by zero
    }

    /**
     * 短路，不判断1 / 0 == 0，返回true
     */
    @Test
    public void test4() {
        System.out.println(1 > 0 || 1 / 0 == 0);  //true
    }
}

4、常见错误：

  例如：判断一个整数的变量 a里面的数据  在0-100之间

  正确写法： a>0   &&  a<100

  错误写法:   0<  a < 100  (java没有这种语法，不支持)

6、位运算

&    |    ^     ~    <<      >>     >>>

1、可以把1看成是true,把0看成是false

2、位运算就是二进制的位进行运算

&  :与 位运算，两边为1，结果为1

|   :或 位运算，有一个为1，结果为1

^  :  异或，两边不一样，就为1，否则为0

~  :  取反，1变成0  ,0 变成1

<< :  向左位移动，例如1<<3                      

>> :   向右位移动，例如8>>2        

>>>:  无符号向右移动

public class BitOperation {
    @Test
    public void test() {
        /*与
        *   00000011
        *   00000100
        *   00000000
        * */
        System.out.println(3 & 4); //0

        /*或
        *   00000011
        *   00000100
        *   00000111
        * */
        System.out.println(3 | 4); //7

        /*向左位移动
        *   00000001
        *   00001000
        */
        System.out.println(1 << 3); //8

        /*~ 取反
        *   原码：1000 0000 0000 0101
        *   反码：1111 1111 1111 1010 符号位不变，其他位取反
        *   补码：1111 1111 1111 1011 反码+1
        *   补码再取反
        *        0000 0000 0000 0100 --》 4
        */
        System.out.println(~(-5)); //4
    }
}

注意：正数的补码，反码，原码都一样；

          负数的反码：符号为不变，其他位取反；

          负数的补码：它的反码+1；

7、三目运算符

　　语法格式：X ? Y : Z

1)上面的三目运算整体看成是一个表达式，应该有一个结果值

2) X  布尔类型的值或者结果为布尔类型的表达式

3) Y  Z  一般来说数据类型相同的值或者表达式

4) 运算的规则

　　X 为true，就是 Y 的结果值 ( 冒号前面的表达式的值)

　　X为false，就是Z的结果值 ( 冒号后面的表达式的值)

　　注意： 不要受  ？ 和    :  的干扰，它们只是一个固定语法格式

public class TernaryOperator {
    /**
     * 三目运算
     */
    @Test
    public void test() {
        int num = 5;
        System.out.println(num % 2 == 0 ? "偶数" : "奇数");  //输出奇数
    }
}