2.變量
l 變量的概念：
- 內存中的一個存儲區域
- 該區域有自己的名稱（變量名）和類型（數據類型）和值
- Java中每個變量必須先聲明，再賦值，然后才能使用
- 該區域的數據可以在同一類型范圍內不斷變化
- Java 中的變量有四個基本屬性：變量名，數據類型，存儲單元和變量值
變量名：合法的標識符
變量的數據類型：可以是基本類型和引用類型（必須包含類型）
存儲單元：存儲單元大小是由數據類型決定的，如：int 為4 個字節32 位
變量值：在存儲單元中放的就是變量值（如果是基本類型放的就是具體值，如果是引用類型放的是內存地址，如果null，表示不指向任何對象）
l 定義變量的格式：數據類型 變量名 = 初始化值
l 變量是通過使用變量名來訪問這塊區域的
//int是一種數據類型，是整型。
int a; //在內存中開辟一塊空間，這塊空間的類型是整型，給這塊空間起名叫a
//賦值
a = 100;
//通過變量名去訪問那塊內存。
System.out.println(a);
//重復訪問
System.out.println(a);
l 使用變量注意：
- 變量的作用域：一對{ }之間有效。出了大括號就不認識了。
- 初始化值
- 變量可以重復賦值，但不能重復聲明，在同一個域中，變量名不能重復。
2.1 關於java中的字面值：
1.什么是字面值？
一眼看上去就知道是多少的數據，就是字面值
2.字面值本質：
字面值是有數據類型的：
整型 100
浮點型 3.14
布爾型 true/false
字符型 '中'
字符串型 "ABC"
在內存中占用空間。
字面值就是內存中的一塊空間，這塊空間有類型，有值。
只有字面值內存無法得到重復利用。
java語言中所有的字符都采用“單引號”括起來
java語言中所有的字符串都采用“雙引號”括起來。
public class ConstTest01{
public static void main(String[] args){
System.out.println(10); //整數型的字面值
System.out.println(3.14); //浮點型的字面值
System.out.println(true); //布爾型字面值
System.out.println(false);
System.out.println('a'); //字符字面值
System.out.println("Hello"); //字符串字面值
System.out.println(10); //新內存
//Error
//System.out.println('AB'); //AB本身不是一個字符，而是字符串.
System.out.println("A"); //這是一個字符串類型。
}
}
2.2 java中變量按照數據類型來分類：
>引用類型默認值：null
>8種基本數據類型：注意定義值時不能超過范圍
整型：byte（8 bit） short int（默認類型）long：變量值的末尾要加“L”或“l”
eg：byte = 1，存儲在計算機上為 0000 0001。
浮點型：float：末尾要加上“F”或“f”、 double (默認類型)
字符型：char（用‘ ’括起來）只能表示一個字符（英文/中文/標點/轉義字符等），默認值是“\u0000”，要定義多個字符用string。
布爾類型： boolean（只能取值為true 或false，不能取null），默認值是false。
2.3 java中變量按照聲明位置的不同來分類：
2.4進制（了解）：
2.4.1二進制：計算機底層都是用二進制來存儲、運算。
2.4.2二進制與十進制之間的轉換。
二進制轉換為十進制：從右向左，2^0 + 2^1 +···+2^n
十進制轉換為二進制：
2.4.3二進制在底層存儲：正數、負數都是以補碼的形式存儲的。（原碼、反碼、補碼）
正數：原碼、反碼、補碼三碼合一
負數：正數的原碼符號位由0變1è負數的原碼è負數原碼除符號位按位取反è負數的反碼è負數反碼加1è負數的補碼
2.4.4四種進制間的轉換
2.5變量的運算：不考慮布爾Boolean類型
①自動類型轉換：容量小的數據類型自動轉換為容量大的數據類型。
short s = 12; int i = s + 2; char c1 = ’a’;//97 char c2 = ‘A’;//65
注意：byte 、short、 char之間做運算，結果為int型！èlong èfloatèdouble
②強制類型轉換：是①的逆過程。使用“（）”實現強轉。
會導致精度的損失（高位截掉了）。Eg: long a1 = 12345L; int a2 = (int)a1;
----------------------------------------------------------------------------------------------------------------------
//字符串與基本數據類型之間的運算:只能是連接運算：+。得到的結果仍為一個字符串
String str = "abc";
String str1 = str + m1;//abc12345
System.out.println(str1);
----------------------------------------------------------------------------------------------------------------------
//題目：
String st1 = "hello";
int myInt1 = 12;
char ch1 = 'a';//97
System.out.println(str1 + myInt1 + ch1);//輸出：hello12a
System.out.println(myInt1 + ch1 + str1);//輸出：109hello
System.out.println(ch1 + str1 + myInt1);//輸出：ahello12
-------------------------------------------------------------------------------------------------
======================================================================
補充
一、關於變量
1.java中如何定義變量，語法：
數據類型 變量名;
2.如何給變量賦值，語法：
變量名 = 值;
3.變量的本質是什么？
變量就是內存中的一塊空間，這塊空間有“類型”，“名字”，“值”
public class VarTest01{
public static void main(String[] args){
//int是一種數據類型，是整型。
int a; //在內存中開辟一塊空間，這塊空間的類型是整型，給這塊空間起名叫a
//賦值
a = 100;
//通過變量名去訪問那塊內存。
System.out.println(a);
//重復訪問
System.out.println(a);
System.out.println(a);
}
}
二、變量的聲明
public class VarTest02{
public static void main(String[] args){
//申請一塊int類型的空間，起名i，並賦值10
int i = 10;
System.out.println(i);
//重新賦值
i = 100;
System.out.println(i);
//變量可以重新賦值，但不能重復聲明
//在同一個域中，變量名不能重復。
//int i = 200; //Error
//java語言中的變量必須先聲明，再賦值，才能使用。
int a;
a = 10;
System.out.println(a);
//聲明三個變量i1,i2,i3，類型都是int類型，i1,i2兩個變量沒有賦值，只有i3變量賦值。
int i1,i2,i3 = 456;
//Error
//System.out.println(i1); //i1沒有賦值不能訪問。
System.out.println(i3);
}
public static void m1(){
int i = 10; //不在同一個區域中可以聲明。
}}
三、關於變量的作用域：有效范圍。作用范圍。
出了大括號就不認識了。
public class VarTest03{
//類體
//聲明變量
int m = 100;
public void m1(){
int m = 200;
System.out.println(m); //200 (就近原則.)
}
public static void m(){
int k = 10;
}
public static void main(String[] args){
int i = 10;
System.out.println(i);
//Error
//無法訪問m方法中的k變量.
//System.out.println(k);
//for循環
/*
for(int j=0;j<10;j++){
System.out.println(j);
}
//Error,j變量是屬於for循環的。
System.out.println(j);
*/
//j的作用域在整個main方法中。
int j;
for(j=0;j<10;j++){
System.out.println(j);
}
System.out.println(j);}}
四、變量根據出現的位置可以分為兩種：
1.局部變量,在方法體中聲明的變量叫做局部變量。包括形式參數列表。
2.成員變量,在類體中，方法之外聲明的變量統稱成員變量。
public class VarTest04{
//成員變量
int i = 10;
//成員變量
int m;
public void m1(int m){ //m也是局部變量.
int k = 10; //局部變量
}
public void m2(){
System.out.println(m); //0
}
public static void main(String[] args){
VarTest04 vt = new VarTest04();
vt.m2();
}
}
五、關於整型類型：一個整數默認是int類型
byte 1byte(8bit) -128~127
short 2byte
int 4byte
long 8byte
整數型有三種表示方式：
十進制
八進制 以0開始
十六進制 以0x開始
public class DataTypeTest01{
public static void main(String[] args){
//十進制
int i1 = 10; //常用.
//八進制
int i2 = 010;
//十六進制
int i3 = 0x10;
System.out.println(i1); //10
System.out.println(i2); //8
System.out.println(i3); //16
//將一個int類型100字面值賦值給i4變量。
int i4 = 100;
//將一個int類型的123字面值賦值給long類型的l1
//int類型容量小於long類型.
//以下程序存在類型轉換.只不過叫“自動類型轉換”
long l1 = 123;
//由於123后面有一個L，所以上來就會把123看做long類型。
//所以以下程序不存在類型轉換，只是一個普通的賦值運算。
long l2 = 123L;
//可以(int類型-->long類型，自動類型轉換)
long l3 = 2147483647;
//程序將2147483648看做int類型，但是這個數據本身已經超出了int的取值范圍。
//long l4 = 2147483648;
long l4 = 2147483648L;
}
}
六、整型類型間轉換
public class DataTypeTest02{
public static void main(String[] args){
long l1 = 1000L;
//將long類型轉換成int類型，不能自動類型轉換.
//int i1 = l1;
//需要強制類型轉換
//需要加強制類型轉換符
//以下的程序雖然編譯通過了，但是程序在運行階段可能損失精度，所以一定要謹慎使用。
int i1 = (int)l1; //大容量向小容量轉換，需要強制類型轉換.
//記憶一個規則：如果這個整數沒有超出byte的取值范圍，可以直接將這個整數賦值給byte類型.
byte b1 = 10;
byte b2 = 127;
//Error
//128本身已經超出了byte的取值范圍。
//byte b3 = 128;
//如果整數本身沒有超出short的取值范圍，可以將這個整數直接賦值給short
short s1 = 32767;
//short s2 = 32768;
//最后結論：如果整數沒有超出byte,short,char的取值范圍，可以直接將這個整數賦值給byte,short,char
char c1 = 97;
char c2 = 65535;
//char c3 = 65536;
}
}
七、關於浮點類型：一個小數默認是double類型
float 4個字節
double 8個字節
public class DataTypeTest03{
public static void main(String[] args){
double d1 = 1.2;
//強制類型轉換
//float f1 = 3.2;
float f1 = (float)3.2;
//自動賦值運算
float f2 = 3.2F;
}
}
八、關於char類型
char是字符類型，java中采用UNICODE編碼。
底層占用兩個字節。
char類型涉及到字符編碼方式：
1.字符編碼方式是現實世界中的文字和計算機的表示方式的轉換規則。
ASCII
'a' 97
'A' 65
'0' 48
ISO-8859-1
GB2312<GBK<GB18030
unicode UTF-8 UTF-16 UTF-32
2.字符如果采用的編碼和解碼不一致的話，會出現亂碼。
public class CharTest01{
public static void main(String[] args){
char c1 = 'a';
//Error
//char c2 = 'ab';
//漢子占用2個字節，所以java中的char可以存儲一個漢字。
char c3 = '中';
System.out.println(c1);
System.out.println(c3);
}
}
九、關於轉義字符
public class CharTest02{
public static void main(String[] args){
/*
char c1 = 't';
System.out.print(c1);
System.out.println("abc");
*/
// 斜線在java語言中有轉義功能，可以將普通t字符，轉換成“制表符”
char c1 = '\t';
System.out.print(c1);
System.out.println("abc");
//這是一個普通的“單引號”字符
char c2 = '\'';
System.out.println(c2);
//這是一個普通的“斜線”字符
char c3 = '\\';
System.out.println(c3);
//這是一個普通的“雙引號”字符
char c4 = '\"';
System.out.println(c4);
//這是一個普通的換行符。
char c5 = '\n';
System.out.print("abc");
System.out.print(c5);
System.out.print("def");
char c6 = '中';
char c7 = '\u4e2d'; //'中'對的unicode碼是 4e2d
System.out.println(c6);
System.out.println(c7);
}
}
十、關於布爾類型
1.boolean類型的數據只有兩個值：true/false,沒有1和0。
2.boolean類型的數據主要用在邏輯運算和條件控制語句中。
public class DataTypeTest04{
public static void main(String[] args){
//Error:boolean只能是true/false
//boolean b1 = 1;
boolean sex = false;
if(sex){
System.out.println("男");
}else{
System.out.println("女");
}
}
}
十一、混合類型間運算
//byte,short,char做混合運算的時候先各自轉換成int在做運算。
public class DataTypeTest05{
public static void main(String[] args){
byte b1 = 10;
short s1 = 20;
int i1 = b1 + s1;
System.out.println(i1); //30(int)
//java程序分編譯期和運行期
//編譯階段只是知道b1+s1的結果是int類型。
//int類型無法直接賦值給byte類型.
//byte b2 = b1 + s1;
//可以.
byte b3 = 100;
}
}
十二、關於基本數據類型轉換規則
1. 8種基本數據類型除boolean類型之外都可以相互轉換.
2. 小容量向大容量轉換叫做自動類型轉換：
byte<short<int<long<float<double
char<
3. byte,short,char做混合運算的時候，各自都先轉換成int在做運算
4.大容量向小容量轉換是強制類型轉換，需要加強制轉換符，
編譯雖然通過，運行期可能損失精度。謹慎使用。
5.如果整數沒有超出byte,short,char的取值范圍，可以直接將這個整數賦值給byte,short,char
6.多種數據類型做混合運算，先轉換成容量最大的那種再做運算。
public class DataTypeTest06 {
public static void main(String[] args) {
//出現錯誤，1000超出了byte的范圍
//byte a = 1000;
//正確，因為20沒有超出byte范圍
//所以賦值
byte a = 20;
//變量不能重名
//short a = 1000;
//正確，因為數值1000沒有超出short類型的范圍
//所以賦值正確
short b = 1000;
//正確，因為默認就是int，並且沒有超出int范圍
int c = 1000;
//正確，可以自動轉換
long d = c;
//錯誤，出現精度丟失問題，大類型-->>小類型會出現問題
//int e = d;
//將long強制轉換成int類型
//因為值1000，沒有超出int范圍，所以轉換是正確的
int e = (int)d;
//因為java中的運算會會轉成最大類型
//而10和3默認為int,所以運算后的最大類型也是int
//所以是正確的
int f = 10/3;
//聲明10為long類型
long g = 10;
//出現錯誤，多個數值在運算過程中，會轉換成容量最大的類型
//以下示例最大的類型為double，而h為int，所以就會出現大類型（long）到小類型（int）的轉換，將會出現精度丟失問題
//int h = g/3;
//可以強制轉換,因為運算結果沒有超出int范圍
//int h = (int)g/3;
//可以采用long類型來接收運算結果
//long h = g/3;
//出現精度損失問題，以下問題主要是優先級的問題
//將g轉換成int，然后又將int類型的g轉換成byte,最后byte類型的g和3運算，那么它的運算結果類型就是int，所以int賦值給byte就出現了精度損失問題
//byte h = (byte)(int)g/3;
//正確
//byte h = (byte)(int)(g/3);
//不能轉換,還有因為優先級的問題
//byte h = (byte)g/3;
//可以轉換，因為運算結果沒有超出byte范圍
//byte h = (byte)(g/3);
//可以轉換，因為運算結果沒有超出short范圍
short h = (short)(g/3);
short i = 10;
byte j = 5;
//錯誤，short和byte運算，首先會轉換成int再運算
//所以運算結果為int，int賦值給short就會出現精度丟失問題
//short k = i + j;
//可以將運算結果強制轉換成short
//short k = (short)(i + j);
//因為運算結果為int，所以可以采用int類型接收
int k = i + j;
char l = 'a';
System.out.println(l);
//輸出結果為97，也就是a的ascii值
System.out.println((byte)l);
int m = l + 100;
//輸出結構為197,取得a的ascii碼值，讓后與100進行相加運算
System.out.println(m);
}
}