java基础（二）

目录

1. 常量
2. 进制数
3. 原码，反码，补码
4. 数据类型
5. 运算符

1.常量

class Demo1_Constant {
    public static void main(String[] args) {
        System.out.println("abc"); //字符串常量-用双引号括起来的内容
        System.out.println(123);  //整数常量-所有整数
        System.out.println(12.3); //小数常量-所有小数
        System.out.println('8'); /*字符常量，''中必须放得是单个字符0-9,
        用单引号括起来的内容，里面只能放单个数字，单个字母，单个符号*/
        //System.out.println('');//单引号中什么也不放也是不可以的
        System.out.println(' '); //空格是代表一个空格字符
        System.out.println(true);
        System.out.println(false);   
    }
}

2.进制数

A:二进制的数据表示
由0，1组成。以0b/0B开头
B:八进制
由0-7组成，以0开头
C：十进制
0-9组成，整数默认是十进制的
D：十六进制
由0-9，a-f（大小写均可）。以0x开头
E：案例演示

class Demo1_Scale {
    public static void main(String[] args) {
        System.out.println(0b100); //结果为4
        System.out.println(0100);//64
        System.out.println(100);//100
        System.out.println(0x100);//256
    }
}

十进制转换为任意进制：除积倒取余数

3.原码，反码，补码

• 原码：就是二进制定点表示法，最高位表示符号位，即1代表位负，0代表位正
  例如，通过一个字节，8个二进制位表示+7，-7如下：
  0（符号位） 0000111
  1（符号位） 0000111
• 反码：正数的反码与原码相同，负数的反码是对原码逐位取反，符号位除外
• 补码：正数的补码与原码相同，负数的补码是在反码的末位加1。

事实上反码是为了求补码的，而所有的运算都是在补码上进行的。

4.数据类型

class Demo1_DataType {
    public static void main(String[] args) {
        byte b = 10;
        short s = 20; //两个字节
        int i =30; //占四个字节，整数默认为int
        long x = 40; //占八个字节
        long y = 88888L;
        //超过int的取值范围，long类型后面加L进行long类型标识，最好用L 
        System.out.println(b);
        System.out.println(s);
        System.out.println(i);
        System.out.println(x);
        System.out.println(y);

        //浮点类型：默认是double类型的
        float f = 12.3F; //占四个字符，要用F声明是float类型的
        double d = 22.3; //占八个字符
        System.out.println(f);
        System.out.println(d);


        //字符类型
        char c = 'a'; //占两个字节
        System.out.println(c);

        //布尔类型
        boolean b1 = true;
        boolean b2 = false;
        System.out.println(b1);
        System.out.println(b2);
    }
} 

注：一条语句也是可以定义多个变量的。

int a = 1,b = 3,c = 30;

隐式转换：

class Demo1_DataType {
    public static void main(String[] args) {
        int x = 3;
        byte b = 4;

        x = x + b;
        System.out.println(x);
    }
} 
输出：7

当占字节数低的类型与高的类型做运算时，低的数据类型会转为高的数据类型再运算。如图所示，前面补0。

强制转换

class Demo1_DataType {
    public static void main(String[] args) {
        int x = 3;
        byte b = 4;

        b = (byte)(x + b); //x+b为int类型的 而b是byte类型的
        System.out.println(b);
    }
} 

这个过程相当于把前面三个8位去掉。

超出范围的强制类型转换

class Demo1_DataType {
    public static void main(String[] args) {

        byte b = (byte)(126 + 4); //x+b为int类型的 而b是byte类型的
        System.out.println(b);
        //输出-126，为什么呢？
        //00000000 00000000 00000000 10000010   130的二进制
        //10000010                              -126的反码
        //00000001                              -1 -求补码
        //10000001                              -126的补码
        //01111110                              -126的原码 
    }
} 

所以这样子会损失精度。

byte a = 3;
byte b = 4;
byte c = a + b;
//这样会出错，因为byte类型运算都会转换为int类型，所以结果是int的类型
//a,b是两个变量，编译的时候不知道具体的值，相加有可能会超出byte的范围

byte a = 7+ 3
//Java编译器有常量优化机制

字符串的输出与字母的运算

class Demo1_DataType {
    public static void main(String[] args) {

        System.out.println('a' + 1); //98 -因为ASCII码表中a表示97
        System.out.println((char)('a' + 1));//b
        System.out.println("hello"+'a' + 1);//helloa1 -任何数据类型用+与字符串连接都会产生新的字符串
        System.out.println("5 + 5 = " + (5+5));//5 + 5 = 10    加括号变换运算的优先级
    }
} 

5.运算符

5.1 基本运算符

class Demo1_DataType {
    public static void main(String[] args) {
        int a = 3;
        int b;

        b = a++;//当++在变量后时，先进行赋值操作，再进行+1操作
        //b = ++a  当++在前面时，先++，再进行赋值
        System.out.println("a = " + a);
        System.out.println("b = " + b);
    }
} 
输出：
a = 4
b = 3

关于运算的几个小面试题

class Demo1_DataType {
    public static void main(String[] args) {
        int x = 4;
        //       4      6       60
        int y = (x++) + (++x)+ (x*10);
        System.out.println(y); //输出70

        byte b = 10;
        //b++.    相当于b = (byte) (b + 1) 做了强制类型转换
        b = b + 1; //会损失精度
        System.out.println(b);

    }
} 

5.2 逻辑运算符

&—逻辑与：有false则false
|—逻辑或 ：有true则true
^—逻辑异或 ：相同为false,不同为true
!—逻辑非：取反

class Demo1_Operator {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;

        System.out.println(a<b ^ b<c); // true false
        System.out.println(a>b ^ b<c); //false true
        System.out.println(a<b ^ b>c); //true false
        System.out.println(a>b ^ b>c); //false false
    }
}

&&—双“与“：左边是false，右边就不执行了
||—同样具有短路效果

5.3 位运算符

class Demo1_Operator {
    public static void main(String[] args) {
        /*
        * &,|,^,~ 的用法
        * &:有0则0
        * |:有1则1
        * ^:相同则0，不同则1
        * ~:按位取反
        */

        System.out.println(6 & 3);              //2
        System.out.println(6 | 3);              //7
        System.out.println(6 ^ 3);              //5 
        System.out.println(~6);                    //-7?                   
    }
}
/*
    110
&   011
-----------
    010

    110
|   011
-----------
    111

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

    00000000 00000000 00000000 00000110     6的原码反码补码都是本身
    11111111 11111111 11111111 11111001     对6取反
-   00000000 00000000 00000000 00000001
---------------------------------------
    11111111 11111111 11111111 11111000     反码
    10000000 00000000 00000000 00000111     原码(-7)
*/

关于异或的小题：^

class Demo1_Operator {
    public static void main(String[] args) {
        //不定义第三方变量，把a,b的值交换

        int a = 10;
        int b = 20;

        a = a ^ b;    // 10^20
        b = a ^ b;    //10^20^20
        a = a ^ b;   //10^20^10
        System.out.println("a = " + a + ", b = " + b);
        //a = 20, b = 10
    }
}

5.4 三元运算符

关系式为ture ? 输出这个 ： 不输出这个

int a = 10;
int b = 20;
int c;
c = (a > b) ? a : b;

这里输出b