简介：术道并行，从零打造IT知识体系，图文视频同步更新。
本文学习章节：Java基础-02基本数据类型与算法
本文学习内容: Java基本数据类型（八大基础数据结构、引用类型）；Java基本算法（Java运算符：算术运算符、位移运算、关系运算、逻辑运算、三目条件运算符、赋值运环等；Java循环语句；Java条件语句；Java条件分支语句）
本文视频地址：待更新

当前知识体系图谱

绿色：已学习内容。蓝色：本次学习内容

1 Java的数据类型

Java数据类型（type） 包括：基本类型（primitive types）和引用类型（reference types）

Java是一种强类型语言，必须为每个变量声明其类型。在Java中，一共有8种基本类型，其中4种整型，2种浮点类型，1种表示Unicode编码的字符单元的字符类型char，1种用于表示真假值得boolean类型。

1.1 基本类型（primitive types）

1.1.1 基本类型简介

基本类型 包括：boolean类型 和 数值类型（numeric types）
数值类型（numeric types）又分为整型（integer types）和 浮点型（floating-point type）
整型有5种：byte、short、int、long、char(char本质上是一种特殊的int)。浮点类型有float 和 double

8种类型表示范围如下：

• byte：8位，最大存储数据量是255，存放的数据范围是-128~127之间。
• short：16位，最大存储数据量是65536，数据范围是-32768~32767之间。
• int：32位，最大数据存储容量是2的32次方减1，数据范围是负的2的31次方到正的2的31次方减1。
• long：64位，最大数据存储容量是2的64次方减1，数据范围为负的2的63次方到正的2的63次方减1。
• float：32位，数据范围在3.4e-45~1.4e38，直接赋值时必须在数字后加上f或F。
• double：64位，数据范围在4.9e-324~1.8e308，赋值时可以加d或D也可以不加。
• boolean：1位，只有true和false两个取值。
• char：16位，存储Unicode码，用单引号赋值。

1.1.2 基本类型的封装器类

Java每个基本类型都对应着封装类

• byte：Byte
• short：Short
• int：Integer
• long：Long
• float：Float
• double：Double
• boolean：Boolean
• char：Character

1.1.3 基本类型与其封装类类型比较

• 原始数据类型在传递参数时都是按值传递，封装类是对象，都是按引用传递
• 封装类实际是对象的引用，当new一个封装类时，实际上是生成一个指针指向此对象；而基本类型则是直接存储数据值
• Java基本类型存储在栈中
• Integer的默认值是null，int的默认值是0，即Integer可以区分出未赋值和值为0的区别，int则无法表达出未赋值的情况，返回数据库字段值是null的话，实体类中用int类型接收的话会报错。int是基本数据类型，其声明的是变量，而null则是对象。所以建议用integer
• Integer对于-128到127之间的数，会进行缓存，Integer i = 127时，会将127进行缓存，下次再写Integer j = 127时，就会直接从缓存中取，就不会new了
• int 和 Integer在进行比较的时候，Integer会进行拆箱，转为int值与int进行比较。其它数值类型也是一样。
• Integer与Integer比较的时候，由于直接赋值的时候会进行自动的装箱，那么这里就需要注意两个问题，一个是-128<= x<=127的整数，将会直接缓存在IntegerCache中，那么当赋值在这个区间的时候，不会创建新的Integer对象，而是从缓存中获取已经创建好的Integer对象。二：当大于这个范围的时候，直接new Integer来创建Integer对象。
• new Integer(1) 和Integer a = 1不同，前者会创建对象，存储在堆中，而后者因为在-128到127的范围内，不会创建新的对象，而是从IntegerCache中获取的。那么Integer a = 128, 大于该范围的话才会直接通过new Integer（128）创建对象，进行装箱
• Java语言中，默认声明的小数是double类型的，因此对float类型的变量进行初始化时需要进行类型转换
• 基本型封装类型调用equals(),但是参数是基本类型，这时候，先会进行自动装箱，基本型转换为其封装类型
• 两个基本型的封装型进行equals()比较，首先equals()会比较类型，如果类型相同，则继续比较值，如果值也相同，返回true
• 基本型和基本型封装型进行“==”运算符的比较，基本型封装型将会自动拆箱变为基本型后再进行比较，因此Integer(0)会自动拆箱为int类型再进行比较。

1.1.4 数据类型转换

byte <（short=char）< int < long < float < double
如果从小转换到大，可以自动完成，而从大到小，必须强制转换。short和char两种相同类型也必须强制转换。

1.2 引用类型（reference types）

引用类型（reference types）包括类（class）、接口（interface）、数组（array）、空（null）

引用类型记住一点，传递参数时是引用传递，以后会继续学习。

2 Java基本算法（参考菜鸟教程）

Java 运算符 - 算术运算符、关系运算符、位运算符、逻辑运算符、赋值运算符、其他运算符Java 循环结构 - for, while 及 do...whileJava 条件语句 - if...elseJava switch case 语句

Java的语法主要包含运算符、循环结构、条件语句、分支选择switch语句。接下来我们通过代码一个一个认识这些语法。

2.1 Java运算符

2.1.1 算术运算符

算术运算符用在数学表达式中，它们的作用和在数学中的作用一样。

运算符：

• 加法（+）：
  相加运算符两侧的值：A + B
• 减法（-）：
  左操作数减去右操作数：A - B
• 乘法（*）：
  相乘操作符两侧的值：A * B
• 除法（/）：
  左操作数除以右操作数：A / B
• 取余（％）：
  左操作数除以右操作数的余数 ：A ％ B
• 自增（++）：
  操作数的值增加1 ：B++ 或 ++BB
• 自增（--）：
  操作数的值增加1 ：B-- 或 --BB

示例代码：

public class ArithmeticOperation {

    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 25;
        int d = 25;
        System.out.println("a + b = " + (a + b) );
        System.out.println("a - b = " + (a - b) );
        System.out.println("a * b = " + (a * b) );
        System.out.println("b / a = " + (b / a) );
        System.out.println("b % a = " + (b % a) );
        System.out.println("c % a = " + (c % a) );
        System.out.println("a++   = " +  (a++) );
        System.out.println("a--   = " +  (a--) );
        // 查看 d++ 与 ++d 的不同
        System.out.println("d++   = " +  (d++) );
        System.out.println("++d   = " +  (++d) );
    }
}

运算结果：

a + b = 30
a - b = -10
a * b = 200
b / a = 2
b % a = 0
c % a = 5
a++   = 10
a--   = 11
d++   = 25
++d   = 27

2.1.2 关系运算符

关系运算符，用于2个操作数的比较，其结果要么为真，要么为假。

运算符：

• 是否相等（==）：
  检查如果两个操作数的值是否相等，如果相等则条件为真。
• 是否不相等（!=）：
  检查如果两个操作数的值是否相等，如果值不相等则条件为真。
• 是否大于（>）：
  检查左操作数的值是否大于右操作数的值，如果是那么条件为真。
• 是否小于（<）：
  检查左操作数的值是否小于右操作数的值，如果是那么条件为真。
• 是否大于等于（>=）：
  检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。
• 是否小于等于（<=）：
  检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。

示例代码：

RelationalOperation {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("a == b = " + (a == b) );
        System.out.println("a != b = " + (a != b) );
        System.out.println("a > b = " + (a > b) );
        System.out.println("a < b = " + (a < b) );
        System.out.println("b >= a = " + (b >= a) );
        System.out.println("b <= a = " + (b <= a) );
    }
}

运算结果：

a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false

2.1.3 位运算符

Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。
位运算符首先转化为二进制，再按照对应位进行位运算规则计算，由于直接操作位移，效率极高。

运算符:

• 与（＆）：
  如果相对应位都是1，则结果为1，否则为0
• 或（|）：
  如果相对应位都是 0，则结果为 0，否则为 1
• 异或（^）：
  如果相对应位值相同，则结果为0，否则为1
• 非（?）：
  按位取反运算符翻转操作数的每一位，即0变成1，1变成0。
• 左移（<<）：
  将运算符左边的对象向左移动运算符右边指定的位数（在低位补0）
• "有符号"右移（>>）：
  将运算符左边的对象向右移动运算符右边指定的位数。使用符号扩展机制，也就是说，如果值为正，则在高位补0，如果值为负，则在高位补1。
• "无符号"右移（>>>）：
  将运算符左边的对象向右移动运算符右边指定的位数。采用0扩展机制，也就是说，无论值的正负，都在高位补0。

示例代码:

public class BitOperation {
    public static void main(String[] args) {
        int a = 60; /* 60 = 0011 1100 */
        int b = 13; /* 13 = 0000 1101 */
        int c = 0;
        c = a & b;       /* 12 = 0000 1100 */
        System.out.println("a & b = " + c );

        c = a | b;       /* 61 = 0011 1101 */
        System.out.println("a | b = " + c );

        c = a ^ b;       /* 49 = 0011 0001 */
        System.out.println("a ^ b = " + c );

        c = ~a;          /*-61 = 1100 0011 */
        System.out.println("~a = " + c );

        c = a << 2;     /* 240 = 1111 0000 */
        System.out.println("a << 2 = " + c );

        c = a >> 2;     /* 15 = 1111 */
        System.out.println("a >> 2  = " + c );

        c = a >>> 2;     /* 15 = 0000 1111 */
        System.out.println("a >>> 2 = " + c );
    }
}

运算结果：

a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 2  = 15
a >>> 2 = 15

2.1.4 逻辑运算符

顾名思义，进行2个操作数的逻辑上的判断。

运算符:

• 与（&&）：
  称为逻辑与运算符。而且仅当两个操作数都为真，条件才为真。
• 或（||）：
  称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。
• 非（！）：
  称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。

示例代码:

public class LogicOperation {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;
        System.out.println("a && b = " + (a&&b));
        System.out.println("a || b = " + (a||b) );
        System.out.println("!(a && b) = " + !(a && b));
    }
}

运算结果：

a && b = false
a || b = true
!(a && b) = true

2.1.5 赋值运算符

将操作数进行指定的运行后，进行赋值覆盖。

运算符:

• 赋值（=）：
  简单的赋值运算符，将右操作数的值赋给左侧操作数：C = A + B将把A + B得到的值赋给C
• 加和赋值（+ =）：
  加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数：C + = A等价于C = C + A
• 减和赋值（- =）：
  减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数：C - = A等价于C = C - A
• 乘和赋值（ =）：
  乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数：C = A等价于C = C * A
• 除和赋值（/ =）：
  除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数：C / = A，C 与 A 同类型时等价于 C = C / A
• 取模和赋值（（％）=）：
  取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数：C％= A等价于C = C％A
• 左移位赋值（<< =）：
  左移位赋值运算符：C << = 2等价于C = C << 2
• 右移位赋值（>> =）：
  右移位赋值运算符：C >> = 2等价于C = C >> 2
• 按位与赋值（＆=）：
  按位与赋值运算符：C＆= 2等价于C = C＆2
• 按位异或赋值（^ =）：
  按位异或赋值操作符：C ^ = 2等价于C = C ^ 2
• 按位或赋值（| =）：
  按位或赋值操作符：C | = 2等价于C = C | 2

示例代码:

public class AssignmentOperators {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 0;
        c = a + b;
        System.out.println("c = a + b = " + c );
        c += a ;
        System.out.println("c += a  = " + c );
        c -= a ;
        System.out.println("c -= a = " + c );
        c *= a ;
        System.out.println("c *= a = " + c );
        a = 10;
        c = 15;
        c /= a ;
        System.out.println("c /= a = " + c );
        a = 10;
        c = 15;
        c %= a ;
        System.out.println("c %= a  = " + c );
        c <<= 2 ;
        System.out.println("c <<= 2 = " + c );
        c >>= 2 ;
        System.out.println("c >>= 2 = " + c );
        c >>= 2 ;
        System.out.println("c >>= 2 = " + c );
        c &= a ;
        System.out.println("c &= a  = " + c );
        c ^= a ;
        System.out.println("c ^= a   = " + c );
        c |= a ;
        System.out.println("c |= a   = " + c );
    }
}

运算结果：

c = a + b = 30
c += a  = 40
c -= a = 30
c *= a = 300
c /= a = 1
c %= a  = 5
c <<= 2 = 20
c >>= 2 = 5
c >>= 2 = 1
c &= a  = 0
c ^= a   = 10
c |= a   = 10

2.1.6 三目条件运算符

三目条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。
variable x = (expression) ? value if true : value if false

运算符：

• 三目条件运算（?:）：
  根据A的结果，若为真则返回B，若为假则返回C： A?B:C

示例代码：

public class ConditionalOperator {
    public static void main(String[] args){
        int a , b;
        a = 10;
        // 如果 a 等于 1 成立，则设置 b 为 20，否则为 30
        b = (a == 1) ? 20 : 30;
        System.out.println( "Value of b is : " +  b );

        // 如果 a 等于 10 成立，则设置 b 为 20，否则为 30
        b = (a == 10) ? 20 : 30;
        System.out.println( "Value of b is : " + b );
    }
}

运算结果

Value of b is : 30
Value of b is : 20

2.1.7 instanceof运算符

该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。
( Object reference variable ) instanceof (class/interface type)

运算符：

• 类型判断运算（instanceof）：
  判断A类型是否是B类型、B类型的实现、B类型的子类。

示例代码：

public class InstanceofOperation {

    public static void main(String[] args){
        String name = "James";
        boolean result1 = name instanceof String; // 由于 name 是 String 类型，所以返回真
        System.out.println( result1);

        Vehicle a = new Car();
        boolean result2 =  a instanceof Car;
        System.out.println( result2);

        Bar bar = new Bar();
        boolean result3 =  bar instanceof Foo;
        System.out.println( result3);
    }
}

interface Foo{}

class Bar implements Foo{

}

class Vehicle {}

class Car extends Vehicle {

}

运算结果：

true
true
true

2.2 Java运算符优先级

当多个运算符出现在一个表达式中，谁先谁后呢？这就涉及到运算符的优先级别的问题。在一个多运算符的表达式中，运算符优先级不同会导致最后得出的结果差别甚大。

优先级记忆方法：单目乘除为关系，逻辑三目后赋值。

实际开发中，应以括号辅助优先级管理。

参考文档：
菜鸟教程：https://www.runoob.com/java/java-tutorial.html
java运算符优先级记忆口诀 https://www.cnblogs.com/gavin-yao/p/10595835.html