數據類型和運算符

Java語言是一門強類型語言。強類型包含兩方面的含義

所有的變量必須先聲明、後使用
指定類型的變量只能接受類型與之匹配的值。

強類型語言可以在編譯過程中發現源代碼的錯誤 ,從而保證程序更加健壯。

Java語言提供了豐富的基本數據類型,例如整型、字符型、浮點型和布爾型等。基本類型大致上可以分爲兩類:

數值類型
- 數值類型包括整型、字符型和浮點型,所有數值類型之間可以進行類型轉換,這種類型轉換包括自動類型轉換和強制類型轉換。
布爾類型
- true/false

註釋

編寫程序時總需要爲程序添加一些註釋,用以說明某段代碼的作用,或者說明某個類的用途、某個方法的功能,以及該方法的參數和返回值的數據類型及意義等。

除此之外,添加註釋也是調試程序的一個重要方法。如果覺得某段代碼可能有問題,可以先把這段代碼註釋起來,讓編譯器忽略這段代碼,再次編譯、運行,如果程序可以正常執行,則可以說明錯誤就是由這段代碼引起的,這樣就縮小了錯誤所在的範圍,有利於排錯;如果依然出現相同的錯誤,則可以說明錯誤不是由這段代碼引起的,同樣也縮小了錯誤所在的範圍。

單行註釋
- 語法：//
- 解釋：單行註釋就是在程序中註釋一行代碼,在Java語言中,將雙斜線(//)放在需要註釋的內容之前就可以了
多行註釋
- 語法：/* */
- 多行註釋是指一次性地將程序中多行代碼註釋掉,在Java語言中,使用/*和*/將程序中需要註釋的內容包含起來,/*表示註釋開始,而*/表示註釋結束。

程序實例：

public class DataTypesAndOperators {
    public static void main(String [] args){
        /*
        這是多行註釋
        */
        /**
         這是文檔註釋
         這是文檔註釋
         這是文檔註釋
         這是文檔註釋
         */
        //這是單行註釋
        System.out.println("HelloJava");
//        System.out.println("這行代碼被註釋了，程序運行時這行代碼不會被執行");
    }
}

文檔註釋
- 語法：/** */
- 解釋：文檔註釋以斜線後緊跟兩個星號(/**)開始,以星號後緊跟一個斜線(*/)結束,中間部分全部都是文檔註釋.

標識符和關鍵字

分隔符

Java語言裏的分號;、花括號{}、方括號[]、圓括號()、空格、圓點.都具有特殊的分隔作用,因此被統稱爲分隔符。

分號：Java語言採用分號;作爲語句的分隔,因此每個Java語句必須使用分號作爲結尾。
花括號：花括號的作用就是定義一個代碼塊,一個代碼塊指的就是{和}所包含的一段代碼,代碼塊在邏輯上是一個整體。花括號一般是成對出現的
方括號：方括號的主要作用是用於訪問數組元素,方括號通常緊跟數組變量名,而方括號裏指定希望訪問的數組元素的索引。
圓括號：圓括號是一個功能非常豐富的分隔符:
- 定義方法時必須使用圓括號來包含所有的形參聲明,調用方法時也必須使用圓括號來傳入實參值;
- 圓括號還可以將表達式中某個部分括成一個整體,保證這個部分優先計算
- 圓括號還可以作爲強制類型轉換的運算符。
空格
- Java語言使用空格分隔一條語句的不同部分。
- Java語言是一門格式自由的語言,所以空格幾乎可以出現在Java程序的任何地方,也可以出現任意多個空格,但不要使用空格把一個變量名隔開成兩個,這將導致程序出錯。
- Java語言中的空格包含空格符Space、製表符Tab和回車Enter等。
- Java源程序還會使用空格來合理縮進Java代碼,從而提供更好的可讀性。
圓點：圓點.通常用作類對象和它的成員(包括成員變量、方法和內部類)之間的分隔符，表明調用某個類或某個實例的指定成員

Java標識符規則

標識符就是用於給程序中變量、類、方法命名的符號,Java言的標識符必須以字母、下畫線_、美元符$開頭，後面可以跟任意數目字母數字、下畫線_和美元符$
使用標識符時，需要注意如下規則:

標識符可以由字母、數字、下畫線_和美元符$組成，其中數字不能打頭。
標識符不能是Java關鍵字和保留字，但可以包含關鍵和保留字。
標識符不能包含空格
標識符只能包含美元符$，不能包含@、#等其他特殊字符

Java關鍵字

abstract contmue for new switch
assert default if package synchronized
boolean do goto private this
break double implements protected throw
byte else import public throws
case enum instanceof retum transient
catch extends int short try
char final inteface static void
class finally long strictfp volatile
const float native super while

數據類型分類

Java語言是強類型(strongly typed)語言，強類型包含兩方面的含義：

所有的變量必須先聲明
指定類型的變量只能接受類型與之匹配的值
聲明變量的語法：type varName[ =初始值];

Java語言支持的類型分爲兩類,基本類型(Primitive Type)和引用類型(Reference Type):

基本數據類型

基本類型包括boolean類型和數值類型。
- 數值類型有整數類型和浮點類型。
  - 整數類型包括byte short int long char(char代表字符型，實際上字符型也是一種整數類型，相當於無符號整數類型)
  - 浮點類型包括float double
- boolean類型：true和false

引用數據類型

引用類型包括類、接口和數組類型，還有一種特殊的null類型
- 所謂引用數據類型就是對一個對象的引用，對象包括實例和數組兩種。實際上，引用類型變量就是一個指針，只Java語言裏不再使用指針這個說法
- 空類型null type就是null值的類型，這種類型沒有名稱。因爲null類型沒有名稱，所以不可能聲明一個null類型的變量或者轉換到null類型。空引用(null)是null類型變量唯一的值。空引用null可以轉換爲任何引用類型
- 在實際開發中程序員可以忽略null類型，假定null只是引用類型的一個特殊直接量。(空引用(null)只能被轉換成引用類型不能轉換成基本類型，因此不要把一個`null值賦給基本數據類型的變量)

基本數據類型分類

Java的基本數據類型分爲兩大類：boolean類型和數值類型。

Java 只包含這8種基本數據類型，值得指出的是，字符串不是基本數據類型字符串是一個類，也就是一個引用數據類型。

整型

通常所說的整型，實際指的是如下4種類型

byte:一個byte類型整數在內存裏佔8位，表數範圍：-128(-2⁷) ~ 127(2⁷-1)
short:一個short類型整數在內存裏佔16位，表數範圍：-32768(-2¹⁵) ~ 32768(2¹⁵-1)
int:一個int類型整數在內存裏佔32位，表數範圍：-2147483648(-2³¹) ~ 2147483648(2³¹-1)
long:一個long類型整數在內存裏佔64位，表數範圍：-2⁶³ ~ 2⁶³-1

字符型

//字符型
char my_char1 = '中';
char my_char2 = '國';
//製表符
System.out.println("my_char1\tmy_char2：" + my_char1 + my_char2);
//雙引號double_a + ""：9999999.56461346
byte_to_short：5
byte_to_char：
byte_to_int：5
byte_to_float：5.0
byte_to_long：5
byte_to_double：5.0
System.out.println("\"my_char1\"\t\"my_char2\"：" + my_char1 + my_char2);
//單引號
System.out.println("\'my_char1\'\t\'my_char2\'：" + my_char1 + my_char2);
//反斜線
System.out.println("\\my_char1\\\t\\my_char2\\：" + my_char1 + my_char2);
//退格符
System.out.println("my_char1\bmy_char2：" + my_char1 + my_char2);//my_charmy_char2：中國  刪除了'my_char1'中的'1'
//換行符
System.out.println("my_char1：" + my_char1 + "\nmy_char2：" + my_char2);
//回車符
System.out.println("my_char1\rmy_char2：" + my_char1 + my_char2);
//char類型賦值給int類型
char name = '張';
int char_to_int = name;
System.out.println("char_to_int：" + char_to_int);//24352
//int類型賦值給char類型
char int_to_char = 10000;
System.out.println("int_to_char：" + int_to_char);//✐

浮點型float和double

/*
因爲 Java 浮點數使用二進制數據的科學計數法來表示浮點數，因此可能不能精確表
示一個浮點數。例如把 5.2345556f 值賦給一個 float 類型變量，接着輸出這個變量時看到
這個變量的值已經發生了改變 使用 double 類型的浮點數比 float 類型的浮點數更精確，
但如果浮點數的精度足夠高(小數點後的數字很多 時) ，依然可能發生這種情況。
如果開發者需要精確保存一個浮點數，則可以考慮使用 BigDecimal類

double 類型代表雙精度浮點數 float 類型代表單精度浮點數 。
一 double 類型的數值佔8字節、64 位， 一個float 類型的數值佔4字節、 32 位。
如果希望 Java把一個浮點類型值當成 float 類型處理，應該在這個浮點類型值後緊跟f或F。
 */
float my_float_num = 456f;
System.out.println("my_float_num:" + my_float_num);
double my_double_num = 456.23541;
System.out.println("my_double_num:" + my_double_num);
double zero = 0.0;
System.out.println(my_float_num/zero);
System.out.println("******************************");
//Java 還提供了3個特殊的浮點數值:正無窮大、負無窮大和非數
/*
正無窮大通過 Double、float 類的 POSITIVE_INFINITY 表示
負無窮大通Double、Float 類的 NEGATIVE_INFINITY 表示
非數通過 Double、Float 類的 NaN 表示
必須指出的是，所有的正無窮大數值都是相等的，所有的負無窮大數值都是相等的
 NaN 不與任何數值相等,甚至和 NaN 都不相等
 */
//float和double的負無窮大
float a_float1 = Float.POSITIVE_INFINITY;
double double_float1 = Double.POSITIVE_INFINITY;
System.out.println("Float.NEGATIVE_INFINITY:" + Float.POSITIVE_INFINITY);
System.out.println("Double.NEGATIVE_INFINITY:" + Double.POSITIVE_INFINITY);
System.out.println("a_float1:" + a_float1);
System.out.println("double_float1:" + double_float1);
System.out.println(a_float1 == double_float1);//true
System.out.println("******************************");
//float和double的負無窮大
float a_float2 = Float.NEGATIVE_INFINITY;
double double_float2 = Double.NEGATIVE_INFINITY;
System.out.println("Float.NEGATIVE_INFINITY:" + Float.NEGATIVE_INFINITY);
System.out.println("Double.NEGATIVE_INFINITY:" + Double.NEGATIVE_INFINITY);
System.out.println("a_float2:" + a_float2);
System.out.println("double_float2:" + double_float2);
System.out.println(a_float2 == double_float2);//true
System.out.println("******************************");
//float和double的非數
float a_float3 = Float.NaN;
double double_float3 = Double.NaN;
System.out.println("Float.NEGATIVE_INFINITY:" + Float.NaN);
System.out.println("Double.NEGATIVE_INFINITY:" + Double.NaN);
System.out.println("a_float3:" + a_float3);
System.out.println("double_float3:" + double_float3);
System.out.println(a_float3 == double_float3);//false

布爾類型boolean true和false

/*
布爾型只有 boolean 類型，用於表示邏輯上的"真"或"假"。
在 Java 語言中， boolean 類型的數值只能是 true或false ，不能用0或者非0來代表。
其他基本數據類型的值也不能轉換成 boolean 類型。

字符串 "true" "false" 不會直接轉換成 boolean 類型.
但如果使用一個boolean 類型的值和字符串進行連接運算，則 boolean 類型的值將會自動轉換成字符串 看下面代碼
*/
boolean boolean1 = true;
boolean boolean2 = false;
String str1 = boolean1 + "";
String str2 = boolean2 + "";
System.out.println("str1：" + str1);
System.out.println("str2：" + str2);

基本類型的類型轉換

自動類型轉換

Java 所有的數值型變量可以相互轉換，如果系統支持把某種基本類型的值直接賦給另1種基本類型的變量，則這種方式被稱爲自動類型轉換。當把1個表數範圍小的數值或變量直接賦給另1個表數範圍大的變量時，系統將可以進行自動類型轉換:否則就需要強制轉換.
表數範圍小的可以向表數範圍大的進行自動類型轉換，就如同有兩瓶水，當把小瓶裏的水倒入大瓶中時，不會有任何問題 Java 支持自動類型轉換的類型如圖
上圖中所示的箭頭左邊的數值類型可以自動類型轉換爲箭頭右邊的數值類型
當把任何基本類型的值和字符串值進行連接運算時，基本類型的值將自動類型轉換爲字符串類型，雖然字符串類型不是基本類型，而是引用類型。因此，如果希望把基本類型的值轉換爲對應的字符串時，可以把基本類型的值和一個空字符串進行連接。

代碼示例：

package com.abc.part_two;

public class AutomaticTypeConversion {
    /**
     * 自動類型轉換
     */
    public static void main(String[] args) {
        byte byte_a = 5;//1字節，在內存中佔8位
        char char_a = '中';//2字節，在內存中佔16位
        short short_a = 56;//2字節，在內存中佔16位
        int int_a = 3000;//4字節，在內存中佔32位
        float float_a = 65161.25f;//4字節，在內存中佔32位
        long long_a = 99999999L;//8字節，在內存中佔64位
        double double_a = 9999999.56461346;//8字節，在內存中佔64位

        //如果希望把基本類型的值轉換爲對應的字符串時，可以把基本類型的值和一個空字符串進行連接。
        System.out.println("double_a + \"\"：" + double_a + "");
        // 下面語句輸出：7Hello!
        System.out.println(3 + 4 + "Hello!");
        // 下面語句輸出：Hello!34，因爲Hello! + 3會把3當成字符串處理，而後再把4當做字符串處理
        System.out.println("Hello!" + 3 + 4);

        //byte類型數據向表數範圍大的數據類型自動轉換
        //byte轉short
        short byte_to_short = byte_a;
        System.out.println("byte_to_short：" + byte_to_short);//`+`不僅可作爲加法運算符使用，還可作爲字符串連接運算符使用。
        //byte轉char 會報錯，byte類型不能自動類型轉換爲char類型，需要強制類型轉換。
        char byte_to_char = (char) byte_a;
        System.out.println("byte_to_char：" + byte_to_char);
        //byte轉int
        int byte_to_int = byte_a;
        System.out.println("byte_to_int：" + byte_to_int);
        //byte轉float
        float byte_to_float = byte_a;
        System.out.println("byte_to_float：" + byte_to_float);
        //byte轉long
        long byte_to_long = byte_a;
        System.out.println("byte_to_long：" + byte_to_long);
        //byte轉double
        double byte_to_double = byte_a;
        System.out.println("byte_to_double：" + byte_to_double);
    }
}

輸出：

double_a + ""：9999999.56461346
7Hello!
Hello!34
byte_to_short：5
byte_to_char：
byte_to_int：5
byte_to_float：5.0
byte_to_long：5
byte_to_double：5.0

強制類型轉換

強制類型轉換換的語法格式是 (targetType )value ，強制類型轉換的運算符是圓括號 (()) 。當進行強制類型轉換時，類似於把一個大瓶子裏的水倒入一個小瓶子，如果大瓶子裏的水不多還好，但如果大瓶子裏的水很多，小瓶子將會引起溢出，從而造成數據丟失這種轉換也被稱爲"縮小轉換 (Narrow Conversion)"。

代碼示例：

package com.abc.part_two;

public class Coercion {
    /**
     * 強制類型轉換
     * 強制類型轉換換的語法格式是 (targetType )value ，強制類型轉換的運算符是圓括號 (()) 。當進行強制類型轉換時，
     * 類似於把一個大瓶子裏的水倒入一個小瓶子，如果大瓶子裏的水不多還好，但如果大瓶子裏的水很多，
     * 小瓶子將會引起溢出 ，從而造成數據丟失 這種轉換也被稱爲"縮小轉換 (Narrow Conversion)"
     *
     * @param args
     */
    public static void main(String[] args) {
        int iValue = 233;
//      強制把一個 int 類型的值轉換爲 byte 類型 的值
        byte bValue = (byte) iValue;
//      將輸出 -23
        System.out.println(bValue);//-23
        double dValue = 3.98;
//      強制把 double 類型的值轉換爲 int 類型的值
        int tol = (int) dValue;
//      將輸出3
        System.out.println(tol);//3
        /**
         * 在上面程序中，把1個浮點數強制類型轉換爲整數時， Java 將直接截斷浮點數的小數部分。
         * 除此之外，上面程序還把 233 強制類型轉換爲 byte 類型的整數，從而變成了-23,這就是典型的溢出
         */

        //生成一個6位的隨機字符串
        //定義一個空字符串
        String result = "";
        //進行6次循環
        for (int i = 0; i < 6; i++) {
            int int_number = (int) (Math.random() * 26 + 97);
            result = result + (char) int_number;
        }
        System.out.println("本次隨機生成的6位字符串爲：" + result);
        //double強轉float
        //39.642默認是一個 double 類型的浮點數
        float double_to_float = (float) 39.642;
        System.out.printf("double 強轉爲 float：%f", double_to_float);//double 強轉爲 float：39.641998
        System.out.println();
        //字符串轉int
        String name1 = "中";
        String name2 = "1999";
        String name3 = "1999.5678";
//        int string_to_int1 = Integer.parseInt(name1);//會報錯：Exception in thread "main" java.lang.NumberFormatException: For input string: "中"
        //只能將數字類型的字符串如："456", "1024"轉換成基本數據類型
        int string_to_int2 = Integer.parseInt(name2);
//        System.out.println("string_to_int1：" + string_to_int1);
        System.out.println("string_to_int2：" + string_to_int2);

        //格式化輸出
        String str = "sss";
        System.out.printf("字符串str格式化輸出：%s", str);//字符串str格式化輸出：sss
    }
}

輸出：

-23
3
本次隨機生成的6位字符串爲：mrfhft
double 強轉爲 float：39.641998
string_to_int2：1999
字符串str格式化輸出：sss

Java爲8種基本類型都提供了對應的包裝類:

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

8個包裝類都提供了parseXxx(String str)靜態方法用於將字符串轉換成基本類型。

表達式類型的自動提升

代碼示例：

//表達式類型的自動提升
short short_num1 = 9;
//表達式右邊中的short_num1將自動提升到 int 類型，則右邊的表達式類型爲int, 將一個 int 類型值直接賦給 short 類型變量將發生錯誤
//        short_num1 = short_num1 - 3;
//這時候需要手動強轉爲short類型數據
short_num1 = (short) (short_num1 - 3);
System.out.printf("short類型數據：%s", short_num1);
//換行
System.out.println();
//以下是正確的表達式類型的自動提升
byte byte_num1 = 12;
char char_num1 = '阿';
short short_num2 = 1245;
double double_num1 = 12.56;
// 右邊表達式中最高等級操作數爲double_num1(double類型), 則右邊表達式的類型爲double類型,故賦給一個double類型變量
double double_result = byte_num1 + char_num1 + short_num2 + double_num1;
System.out.println(double_result);
System.out.println((double) char_num1);//38463.0

//必須指出,表達式的類型將嚴格保持和表達式中最高等級操作數相同的類型。下面代碼中兩個int類型整數進行除法運算，即使無法除盡，也將得到int類型結果
int int_num1 = 29;
//表達式右邊兩個操作數都是int類型，所以右邊表達式的類型爲int。
//雖然29/3不能除盡，但依然會得到一個int類型整數
int int_result = int_num1 / 3;
System.out.printf("int_num1 / 3 = %s", int_result);//9
//從上邊的結算結果來看，當兩個整數進行除法運算時，如果不能整除，得到的結果將是把小數部分截斷後取整數部分。
System.out.println();
//如果表達式中包含了字符串，則又是另1番情形了 因爲當把加號(+)放在字符串和基本類型值之間時 這個加號是1個字符串連接運算符 而不是進行加法運算 看如下代碼：
System.out.println("Java!" + '哈' + 3);//Java!哈3
System.out.println((int) '哈');//21704
System.out.println('哈' + 3 + "Java!");//21707Java!
/**
 * 對於第1個表達式 "Java!" + '哈' + 3,先進行"Java!" + '哈'運算， '哈'轉換成字符串,拼接成字符串 Java!哈, 接着進行 "Java!哈" + 3運算，這也是字符串連接運算，結果是 Java!哈3
 * 對於第2個表達式 先進行 '哈' + 3 加法運算，其中'哈'自動提升到int類型，變成'哈'對應的ASCII值：21704， 21704 + 3 = 21707， 然後進行 21707 + "Hello ! 運算 21707會自動轉換成字符串，將變成兩個字符串的連接運算 從而得到 21707Java!
 */

直接量

直接量是指在程序中通過源代碼直接給出的值，int a=5這行代碼中，爲變a所分配的初始值，就是1個直接量。

直接量的類型

並不是所有的數據類型都可以指定直接量，能指定直接量的通常只有3種類型基本類型、字符串類型和null類型，具體而言，Java支持如下8種類型的直接量。

int 類型的直接量：在程序中直接給出的整型數值，可分爲二進制、十進制、八進制和十六進制4種，其中二進制需要 OB/Ob開頭，八進制需要以0開頭，十六進制需要Ox/OX開頭。例如123、012(對應十進制的10)、Ox12 (對應十進制的18)等
long 類型的直接量：在整型數值後添加l或L後就變long類型的直接量。例如 3L、Ox12L(對應十進制的18L)
float 類型的直接量：在一個浮點數後添加f/F就變成了 float 類型的直接量，這個浮點數可以是標準小數形式，也可以是科學計數法形式例如 5.34F、3.14E5f
double 類型的直接量:直接給出1個標準小數形式或者科學計數法形式的浮點數就是 double類型的直接量。例如 5.34、3.14E5
boolean 類型的直接量：這個類型的直接量只有 true/false
char 類型的直接量： char 類型的直接量有三種形式，分別是用單引號括起來的字符、轉義字符和Unicode 值表示的字符。例如’a’、’\n’、’\u0061’。
String 類型的直接量：1個用雙引號括起來的字符序列就是 String 類型的直接量。
null 類型的直接量：這個類型的直接量只有1個值，即 null。

在上面的8種類型的直接量中， null 類型是1種特殊類型，它只有1個值：null，而且這個直接量可以賦給任何引用類型的變量，用以表示這個引用類型變量中保存的地址爲空，即還未指向任何有效對象。

直接量的賦值

//直接量的賦值，通常總是把1個直接量賦值給對應類型的變量，例如下面代碼都是合法的：
int a = 5;
char c = 'a';
boolean b = true;
float f = 5.12f;
double d = 4.12;
String author = "小花花";
String book = "Go語言學習入門";

知識點

String 類型的直接量不能賦給其他類型的變量， null 類型的直接量可以直接賦給任何引用類型的變量，包括 String 類型。
boolean 類型的直接量只能賦給 boolean 類型的變，不能賦給其他任何類型的變量。
關於字符串直接量有一點需要指出，當程序第一次使用某個字符串直接量時， Java 會使用常量池(constant pool) 來緩存該字符串直接量，如果程序後面的部分需要用到該字符串直接量時 Java 會直接使用常量池 (constant pool) 中的字符串直接量。
由於 String 類是一個典型的不可變類，因此 String對象創建出來就不可能被改變，因此無須擔心共享 String 對象會導致混亂。
常量池( constant pool )指的是在編譯期被確定，並被保存在己編譯的 .class 文件中的一些數據，它包括關於類、方法、接口中的常量，也包括字符串直接量。
代碼示例：

String s0 = "hello";
String s1 = "hello";
String s2 = "he" + "llo";
System.out.println(s0 == s1);//true
System.out.println(s0 == s2);//true

Java會確保每個字符串常量只有1個，不會產生多個副本，例子中的 sO和s1中的 “hello” 是字符串常量，它在編譯期就被確定了，所 sO == s1返回true;
“he’和"ll0” 也都是字符串常量，當一個字符串由多個字符串常量連接而成時，它本身就是字符串常量， s2一樣在編譯期就被解析爲1個字符串常量，所 s2也是常量池中 “hello” 的引用。因此，程序輸出 sO == s1返回 true ，s1 == s2 返回 true。

運算符

算術運算符

加法運算符 `+`

示例

//加法運算符 +
int num1 = 10;
int num2 = 14;
int num_sum = num1 + num2;
System.out.println(num_sum);//24

減法運算符 `-`

示例

//減法運算符 -
int num_subtraction = num1 - num2;
System.out.println(num_subtraction);//-4

乘法運算符 `*`

示例

//乘法運算符 *
int num_multiplication = num1 * num2;
System.out.println(num_multiplication);//140

除法運算符 `/`

如果除法運算符的兩個操作數都是整數類型(其中除數不可以爲0),計算結果取商
如果除法運算符的兩個操作數有一個是浮點數或者兩個都是浮點數，則計算結果也是浮點數。此時允許除數爲0或者0.0，得到的結果是正無窮大或負無窮大。

int num2 = 14;
double num3 = 18.54;
double num4 = 58.54;
int division_num1 = num2 / num1;
//        int division_num2 = num2 / 0;//除數不可以爲0
double division_num3 = num3 / num1;
double division_num4 = num4 / num3;
double division_num5 = num3 / 0;
double division_num6 = num3 / 0.0;
//        System.out.println(num2 / num1);
System.out.println(division_num1);//1
//        System.out.println(division_num2);
System.out.println(division_num3);//1.8539999999999999
System.out.println(division_num4);//3.157497303128371
System.out.println(division_num5);//正無窮大  Infinity
System.out.println(division_num6);//正無窮大  Infinity
System.out.println(-num3 / 0);//負無窮大  -Infinity
System.out.println(-num3 / 0.0);//負無窮大  -Infinity

取餘運算符 `%`

求餘運算符.求餘運算的結果不1定總是整數,它的計算結果是使用第一個操作數除以第2操作數後得到1個整除的結果後剩下的值就是餘數。
由於求餘運算也要進行除法運算，因此如果求餘運算的兩個操作數都是整數類型，則求餘運算的第2個操作數不能是0，否則將引發除以零異常.
如果求餘運算的兩個操作數中有1個或者兩個都是浮點數，則允許第2個操作數是0或0.0 ，只是求餘運算的結果是非數: NaN
0或0.0 對零以外的任何數求餘都將得到0或0.0

int num2 = 14;
System.out.println(num2 % num1);//4
System.out.println(num3 % num2);//4.539999999999999
System.out.println(num3 % 0);//非數 NaN
System.out.println(num3 % 0.0);//非數 NaN
System.out.println(-num3 / 0);//負無窮大  -Infinity
System.out.println(-num3 / 0.0);//負無窮大  -Infinity
System.out.println(0 / 5);//0
System.out.println(0.0 / 5);//0.0

自加 `++` 將操作數的值加1

自加是單目運算符，只能操作一個操作數
自加運算符只能操作單個數值型(整型、浮點型都行)的變量,不能操作常量或表達式.
運算符既可以出現在操作數的左邊，也可以出現在操作數的右邊
但出現在左邊和右邊的效果是不1樣的,如果把++放在左邊，則先把操作數加1，然後才把操作數放入表達式中運算

如果把++放在右邊，則先把操作數放入表達式中運算，然後才把操作數加1

int a = 3;
//        int a_new1 = a++ + 3;//a先不自增1，直接加3.此時a_new1=3+3=6,然後a在自增1此時a=4
//        System.out.println(a + "\t" + a_new1);//4   6
int a_new2 = ++a + 3;//a先自增1，直接加3.此時a_new1=4+3=6,然後a在自增1此時a=4
System.out.println(a + "\t" + a_new2);//4   7

自減 `--` 用法與`++`自增用法一致將操作數的值減1

示例

int b = 5;
int b_new1 = b-- - 1;
System.out.println(b + "\t" + b_new1);//4   4
//        int b_new2 = --b - 1;
//        System.out.println(b + "\t" + b_new2);//4   3

自加和自減總結

自加和自減只能用於操作變量，不能用於操作數值直接量、常量或表達式
Java 並沒有提供其他更復雜的運算符，如果需要完成乘方、開方等運算，則可藉助於 java.lang.Math類的工具方法完成複雜的數學運算
Math 類下包含了豐富的靜態方法，用於完成各種複雜的數學運算。

賦值運算符

賦值運算符用於爲變量指定變量值，與C類似， Java也使用=作爲賦值運算符。通常，使用賦值運算符將一個直接量值賦給變量。

//爲變量賦值
String str1 = "Java";
String str2 = "Python";
int age = 21;
//        將一個變量的值賦值給另一個變量
String myFavoriteProgramLanguage = str1;
System.out.printf("我最喜歡的編程語言之一是%s\n其次是%s\n我今年%d歲了," +
        "我相信自己可以學會這兩門編程語言~", myFavoriteProgramLanguage, str2, age);

賦值運算符是從右向左執行計算的，程序先計算得到=右邊的值,然後將該值"裝入"=左邊的變量，因此賦值運算符(=)左邊只能是變量。

賦值表達式是有值的，賦值表達式的值就是右邊被賦的值

例如 String str2 = str表達式的值就是str.因此，賦值運算符支持連續賦值，通過使用多個賦值運算符，可以一次爲多個變量賦值
- 示例
```
System.out.println();
int a;
int b;
int c;
//連續爲多個變量進行賦值
a = b = c = 666;
System.out.printf("a:%d\nb:%d\nc:%d", a, b, c);
```

位運算符

Java支持的位運算符有如下7個

& 按位與。當兩位同時爲1時才返回1
| 按位或。只要有位爲1即可返回1
~ 按位非。單目運算符，將操作數的每個位(包括符號位) 全部取反
^ :按位異或當兩位相同時返回0 不同時返回1
<< : 左移運算符
>> : 右移運算符
>>> : 無符號右移運算符

一般來說，位運算符只能操作整數類型的變量或值

擴展後的賦值運算符

賦值運算符可與算術運算符、位移運算符結合，擴展成功能更加強大的運算符,擴展後的賦值運算符如下

+=;對於x+=y，即對應於x=x+y
-=;對於x-=y，即對應於x=x-y
*=;對於x*=y，即對應於x=x*y
/=;對於x/=y，即對應於x=x/y
%=;對於x%=y，即對應於x=x%y
&=;對於x&=y，即對應於x=x&y
|=;對於x|=y，即對應於x=x|y
^=;對於x^=y，即對應於x=x^y
<<=;對於x<<=y，即對應於x=x<<y
>>=;對於x>>=y，即對應於x=x>>y
>>>=;對於x>>>=y，即對應於x=x>>>y

示例

byte a = 6;
a = (byte) (a + 4);//需要強轉，否則會報錯
byte b = 6;
b += 4;
System.out.printf("a:%d\nb:%d", a, b);

比較運算符

比較運算符用於判斷兩個變量或常量的大小，比較運算的結果是一個布爾值(true false)。Java支持的比較運算符如下

>: 大於，只支持左右兩邊操作數是數值類型。如果前面變量的值大於後面變量的值，則返回 true
>=: 大於等於,只支持左右兩邊操作數是數值類型。如果前面變量的值大於等於後面變量的值，則返回 true
<: 小於，只支持左右兩邊操作數是數值類型。如果前面變量的值小於後面變量的值，則返回 true
<=: 小於等於，只支持左右兩邊操作數是數值類型。如果前面變量的值小於等於後面變量的值，返回 true
==: 等於，如果進行比較的兩個操作數都是數值類型，即使它們的數據類型不相同，只要它們的值相等，也都將返回true
- 例如 97 == 'a’返回true. 5.0 == 也返回 true
- 如果兩個操作數都是引用類型，那麼只有當兩個引用變量的類型具有父子關係時纔可以比較，而且這兩個引用必須指向同一個對象纔會返回true
- Java也支持兩個boolean類型的值進行行比較，例如，true == false，將返回 false
!=:不等於，如果進行比較的兩個操作數都是數值類型，無論它們的數據類型是否相同，只要它們的值不相等，也都將返回true
- 如果兩個操作數都是引用類型，只有當兩個引用變量的類型具有父子關係時纔可以比較，只要兩個引用指向的不是同一個對象就會返回true。

示例

int a = 5;
int b = 6;
int c = 6;
System.out.printf("a < b? %b\nb == c? %b\na != c? %b\n", a < b, b == c, a != c);//a < b? true  b == c? true a != c? tru
String name1 = "小明";
String name2 = "小明";
System.out.printf("name1 != name2? %b\nname1 == name2? %b\n", name1 != name2, name1 == name2);//a < b? true  b == c? true
System.out.printf("true != false? %b\ntrue == false? %b\n", true != false, true == false);//true != false? true  true == false? false
//創建兩個Coercion類的對象，分別賦值給t1和t2兩個變量引用
Coercion t1 =new Coercion();
Coercion t2 = new Coercion();
// tl和t2 是同一個類的兩個實例的引用，所以可以比較
//但t1和t2 引用不同的對象，所以返回 false
System.out.println("t1 是否等於 t2: " + (t1 == t2)) ;//t1 是否等於 t2: false
//直接將 t1 的值賦給t3， 即讓t3 指向 t1 指向的對象
Coercion t3 = t1 ;
//t1和t3 指向同一個對象，所以返回 true
System.out.println("t1 是否等於 3 : " + ( t1 == t3)) ;//t1 是否等於 3 : true

邏輯運算符

邏輯運算符用於操作兩個布爾型的變量或常量邏輯運算符主要有如下6個

&&: 與，前後兩個操作數必須都是true才返回 true，否則返回 false
&:不短路與，作用與&&相同，但不會短路
&與&&的區別:&總會計算前後兩個操作數，而&&先計算左邊的操作數，如果左邊的操作數爲false，則直接返回false，根本不會計算右邊的操作數
||: 或，只要兩個操作數中有一個是true，就可以返回 true ，否則返回 false
|: 不短路或，作用與||相同，但不會短路
|與||的區別:|總會計算前後兩個操作數，而||先計算左邊的操作數，如果左邊的操作數爲true，則直接返回true，根本不會計算右邊的操作數
!: 非，只需要一個操作數，如果操作數爲true ，則返回 false 如果操作數爲 false ，則返回 true
^: 異或，當兩個操作數不同時才返回 true，如果兩個操作數相同則返回 false。

下面代碼示範了或、與、非、異或4個邏輯運算符的執行示意

String name1 = "瀟瀟";
String name2 = "大大";
System.out.println("&&  &");
System.out.println(!((name1 == name2) && (name1 != name2)));//true
System.out.println(!(name1 == name2) && (name1 != name2));//true
System.out.println((name1 == name2) && !(name1 != name2));//false
System.out.println(!((name1 == name2) & (name1 != name2)));//true
System.out.println(!(name1 == name2) & (name1 != name2));//true
System.out.println((name1 == name2) & !(name1 != name2));//false
System.out.println("||  |");
System.out.println(!((name1 == name2) || (name1 != name2)));//false
System.out.println(!(name1 == name2) || (name1 != name2));//true
System.out.println((name1 == name2) || !(name1 != name2));//false
System.out.println(!((name1 == name2) | (name1 != name2)));//false
System.out.println(!(name1 == name2) | (name1 != name2));//true
System.out.println((name1 == name2) | !(name1 != name2));//false

三目運算符

三目運算符只有一個 ? ，三目運算符的語法格式如下:
- (expression) ? if-true-statement : if-false-statement;
三目運算符的規則是:先對邏輯表達式 expression 求值，如果邏輯表達式返回 true ，則返回第二操作數的值，如果邏輯表達式返回 false ，則返回第一個操作數的值
大部分時候，三目運算符都是作爲 if else 的精簡寫法
三目運算符和 if else 寫法的區別在於: if 後的代碼塊可以有多個語句,三目運算符是不支持多個語句的。
三目運算符可以嵌套，嵌套後的三目運算符可以處理更復雜的情況

示例

String str = 5 > 1 ? "5大於1" : "5小於1";
System.out.println(str); //5大於1
//        嵌套的三目運算符
boolean result = 6 < 2 ? true : (6 > 3 ? false : true);
System.out.println(result);//false

運算符的結合性和優先級

所有的數學運算都認爲是從左向右運算的， Java 語言中大部分運算符也是從左向右結合的，
只有單目運算符、賦值運算符和三目運算符例外，其中，單目運算符、賦值運算符和三目運算符是從右向左結合的，也就是從右向左運算
乘法和加法是兩個可結合的運算，也就是說，這兩個運算符左右兩邊的操作數可以互換位置而不會影響結果。

運算符有不同的優先級，所謂優先級就是在表達式運算中的運算順序。下表列出了包括分隔符在內的所有運算符的優先級順序，上一行中的運算符總是優先於下一行的。

運算符說明	Java 運算符
分隔符	. [] () {} , ;
單目運算符	++ – ~ !
強制類型轉換運算	(type)
乘法/除法/求餘	* / %
加法/減法	+ -
移位運算符	<< >> >>>
關係運算符	< <= >= > instanceof
等價運算符	== !=
按位與	&
按位異或	^
按位或	\|
條件與	&&
條件或	\|\|
三目運算	? :
賦值	= += -= *= /= &=

anonymous的Java學習筆記之(2)——數據類型和運算符

數據類型和運算符

文章目錄

註釋

標識符和關鍵字

分隔符

Java標識符規則

Java關鍵字

數據類型分類

基本數據類型

引用數據類型

基本數據類型分類

整型

字符型

浮點型float和double

布爾類型boolean true和false

基本類型的類型轉換

自動類型轉換

強制類型轉換

表達式類型的自動提升

直接量

直接量的類型

直接量的賦值

知識點

運算符

算術運算符

加法運算符 +

減法運算符 -

乘法運算符 *

除法運算符 /

取餘運算符 %

自加 ++ 將操作數的值加1

自減 -- 用法與++自增用法一致 將操作數的值減1

自加和自減總結

賦值運算符

位運算符

擴展後的賦值運算符

比較運算符

邏輯運算符

三目運算符

運算符的結合性和優先級

加法運算符 `+`

減法運算符 `-`

乘法運算符 `*`

除法運算符 `/`

取餘運算符 `%`

自加 `++` 將操作數的值加1

自減 `--` 用法與`++`自增用法一致將操作數的值減1