一 類型轉(zhuǎn)換

java是強類型語言，所以必須在運算的時候，注意數(shù)據(jù)是否溢出，此時就需要利用到類型轉(zhuǎn)換

數(shù)據(jù)類型儲存值從低到高如下

byte,short,char,int,long,float,double.

運算中，不同類型的數(shù)據(jù)先轉(zhuǎn)換為同一類型，然后再進行運算

強制轉(zhuǎn)換

注意點：
1，不能對布爾值進行轉(zhuǎn)換
2，不能把對象類型轉(zhuǎn)換為不相干的類型
3，在把高容量轉(zhuǎn)換到低容量的時候，強制轉(zhuǎn)換（反之就不用動）
4，轉(zhuǎn)換的時候可能存在內(nèi)存溢出，或者精度問題！

public class deme_3 {
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte) i; //內(nèi)存溢出
//        byte b = 128;
?
        //強制轉(zhuǎn)換 （類型）變量名
        //自動轉(zhuǎn)換 從低到高
        System.out.println(i);
        System.out.println(b);
         System.out.println("==================");
        System.out.println((int)23.7); //23
        System.out.println((int)-55.57f);//-55 存在精度問題
        System.out.println("==================");
        char c = 'A';
        int d = 1;
        int s = c + d;
        System.out.println(s); //int
        System.out.println((char)s);//char類型B
 }
}

簡單來說就是，計算機的存儲單位字節(jié)不夠用了，要換大的。

• byte：1 字節(jié)（8 位），范圍：-128 到 127

• short：2 字節(jié)（16 位），范圍：-32768 到 32767

• int：4 字節(jié)（32 位），范圍：-2³¹ 到 2³¹-1

• long：8 字節(jié)（64 位），范圍：-2?³ 到 2?³-1

• float：4 字節(jié)（32 位），單精度浮點數(shù)

• double：8 字節(jié)（64 位），雙精度浮點數(shù)

• char：2 字節(jié)（16 位），用于表示 Unicode 字符

• boolean：理論上占 1 位，但在實際存儲中通常使用 1 字節(jié)（具體大小由 JVM 決定）

操作數(shù)字比較大時候，記得要注意溢出問題

例如

public class deme_3 {
    public static void main(String[] args) {
?
//jdk7 以后新特性，數(shù)字之間可以用下劃線分割
        int money = 10_0000_0000;
        int years = 20;
        int total = money * years;//計算之后溢出了
        long total1 = money * years;//定義了long也溢出了
        long total2 = money * (long)years;//先把一個數(shù)轉(zhuǎn)換為long
        long total3 = (long)money * years;
        System.out.println(total);
        System.out.println(total1);
        System.out.println(total2);
        System.out.println(total3);
?
  }
}

細節(jié)：為什么total1 不能轉(zhuǎn)換，因為money和years都是int類型

詳細解釋

• 運算時的類型：

  • int 類型的取值范圍是有限的（約 -21 億到 21 億）。

  • 代碼中 money = 10_0000_0000（即 10 億），years = 20，兩者相乘為 10 億 * 20 = 200 億。

  • 但 int 類型最大只能表示約 21 億，所以 money * years 的結(jié)果會超出 int 的范圍，發(fā)生整數(shù)溢出（結(jié)果變成一個錯誤的小數(shù)值）。

• 賦值給 long 的時機：

  • 雖然 total1 被聲明為 long 類型，但 money * years 的運算先于賦值發(fā)生。

  • 由于 money 和 years 都是 int，Java 會先以 int 類型進行乘法運算，導(dǎo)致溢出。

  • 溢出后的錯誤結(jié)果再被賦值給 long 時，已經(jīng)是錯誤的值了，無法恢復(fù)。

避免這種情況，需要在運算前將其中一個操作數(shù)轉(zhuǎn)換為 long

一個數(shù)字轉(zhuǎn)換為long就行了

二 變量

• 變量是什么：就是可以變化的量！

• java是一種強類型語言，每個變量都必須聲明其類型。

• java變量是程序中最基本的存儲單元，其要素包括變量名，變量類型和作用域

注意事項：

• 每個變量都有類型，類型可以是最基本類型，也可以是引用類型（string）

• 變量名必須是合法的標識符（前面的博客有說過）。

• 變量聲明是一條完整的語句，因此每一個聲明都必須以分號結(jié)束。

代碼部分：

public class deme_4 {
    public static void main(String[] args) {
        int a = 1,b = 2,c = 3,d = 4;
        System.out.println(a + "," + b + "," + c + "," + d);
    }
}
?

注意：你們仔細看我的println打印值的地方用的是加號（是不是和c語言不一樣）。我下面的圖片就是錯誤示范，大家可以去看一下！

java中“同時打印多個變量”的問題

Java 的 System.out.println（或 print）不支持像 C 語言 printf 那樣直接用 “逗號分隔多個變量” 傳參。若要打印多個變量，需通過 “字符串拼接” 或 printf 格式化輸出 實現(xiàn)：

• 方式 1：字符串拼接（用 + 號連接變量與字符串）

  int a = 1, b = 2, c = 3, d = 4;
  System.out.println(a + ", " + b + ", " + c + ", " + d);

• 方式 2：printf 格式化輸出（類似 C 語言 printf）

  System.out.printf("%d, %d, %d, %d\n", a, b, c, d);

之前的代碼 System.out.println(a,b,c,d); 報錯，是因為 println 方法不支持 “多變量逗號分隔” 的傳參語法 —— 它需要將多個變量 ** 拼接成一個整體（字符串或格式化內(nèi)容）** 后再傳入。

接下來大家肯定就要問這個加號為什么要這么用了，注意看我細節(jié)：在 Java 中，+ 號在這里的作用是字符串拼接，這是 Java 語法中一種特殊的處理邏輯。

例如：

int a = 1;
String str = ", ";
int b = 2;
System.out.println(a + str + b); // 輸出結(jié)果：1, 2

當 + 號兩邊的 “元素” 中至少有一個是字符串類型時，+ 就不再是 “數(shù)學(xué)加法”，而是 “拼接”—— 它會把所有元素轉(zhuǎn)換成字符串 **，然后首尾連接成一個新的字符串。

代碼 a + ", " + b + ", " + c + ", " + d 中：

• a 是 int 類型（數(shù)值 1），", " 是字符串類型

• 第一個 +（a + ", "）：因為右邊是字符串，所以 a 會被自動轉(zhuǎn)換成字符串 "1"，拼接后得到 "1, "

• 接下來 + b：左邊已經(jīng)是字符串 "1, "，所以 b（數(shù)值 2）被轉(zhuǎn)換成 "2"，拼接后得到 "1, 2, "

• 以此類推，最終所有元素會被拼接成一個完整的字符串 "1, 2, 3, 4"

最后 System.out.println 接收這個拼接好的字符串，打印出結(jié)果

和數(shù)學(xué)中+的區(qū)別

如果 + 號兩邊都是數(shù)值類型（比如 int、double 等），它才會執(zhí)行數(shù)學(xué)加法：

int x = 10, y = 20;
System.out.println(x + y); // 輸出 30（數(shù)學(xué)加法）
System.out.println(x + ", " + y); // 輸出 "10, 20"（字符串拼接）

變量的作用域

目錄

• 類變量

• 實例變量

• 局部變量

局部變量

代碼示例：

public class deme_6 {
    //main方法
    public static void main(String[] args) {
        //局部變量，必須聲明和初始化值
        int i = 10;
        System.out.println(i);
?
    }
?
    //其他方法
    public  void  add(){
        System.out.println(i); //i在這個方法里是無法表達的，這就是作用域
    }
}?

實例變量

定義：從屬于對象

格式：變量類型 +變量名字 = new Deme06（）

public class deme_6 {
    //實例變量：從屬于對象，在不進行初始化時，默認輸出是0
    String name = ",";
    int age = 2;
?
?
    //main方法
    public static void main(String[] args) {
        //局部變量，必須聲明和初始化值
        int i = 10;
        System.out.println(i);
//
        deme_6 deme06 = new deme_6();
        System.out.println(deme06.age);
        System.out.println(deme06.name);
    }
?
    //其他方法
    public  void  add(){
//        System.out.println(i);
    }
}?

兄弟們給你們看我的錯誤：類聲明是 public class deme_6（小寫開頭），但創(chuàng)建對象時寫成了 Deme_6 deme06 = new Deme_6();（大寫開頭），Java 是大小寫敏感的，所以編譯器找不到名為 Deme_6 的類，也會報 “找不到符號”。

類變量

關(guān)鍵詞：tatic （中文：靜態(tài)的）

public class deme_6 {
    //實例變量：從屬于對象，在不進行初始化時，默認輸出是0
    String name = ",";
    int age = 2;
//類變量
    static int age2 = 2;
?
    //main方法
    public static void main(String[] args) {
        //局部變量，必須聲明和初始化值
        int i = 10;
        System.out.println(i);
//
        deme_6 deme06 = new deme_6();
        System.out.println(deme06.age);
        System.out.println(deme06.name);
        System.out.println(age2);
    }
?
    //其他方法
    public  void  add(){
//        System.out.println(i);
    }
}?

變量命名規(guī)則

有效字符與開頭限制

• 首字符：只能以字母（大小寫均可）、下劃線 _、美元符號 $ 開頭，不能以數(shù)字開頭。

• 后續(xù)字符：可包含字母、數(shù)字、下劃線 _、美元符號 $（但 $ 實際很少使用，避免歧義）。

int count;        // 正確（字母開頭）
int _value;       // 正確（下劃線開頭）
int $temp;        // 合法但不推薦（$ 開頭）
// int 123num;    // 錯誤（數(shù)字開頭）
// char @sym;     // 錯誤（含非法字符 @）

• 大小寫敏感 Java 對大小寫敏感，myVariable 和 MyVariable 會被視為兩個不同的變量。

• 禁用關(guān)鍵字 / 保留字 不能使用 Java 的關(guān)鍵字（如 int、class、public、true 等，有特定語法含義）或保留字（如 goto、const，曾是 C++ 關(guān)鍵字，Java 中雖不做關(guān)鍵字但也禁止用作變量名）

命名規(guī)范與最佳實踐

1. 駝峰命名法（Camel Case）

• 小駝峰（Lower Camel Case）：首字母小寫，后續(xù)單詞首字母大寫。 適用場景：變量名、方法名。 示例：studentAge、calculateTotal()。

• 大駝峰（Upper Camel Case / Pascal Case）：每個單詞首字母大寫。 適用場景：類名、接口名。 示例：StudentRecord、DataProcessor。

2. 見名知意原則

• 變量名要描述用途 / 含義，避免無意義縮寫或單字母（除非是小作用域的循環(huán)變量，如 i、j）。

總結(jié)

到此這篇關(guān)于java中類型轉(zhuǎn)換和變量理解的文章就介紹到這了,更多相關(guān)java類型轉(zhuǎn)換和變量內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論