Java基础-Lesson2基础语法

1、计算机中的进制

（1）常用的进制：

二进制变量：以0b开头（大小写均可），比如 int a = 0b1010;

八进制变量：以0开头，比如 int a = 01234; int a = 01010;

十六进制：以0x开头（大小写均可），比如 int a = 0x1234; int a = 0xABAA;

在定义变量的时候可以使用“_”进行划分，但不参与编译，比如 int a = 0b10_111_100;

（2）进制的转换

十进制转二进制不停的除以2取余，比如，9 ==> 1001

二进制转十进制，比如10110 ==> 0*2^0+1*2^1+1*2^2+0*2^3+1*2^4 ==> 22

二进制转十六进制，比如1101010101011001110011 ==> 0011 0101 0101 0110 0111 0011

        ==> 0x355673

二进制转八进制，比如1101010101011001110011 ==> 001 101 010 101 011 001 110 011

        ==> 015253163

负数在内存中是以补码（正数按位取反再+1）形式存储的，比如 int a = -23

        ==> 00000000 00000000 00000000 00010111 ==> 11111111 11111111 11111111 11101000

        ==> 11111111 11111111 11111111 11101001

2、标识符

以数字、字母、"$" 或  "_" 组成，不能以数字开头，不能是关键字，汉字可以

3、变量

（1）基本数据类型

byte  1个字节有符号        -128 到 127之间        //如果不带符号最大值是255

short  2个字节有符号        -32768 到 32767之间        //如果不带符号最大值是65535

int  4个字节有符号        -2147483648 到 2147483647之间        

long  8个字节有符号        -9223372036854775808 到 9223372036854775807之间        //总长度19位

float  4个字节，单精度浮点数

double  8个字节，双精度浮点数

boolean  1个字节，取值又有true 和 false

char  2个字节，存一个字符或数字

注：当一个数的取值大于int型的最大值（或小于最小值）的时候，要定义成long类型并在数值后加上L，比如 long a = 2147483650L;

当定义一个单精度浮点数时要在最后加上f，比如 float a = 3.14f;小数一般默认是双精度浮点数

char型没有符号位所以不能存负数，而且不能直接 char a = '';定义空值，要使用转义字符，比如

char a = '\u0000' == char a = '\0' ; 

（2）引用数据类型

4、运算符-算数运算符

+        -        *        /        %        ++        --

（1）在进行运算的时候，java要求运算符两端的类型相同，如果不相同，会把级别小的转换成级别大的，运算结果变成大的（可能说的不是很专业，但是便与我自己理解），比如

public static void main(String[] args) {
    System.out.println(10/3);  //3
    System.out.println(10f/3);  //3.3333333
}

（2）关于++在前和在后的问题

public static void main(String[] args) {
    int a = 9;
    int b = a++;
    System.out.println(a);  //10
    System.out.println(b);  //9
}

本例中++在后就会先进行赋值操作再进行自增，如果++在前那么 a = 10，b = 10;

请看下面这个例子

public static void main(String[] args) {
    int a = 9;
    a=a++;
    a=a++;
    a=a++;
    a=a++;
    System.out.println(a);  //9
}

这里先不做解释

5、运算符-赋值运算符

（1）“=”

把类型小的变量赋值给类型大的变量是没问题的，但是把类型大的赋值给类型小的编译不通过，比如

public static void main(String[] args) {
    byte a1 = 9;
    int b1 = a1;  //编译通过
    int a2 = 9;
    byte b2 = a2;  //编译不通过
}

但是可以进行强制类型转换，但是可能出现溢出的问题，比如

public static void main(String[] args) {
    int x = 205;
    byte y = (byte) x;
    System.out.println(y);  //-51
}

再看下面这个例子

public static void main(String[] args) {
    byte a1 = 10;
    byte b1 = 5;
    byte c1 = a1+b1;  //编译出错
    int d1 = a1+b1;  //编译通过
    short a2 = 10;
    short b2 = 5;
    short c2 = a2+b2;  //编译出错
    int d2 = a2+b2;  //编译通过
}

因为byte ，short 型取值范围小，非常容易超出容量，所以在java中，把它们的计算结果，提升为int型了

再看下面这个“类似”的例子

public static void main(String[] args) {
    byte a1 = 10;
    byte b1 = a1+5;  //编译错误
    final byte a2 = 10;
    byte b2 = a2+5;  //编译通过
}

在没有final修饰的赋值语句中，因为byte型的变量和int型的数据值相加结果为int型，而在final修饰的赋值语句中，因为a2是常量，所以直接编译成了 byte b2 = 15;

（2）“+=”

关于“+=”的一个小区别

public static void main(String[] args) {
    byte a = 10;
    a = a+5;  //编译出错
    a += 5;  //编译通过
}

附：关于基本数据类型的初始值

byte、short、int 都是0

long  是0L

float  是0.0f

double  是0.0

boolean  是false

char  是'\0'

基本数据类型，无论是哪种，都没有null这个取值

6、其他运算符

（1）逻辑运算符

参与逻辑运算的都是逻辑表达式，结果也是true 或 false

&        两端都是true则结果为true，否则为false

|        只要有一个是true，那么结果就为true

！        取反，原来是true就返回false，原来是false就返回true

^        异或，两端相同则返回false，不同则返回true

&&        和& 的意思相同，但是短路（在有多个条件相与的时候，如果前面的条件不成立，则直接返回false，后面的表达式将不再执行）

||        和| 的意思相同，但短路

附：&&和& 还有一个区别是，& 可以用于位运算，但是&&只能用于逻辑运算，比如

public static void main(String[] args) {
    System.out.println(true && false);  //false
    System.out.println(7 & 9);  //1
}

知识点：

&        按位与

|        按位或

~        按位取反

^        按位异或

<<        逻辑左移  //每左移一次相当于将原来的数乘以2

>>        逻辑右移  //每右移一次相当于将原来的数除以2

>>>        无符号右移  //在右移的时候，无论原来的数是正是负米高为都补0

public static void main(String[] args) {
    System.out.println(7 | 9);  //15
    System.out.println(~Integer.MAX_VALUE);  //-2147483648，变成最小的负数
    System.out.println(7 ^ 9);  //14
    int a = -2;
    a = a<<1;
    System.out.println(a);  //-4，不改变符号
    int b = -8;
    b = b>>2;
    System.out.println(b);  //-2，不改变符号
}

注意：在进行移位的时候，对于byte, short, int型，真正移位的数是和32进行取余后的数，比如

public static void main(String[] args) {
    System.out.println(16<<33);  //32，相当于16<<(33%32)
    System.out.println(16>>33);  //8，相当于16>>(33%32)
}

而且移位运算的优先级很低，而且不是++  -- 这类的自增操作运算符，它不会改变原来的变量的值

（2）关系运算符

>        ==        <        >=        <=        !=

instanceof运算符  //判断一个对象是不是某一个类的实例

（3）条件运算符

三元运算符，比如

public static void main(String[] args) {
    int number = 30;
    int result = number>50?Integer.MAX_VALUE:Integer.MIN_VALUE;
    System.out.println(result);  //-2147483648
    int score = 60;
    String res = score>=60?"及格":"不及格";
    System.out.println(res);  //及格
}