第二天 變數&資料型別&運算子【悟空教程】
第二天 變數&資料型別&運算子【悟空教程】
第02天 Java基礎
第1章 變數
1.1 變數
1.1.1 變數概念
變數是用來儲存數值的記憶體區域
1.1.2 作用
變數用來記錄數值。使用變數進行代數計算，則該變數中數值可以隨著程式的邏輯計算而改變。當計算全部結束後，再將數值拿出展示給使用者。
1.1.3 變數的使用格式
日常變數的使用分為四個部分
變數定義格式
資料型別 變數名 = 變數值；
如 int a = 100;
-
變數型別 每一個變數均必須指定其變數型別。Java是強型別語言，在Java中不同的資料型別在記憶體中的儲存方式是不盡相同的。所以必須在儲存內容之前指定資料型別。
-
變數名 即使用識別符號為變數起一個名字，之後在計算時，使用該名字即可參與計算。這個名字就代表了儲存數值的空間。
-
“=”號 這裡的“=”號是運算子的一種，即=代表賦值運算，並非數學意義上的相等。
-
值 即真正變數儲存的數值，需要與變數的資料型別一致。
/*
變數:儲存數值的一塊記憶體區域
變數的定義格式:
資料型別變數名 = 資料值;
*/
public class Demo01Variable{
public static void main(String[] args){
//定義一個儲存整數的變數
int myVar = 10;
//列印變數的值
System.out.println(myVar);//10
//改變變數的值
myVar = 20;
//列印變數的值
System.out.println(myVar);//20
}
}
1.1.4 日常變數使用的注意事項
-
可以同時定義多個變數
-
變數定義後可以不賦值，使用時再賦值。不賦值不能使用。
-
變數使用時有作用域的限制。
/*
變數使用的注意事項:
可以同時定義多個變數
變數定義後可以不賦值，使用時再賦值。不賦值不能使用。
變數使用時有作用域的限制
*/
public class Demo02Variable{
public static void main(String[] args){
//可以同時定義多個變數
int a=5,b=10;
/*
int a = 5;
int b = 10;
*/
System.out.println(a);//5
System.out.println(b);//10
//變數定義後可以不賦值，使用時再賦值。不賦值不能使用。
int c;
//System.out.println(c);//錯誤: 可能尚未初始化變數c
//System.out.println(c=20);
c = 20;
System.out.println(c);
}
}
1.2 資料型別
Java是一種強型別語言，對不同資料結構進行了嚴格的區分，對每一種資料型別都做了明確定義，也同時規定了每一種資料型別的變數在記憶體中佔用空間的大小。
1.2.1 位元組
位元組是計算機當中儲存資料的基本單位，每種資料型別都會佔用一定的空間。
-
位元位
位元位(bit)是計算機當中最小的儲存單位，由於機器碼只識別1與0，所以每一位的1與0均為一個位元位
-
位元組組成規則
在計算機當中如果使用bit來計算資料過於冗餘複雜，所以以8個位元位組成一個新的單位——位元組，作為資料儲存的基本單位
-
常見的資料儲存單位之間的換算
1B（位元組） = 8bit
1KB = 1024B
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB
1.2.2 資料型別分類
資料型別分為基本型別與引用型別，引用型別包括：陣列、類、介面，在面向物件後期會全部介紹完畢。這裡著重介紹基本資料型別。
-
整數型(精確)
int 佔用4個位元組 (整數的預設值)
byte 佔用1個位元組
short 佔用2個位元組
long 佔用8個位元組
long型別在賦值時，需要在值後加入字母l(L)區分其是一個長整型
如 int i = 100; short s = 66; long l = 100L;
-
浮點型(小數型，非精確，為近似值)
double 佔用8個位元組 (小數的預設值)
float 佔用4個位元組
float型別在賦值時，需要在值後加入字母f(F)區分其是一個浮點型
如 double d = 100.0; double d2 = 10.1; float f = 100.0F;
-
字元型
char 佔用2個位元組，必須使用’’包裹，且不能為空。
如 char c = ‘a’; char c2 = ‘中’; char c3 = ‘ (空格)’; char c4 = ‘$’
-
-
轉義字元
-
有時我們無法直接給出一個字元，需要使用轉義字元進行轉義動作。轉義字元也為一個字元，由轉義符號與被轉義字元組成
轉義符號：\
如:
\t 製表符
\’ 單引號
\” 雙引號
\\ 反斜槓
-
-
字元儲存原理
-
每一個值在儲存時，均儲存的為值對應的數字。即字元、聲音、圖片、文字，使用都以數字1或0的方式儲存在計算機中。
每一個英文字元都有其固定的數字對應。英文字元與數字的對應關係組成了一張編碼表，該表名稱為ASCII表。(內容見資料)
-
布林型
布林值是我們比較陌生的型別，它代表一些條件成立與不成立的判斷。只有兩個值true與false。
boolean 佔用1個位元組
如 boolean b = true; boolean b2 = false;
|
型別 |
資料表示範圍 |
|
整數型別byte |
-128～127 |
|
整數型別short |
-32768～32767 |
|
整數型別int(整數的預設值) |
-2147483648～2147483648 |
|
整數型別long |
-263～263-1 |
|
小數型別float |
-3.403E38～3.403E38 |
|
小數型別double(小數的預設值) |
-1.798E308～1.798E308 |
|
字元型別char |
表示一個字元，如('a'，'A'，'0'，'家') |
|
布林型別boolean |
只有兩個值true與false |
/*
資料型別:
整數:(精確)
byte:佔用1個位元組
short:佔用2個位元組
int:佔用4個位元組(預設)
long:佔用8個位元組,使用時必須在末尾加上一個小寫字母l或者大寫字母L
小數:(不精確,近似值)
float:佔用4個位元組,使用時必須在末尾加上一個小寫字母f或者大寫字母F
double:佔用8個位元組(預設)
布林:
boolean:(true,false)佔用1個位元組
字元:
char:佔用2個位元組
注意事項:
字元不能為空
字元實際儲存的是一個數值
想把具有特殊含義',轉換成普通的字元,用轉義字元\'
想把普通字元t,變成一個具有特殊含義的字元,用轉義字元\t
*/
public class Demo03Variable{
public static void main(String[] args){
//整數
byte b = 100;
System.out.println(b);
short s = 10000;
System.out.println(s);
int i = 1600000000;
System.out.println(i);
long l = 6000000000L;
System.out.println(l);
//小數
double d = 3.14;
System.out.println(d);
float f = 2.6f;
System.out.println(f);
//小數是一個不精確的數
System.out.println(f-2);//0.5999999
//布林
boolean b1 = true;
System.out.println(b1);
boolean b2 = false;
System.out.println(b2);
//字元
char c = 'a';
System.out.println(c);
//轉義字元
char c1 = '\'';
System.out.println(c1);
char c2 = '\t';
System.out.println(c2+"Hello");
System.out.println('\\');
//字元實際儲存的是一個數值
System.out.println(c+1);
}
}
1.2.3 數字型別轉換
數字型別可以有資料型別上的轉換，即將一種型別的值賦值給另外一種型別的變數。但要依據資料範圍，符合一定規則：
-
各種資料型別按照資料範圍從小到大：
byte -> short -> int -> long -> float -> double
-
自動型別轉換
範圍小的資料型別值（如int），可以自動轉換為範圍大的資料型別值（如double）
範圍大的資料型別 變數 = 範圍小的資料型別值；
如：
double d = 1000;
或
int i = 100;
double d2 = i;
-
強制型別轉換
範圍大的資料型別值（如double），不可以自動轉換為範圍小的資料型別值（如int），但是可以強制轉換
範圍小的資料型別 變數 = (範圍小的資料型別) 範圍大的資料型別值;
如：
int i = (int)6.718; //i的值為6
或
double d = 3.14;
int i2 = (int)d; //i2的值為3
/*
數字型別轉換:就是數值轉換,包括整數,小數,字元
自動型別轉換:小-->大
byte < short(char)< int < long < float < double
格式:範圍大的資料型別 變數名 = 範圍小的資料型別的值;
強制型別轉換:大-->小
格式:範圍小的資料型別 變數名 = (範圍小的資料型別)範圍大的資料型別的值;
*/
public class Demo04Variable{
public static void main(String[] args){
//自動型別轉換 int --> double
int i = 100;
double d = i;
System.out.println(i);
System.out.println(d);
//強制型別轉換
double d2 = 3.14;
//int i2 = d2;//錯誤: 可能損失精度
int i2 = (int)d2;
System.out.println(i2);
System.out.println(d2);
}
}
1.3 變數案例---超市水果報價單
1.3.1 案例介紹與演示
根據不同的水果種類，使用變數在控制檯列印所有水果價格的列表。
1.3.2 案例分析
我們通過以下方式定義5個變數，來記錄可能改變的資料：
一個記錄整數型別的榴蓮編號
一個記錄小數型別的榴蓮價格
兩個分別記錄字串型別的水果名稱與計價單位
一個記錄字元型別的榴蓮品質
int liulianId = 1;
String liulianName = “榴蓮”;
double liulianPrice = 32.0;
String liulianUnit = “公斤”;
char liulianLevel = ‘A’;
按照同樣的方法，我們也可以將蘋果的編號與屬性用變量表示。(注意命名)
int appleId = 2;
String appleName = “蘋果”;
double applePrice = 6.5;
String appleUnit = “公斤”;
char appleLevel = ‘B’;
這時，再列印時，便可以直接使用變數列印
System.out.println("水果編號 水果名稱 水果單價 計價單位 品質");
System.out.println(" "+ liulianId +" "+ liulianName +" "+
liulianPrice +" "+ liulianUnit +" "+ liulianLevel);
System.out.println(" "+ appleId +" "+ appleName +" "+
applePrice +" "+ appleUnit +" "+ appleLevel);
很明顯，在這種方式列印時價格列表時，可以隨意操作價格或者其他屬性值而後邊打印表單的程式碼不需要更改。我們用變數來記錄各種屬性值，將最終的值儲存到變數中。
/*
水果超市報價單:變數版本
水果編號水果名稱水果單價計價單位品質
1 榴蓮 32.0 公斤 A
2 蘋果 6.5 公斤 B
3 獼猴桃 6.0 公斤 A
分析:定義3組15個變數用來記錄水果資訊
水果編號:採用int型別定義
水果名稱:採用String型別定義
水果單價:採用double型別定義
計價單位:採用String型別定義
品質:採用char型別定義
*/
public class List02{
public static void main(String[] args){
//定義榴蓮的水果資訊
int llId = 1;
String llName = "榴蓮";
double llPrice = 32.0;
String llUnit = "公斤";
char llLevel = 'A';
//定義蘋果的水果資訊
int appleId = 2;
String appleName = "蘋果";
double applePrice = 6.5;
String appleUnit = "公斤";
char appleLevel = 'B';
//定義獼猴桃的水果資訊
int mhtId = 3;
String mhtName = "獼猴桃";
double mhtPrice = 6.0;
String mhtUnit = "公斤";
char mhtLevel = 'A';
System.out.println("水果編號水果名稱水果單價計價單位品質");
System.out.println(llId+" "+llName+" "+llPrice+" "+llUnit+" "+llLevel);
System.out.println(appleId+" "+appleName+" "+applePrice+" "+appleUnit+" "+appleLevel);
System.out.println(3+" 獼猴桃 "+6.0+" 公斤 "+'A');
}
}
第2章 運算子
2.1 運算子概念
運算子是用來計算資料的指令。資料可以是常量，也可以是變數。被運算子操作的數成為運算元。
Int x = 3;
Int y = 4;
Int z = x + y
2.2 算數運算子
將運算元參與數學計算(通常為數學計算)
|
運算子 |
運算規則 |
範例 |
結果 |
|
+ |
正號 |
+3 |
3 |
|
+ |
加 |
2+3 |
5 |
|
+ |
連線字串 |
“中”+“國” |
“中國” |
|
- |
負號 |
int a=3;-a |
-3 |
|
- |
減 |
3-1 |
2 |
|
* |
乘 |
2*3 |
6 |
|
/ |
除 |
5/2 |
2 |
|
% |
取模(餘數) |
5%2 |
1 |
|
++ |
自增 |
int a=1;a++/++a |
2 |
|
-- |
自減 |
int b=3;a--/--a |
2 |
注意：
-
加法運算子在連線字串時要注意，只有直接與字串相加才會轉成字串。
-
除法“/”當兩邊為整數時，取整數部分，舍餘數。當兩邊為浮點型時，按正常規則相除。
-
“%”為整除取餘符號，小數取餘沒有意義。取餘結果的符號與被取餘數的符號相同。
-
得到的是兩個相除資料的餘數。
-
用處: 判斷兩個資料是否整除。
-
-
整數做被除數，0不能做除數，否則報錯。
-
小數做被除數，整除0結果為Infinity，對0取模結果為NaN
-
自增與自減
單獨使用：
前置與後置效果相同，均為直接+1或-1
混合使用：
自增（++）：將變數的值加1，分字首式（如++i）和字尾式（如i++）。字首式是先加1再使用；字尾式是先使用再加1。
自減（--）：將變數的值減1，分字首式（如--i）和字尾式（如i--）。字首式是先減1再使用；字尾式是先使用再減1。
自增與自減運算子還遵循以下規律：
1. 可以用於整數型別byte、short、int、long，浮點型別float、double，以及字串型別char。
2. 在Java5.0及以上版本中，它們可以用於基本型別對應的包裝器類Byte、Short、Integer、Long、Float、Double、Character。
3. 它們的運算結果的型別與被運算的變數的型別相同。
/*
算數運算子:
+,-,*:相當於數學+,-*
+:做為字串連線符
/:兩個整數相除,結果是整數
%:兩個整數取模(餘數),結果是整數
++:自增(自身加1)
--:自減(自身減1)
注意事項:
1.加法運算子在連線字串時要注意，只有直接與字串相加才會轉成字串。
2.除法“/”當兩邊為整數時，取整數部分，舍餘數。當兩邊為浮點型時，按正常規則相除。
3.“%”為整除取餘符號，小數取餘沒有意義。取餘結果的符號與被取餘數的符號相同。
4.整數做被除數，0不能做除數，否則報錯。
5.小數做被除數，整除0結果為Infinity，對0取模結果為NaN
自增與自減
單獨使用：
前置與後置效果相同，均為直接+1或-1
與其他運算子混合使用：
++或- -為前置時，先+1或-1，再使用值。
++或- -為後置時，先使用值再+1或-1。
*/
public class Demo05Operator{
public static void main(String[] args){
//兩個常量相加
System.out.println(3 + 5);//8
//變數加減乘除模
int a = 20;
int b = 7;
System.out.println(a + b);//27
System.out.println(a - b);//13
System.out.println(a * b);//140
System.out.println(a / b);//2
System.out.println(a % b);//6
//+:做為字串連線符
System.out.println("中"+"國");//中國
/*
單獨使用：
前置與後置效果相同，均為直接+1或-1
*/
//++:自增(自身加1)
//--:自減(自身減1)
int c = 10;
int d = 20;
//c++;
//d--;
++c;
--d;
System.out.println("c = " + c);//c = 11
System.out.println("d = " + d);//d = 19
System.out.println("===================================");
//1.加法運算子在連線字串時要注意，只有直接與字串相加才會轉成字串。
int e = 15;
int f = 20;
System.out.println("e + f = " + e + f);//e + f = 1520
System.out.println("e + f = " + (e + f));//e + f = 35
System.out.println(e + f + " = e + f");//35 = e + f
//2.除法“/”當兩邊為整數時，取整數部分，舍餘數。當兩邊有浮點型時，按正常規則相除。
System.out.println(5.0 / 2);//2.5
//3.“%”為整除取餘符號，小數取餘沒有意義。取餘結果的符號與被取餘數(符號左邊的數)的符號相同。
System.out.println(5.1 % 2);//1.0999999999999996
System.out.println(5 % 2);//1
System.out.println(-5 % 2);//-1
System.out.println(5 % -2);//1
System.out.println(-5 % -2);//-1
//4.整數做被除數，0不能做除數，否則報錯。
//System.out.println(5 / 0);//ArithmeticException: / by zero
//5.小數做被除數，整除0結果為Infinity(無窮)，對0取模結果為NaN(not number 無效數字)
System.out.println(5.0 / 0);//Infinity
System.out.println(5.0 % 0);//NaN
System.out.println("===================================");
/*
與其他運算混合使用：
++或- -為前置時，先+1或-1，再使用值。
++或- -為後置時，先使用值再+1或-1。
*/
System.out.println(e);//15
System.out.println(f);//20
System.out.println(e++);//15
System.out.println(f--);//20
System.out.println(e);//16
System.out.println(f);//19
int i1 = 100;
int i2 = i1++ + 200;
System.out.println(i1);//101
System.out.println(i2);//300
int i3 = 100;
int i4 = ++i3 + 200;
System.out.println(i3);//101
System.out.println(i4);//301
}
}
2.3 賦值運算子
為變數賦值的運算子
|
運算子 |
運算規則 |
範例 |
結果 |
|
= |
賦值 |
int a=2 |
2 |
|
+= |
加後賦值 |
int a=2，a+=2 |
4 |
|
-= |
減後賦值 |
int a=2，a-=2 |
0 |
|
*= |
乘後賦值 |
int a=2，a*=2 |
4 |
|
/= |
整除後賦值 |
int a=2，a/=2 |
1 |
|
%= |
取模後賦值 |
int a=2，a%=2 |
0 |
注意：
-
諸如+=這樣形式的賦值運算子，會將結果自動強轉成等號左邊的資料型別。
/*
賦值運算子:
=,+=,-=,*=,/=,%=
+=,-=,*=,/=,%=運算子的運算規則:
先將運算子兩邊進行+,-,*,/,%運算,在把結果賦值給左邊的變數
+=,-=,*=,/=,%=注意事項:運算子左邊必須是一個變數
+=,-=,*=,/=,%=特點:隱含一個強制型別轉換
*/
public class Demo06Operator{
public static void main(String[] args){
int a = 10;
a += 20;//相當於 a = a + 20;
System.out.println("a = " + a);
//5 += 6;//錯誤: 意外的型別,這裡5的位置需要一個變數
byte b = 10;
//b = b + 100;// 錯誤: 可能損失精度
//b = (byte)(b + 100);
b += 100;//+=隱含了一個強制型別轉換 相當於b = (byte)(b + 100);
System.out.println("b = " + b);
}
}
2.4 比較運算子
-
又叫關係運算符，即判斷兩個運算元的大小關係及是否相等關係，比較運算子的返回一定為布林值。
|
運算子 |
運算規則 |
範例 |
結果 |
|
== |
相等於 |
4==3 |
false |
|
!= |
不等於 |
4!=3 |
true |
|
< |
小於 |
4<3 |
false |
|
> |
大於 |
4>3 |
true |
|
<= |
小於等於 |
4<=3 |
false |
|
>= |
大於等於 |
4>=3 |
true |
-
==，!=，>，<，>=，<=
-
關係運算符的結果都是boolean型，也就是要麼是true，要麼是false。
-
注意事項
-
n 關係運算符“==”不能誤寫成“=” 。
public class Demo06Operator {
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 10;
System.out.println(a == b);
System.out.println(a == c);
System.out.println("-----------------");
System.out.println(a != b);
System.out.println(a != c);
System.out.println("-----------------");
System.out.println(a > b);
System.out.println(a > c);
System.out.println("-----------------");
System.out.println(a >= b);
System.out.println(a >= c);
System.out.println("-----------------");
int x = 3;
int y = 4;
// System.out.println(x == y);
// System.out.println(x = y);// 把y賦值給x，把x的值輸出
boolean bb = (x == y);
// 報錯
// boolean cc = (x = y);
int cc = (x = y);
}
}
2.5 邏輯運算子
用於計算兩個布林值經過指定邏輯後的運算結果，結果同樣是一個布林值
|
運算子 |
運算規則 |
範例 |
結果 |
|
& |
與(並且) |
false&true |
False |
|
| |
或 |
false|true |
True |
|
^ |
異或 |
true^flase |
True |
|
! |
非(取反) |
!true |
Flase |
|
&& |
短路與 |
false&&true |
False |
|
|| |
短路或 |
true ||true |
True |
-
作用:邏輯運算子用於連線布林型表示式，在Java中不可以寫成3<x<6，應該寫成x>3 && x<6 。
-
基本使用: &(與),|(或),^(異或),!(非)
-
與：& 有false則false
-
或：| 有true則true
-
異或：^ 相同則false,不同則true
-
非：! true則false,false則true
-
public class Demo08Operator {
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 30;
System.out.println((a > b) & (a > c));// false & false
System.out.println((a < b) & (a > c)); // true & false
System.out.println((a > b) & (a < c)); // false & true
System.out.println((a < b) & (a < c)); // true & true
System.out.println("---------------");
System.out.println((a > b) | (a > c));// false | false
System.out.println((a < b) | (a > c)); // true | false
System.out.println((a > b) | (a < c)); // false | true
System.out.println((a < b) | (a < c)); // true | true
System.out.println("---------------");
System.out.println((a > b) ^ (a > c));// false ^ false
System.out.println((a < b) ^ (a > c)); // true ^ false
System.out.println((a > b) ^ (a < c)); // false ^ true
System.out.println((a < b) ^ (a < c)); // true ^ true
System.out.println("---------------");
System.out.println((a > b)); // false
System.out.println(!(a > b)); // !false
System.out.println(!!(a > b)); // !!false
}
}
-
&&和&的區別
-
單&時，左邊無論真假，右邊都進行運算；
-
雙&時，如果左邊為真，右邊參與運算，如果左邊為假，那麼右邊不參與運算。
-
“|”和“||”的區別同理，雙或時，左邊為真，右邊不參與運算。
-
public class Demo09Operator {
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 30;
System.out.println((a > b) && (a > c));// false && false
System.out.println((a < b) && (a > c)); // true && false
System.out.println((a > b) && (a < c)); // false && true
System.out.println((a < b) && (a < c)); // true && true
System.out.println("---------------");
System.out.println((a > b) || (a > c));// false || false
System.out.println((a < b) || (a > c)); // true || false
System.out.println((a > b) || (a < c)); // false || true
System.out.println((a < b) || (a < c)); // true || true
System.out.println("---------------");
int x = 3;
int y = 4;
// System.out.println((x++ > 4) & (y++ > 5)); // false & false
System.out.println((x++ > 4) && (y++ > 5)); // false && false
System.out.println("x:" + x);
System.out.println("y:" + y);
}
}
2.6 三元運算子
接下來我們要學習的三元運算子與之前的運算子不同。之前學習的均為一元或者二元運算子。元即參與運算的資料。
格式：
-
(條件表示式)？表示式1：表示式2；
-
表示式：通俗的說，即通過使用運算子將運算元聯絡起來的式子，例如：
-
3+2，使用算數運算子將運算元聯絡起來，這種情況，我們稱為算數表示式。
-
3>2，使用比較運算子（也稱為條件運算子）將運算元聯絡起來，這種情況，我們稱為條件表示式。
-
其他表示式，不再一一舉例。
-
-
三元運算子運算規則：
先判斷條件表示式的值，若為true，運算結果為表示式1；若為false，運算結果為表示式2。
注意：
-
三元運算子，最終一定會產生一個結果值，這個值必須被使用起來。
-
要麼被運算子使用，要麼被列印
/*
三元運算子:求兩個數的最大值,判斷兩個數是否相等
格式:
(條件表示式) ? 表示式1 : 表示式2;
執行流程:
首先判斷條件表示式是否成立
true:表示式1作為3元運算子的結果
false:表示式2作為3元運算子的結果
注意：
三元運算子，最終一定會產生一個結果值，這個值必須被使用起來。
要麼被運算子使用，要麼被列印
*/
public class Demo10Operator{
public static void main(String[] args){
int a = 10;
int b = 20;
int max = (a > b) ? 10 : 20;
System.out.println("max = " + max);
int c = 15;
int d = 10;
//System.out.println((c != d) ? "相等" : "不相等");
String s = (c != d) ? "相等" : "不相等";
System.out.println("s = " + s);
//(c != d) ? "相等" : "不相等";//錯誤: 不是語句
//3;//錯誤: 不是語句
}
}
2.7 運算子優先順序
2.7.1 優先順序概念
運算子運算的先後順序，優先順序越高(數字越小)，計算順序越靠前。
2.7.2 優先順序規則
優先順序相同的情況下，按照從左到右的順序依次運算
|
優先順序 |
描述 |
運算子 |
|
1 |
括號 |
()、[] |
|
2 |
正負號 |
+、- |
|
3 |
自增自減，非 |
++、--、! |
|
4 |
乘除，取餘 |
*、/、% |
|
5 |
加減 |
+、- |
|
6 |
移位運算 |
<<、>>、>>> |
|
7 |
大小關係 |
>、>=、<、<= |
|
8 |
相等關係 |
==、!= |
|
9 |
按位與 |
& |
|
10 |
按位異或 |
^ |
|
11 |
按位或 |
| |
|
12 |
邏輯與 |
&& |
|
13 |
邏輯或 |
|| |
|
14 |
條件運算 |
?: |
|
15 |
賦值運算 |
=、+=、-=、*=、/=、%= |
|
16 |
位賦值運算 |
&=、|=、<<=、>>=、>>>= |
2.8 運算子案例---超市購物小票案例
2.8.1 案例介紹與演示
模擬真實購物邏輯，以上述圖片為需求原型，根據不同購物物品完成購物小票內容列印到控制檯。
2.8.2 案例分析
a) 總體思路
案例分析可分為三個部分：
-
小票介面結構分析：通過小票介面分析，可以將複雜的問題簡單化，規劃出來更為具體的需求。
-
資料分析：實際開發過程中的資料是複雜的，存在多個維度的資訊。需要分析出我具體需要操作的資料有哪些
-
業務邏輯分析：在接收到最基本的必要資料後，需要加入業務邏輯來完成所有需求。如本例中，求總價的過程。
b) 小票介面結構分析
票頭: 又分為兩部分，即歡迎光臨歡迎語與具體的物品屬性標題。
票體: 是讀取的真實資料內容，即列印對應的變數值即可。
票腳: 也分為兩部分，即統計資訊與開發票的提醒資訊。這裡為了簡化需求，去掉了時間與付錢找零的統計,只完成商品價錢和數量統計部分。
c) 資料分析
經過觀察，我們確定一項物品應該有如下幾個屬性：
品名：物品名稱，String型
商品編號：用於區分管理商品的編號，String型
售價：物品單價，double型
數量：購買數量，原型中是小數，我們這裡以個為單位，設計成int型
金額：這一項物品的購物總金額，double型
票腳：我們發現三個單獨的可變化量
商品項數：共有幾項商品，int型
共計：所有項商品一共多少件，int型
總計：所有商品花費，double型
d) 邏輯分析
與直接列印資料不同，這個案例的基本需求中存在許多統計資訊，顯然類似總價這樣的值是由其他資料計算得來。
這裡就涉及到了常量或變數的運算問題，需要用到運算子來完成這個需求。
l 普通變數值直接列印
對於普通的商品名稱，商品單價等資訊，讀取使用者資料後可以直接列印。這裡我們先“幫使用者給出資料”。
l 需要計算的資料的列印
票腳部分的三個統計資訊需要經過計算得到並列印：
商品項數：共有幾項商品，直接給出，int型
共計：所有商品數量求和，int型
總計：所有商品金額求和，double型
/*
超市購物小票:
分析:
票頭:
用字串方式直接列印
票體:
先定義3組15個變數用來記錄商品資訊
票腳:
計算:商品種類
計算:商品數量
計算:商品總金額
*/
public class SuperMarketTicket{
public static void main(String[] args){
//先定義3組15個變數用來記錄商品資訊
//定義少林寺酥餅核桃
String slsName = "少林寺酥餅核桃";
String slsID = "(090115)";
double slsPrice = 15.50;
int slsNumber = 22;
double slsMoney = slsPrice * slsNumber;
String xjName = "新疆美味羊肉串";
String xjID = "(090028)";
double xjPrice = 16.00;
int xjNumber = 55;
double xjMoney = xjPrice * xjNumber;
String skName = "尚康雜糧牡丹餅";
String skID = "(090027)";
double skPrice = 14.50;
int skNumber = 24;
double skMoney = skPrice * skNumber;
//計算:商品種類
int goodsItem = 3;
//計算:商品數量
int goodsNumner = slsNumber + xjNumber + skNumber;
//計算:商品總金額
double goodsMoney = slsMoney + xjMoney + skMoney;
//列印小票
//票頭
System.out.println("歡迎光臨");
System.out.println("品名 售價數量金額");
System.out.println("------------------------------------------------");
//票體
System.out.println(slsName+slsID+""+slsPrice+""+slsNumber+""+slsMoney);
System.out.println(xjName+xjID+""+xjPrice+""+xjNumber+""+xjMoney);
System.out.println(skName+skID+""+skPrice+""+skNumber+""+skMoney);
System.out.println("------------------------------------------------");
//票腳
System.out.println(""+goodsItem+" 項商品共計: "+goodsNumner+" 件");
System.out.println("總計: " + goodsMoney);
System.out.println("憑此小票換取發票!");
}
}
第3章 本日自習作業：
3.1 知識點相關題
3.1.1 知識點：變數
要求：
1) 熟練掌握各種基本資料型別及其大小；
2) 熟練掌握各種基本資料型別變數的定義；
3) 熟練掌握資料型別轉換
題目：
1) 寫出8種資料型別的名稱及大小（重要）；
Byte -- 一個位元組 2的1*8次方
Short -- 兩個位元組 2的2*8次方
Int -- 四個位元組 2的4*8次方
Long -- 八個位元組 2的8*8次方
Char -- 兩個位元組 2的2*8次方
Float -- 四個位元組 2的4*8次方
Double -- 八個位元組 2的8*8次方
2) 定義類：Test1，定義main()方法，分別定義8種資料型別的變數，並賦初始值；然後列印每種型別的變數。
程式碼實現：
public class Test1 {
//定義主方法
public static void main(String[] args) {
//在控制檯上列印
byte a = 1;
short b = 2;
int c = 3;
long d = 4;
char e = '5';
float f = 4.5f;
double g = 5.43423;
boolean h = true;
boolean i = false;
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
System.out.println(e);
System.out.println(f);
System.out.println(g);
System.out.println(h);
System.out.println(i);
}
}
3) 定義類：Test2，定義main()方法，請按如下要求編寫程式碼：
a) 定義一個byte型別的變數v1，賦初始值；
將v1賦給一個int型別的變數v2。
將v2賦給一個long型別的變數v3
將v3賦給一個double型別的變數v4
b) 列印每個變數的值；
程式碼實現：
public class Test2 {
//定義主方法
public static void main(String[] args) {
//在控制檯上列印
byte v1 = 5;
int v2 =v1;
long v3 = v2;
double v4 = v3;
System.out.println(v1);
System.out.println(v2);
System.out.println(v3);
System.out.println(v4);
}
}
4) 定義類：Test3，定義main()方法，請按如下要求編寫程式碼：
a) 定義一個double型別的變數v1，賦值為：3.1
定義一個double型別的變數v2，賦值為：88.88
定義一個int型別的變數v3，將v1強轉後賦值給v3
定義一個int型別的變數v4，將v2強轉後賦值給v4
列印v3和v4的值，請觀察一個浮點型被強轉為int型後的結果；
程式碼實現：
public class Test3 {
//定義主方法
public static void main(String[] args) {
//在控制檯上列印
double v1 = 3.1;
double v2 = 88.88;
int v3 =(int)v1;
int v4 = (int)v2;
System.out.println(v3);
System.out.println(v4);
}
}
3.1.2 分析以下需求，並用程式碼實現
1.鍵盤錄入一個三位整數數，請分別獲取該三位數上每一位的數值
2.例如：鍵盤錄入的整數123的個位、十位、百位，分別是3、2、1
3.列印格式:"數字123的個位是 3, 十位是 2, 百位是 1"
程式碼實現：
public class HelloWorld {
//定義主方法
@SuppressWarnings("resource")
public static void main(String[] args) {
//在控制檯上列印
Scanner sc = new Scanner(System.in);
System.out.println("請輸入一個三位數的數值");
int a = sc.nextInt();
int b = a%100%10;
int c = a%100/10;
int d = a/100;
System.out.println("數字a的個位是"+b+", 十位是"+c+", 百位是"+d);
}
}
3.1.3 分析以下需求，並用程式碼實現
1.鍵盤錄入三個int型別的數字
2.要求：
(1)求出三個數中的最小值並列印
(2)求出三個數的和並列印
程式碼實現：
public class Test {
@SuppressWarnings("resource")
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("請依次輸入三個數值");
int a = sc.nextInt();
int b = sc.nextInt();
int c = sc.nextInt();
//求出三個數中的最小值並列印
int temp = a<b?a:b;
int min = temp<c?temp:c;
System.out.println(min);
//求出三個數的和並列印
System.out.println(a+b+c);
}
}
3.1.4 知識點：算數運算子
要求：
1) 熟練掌握算數運算子的使用；
題目：
1) 定義類：Test4，定義main()方法，請按如下要求編寫程式碼：
a) 定義一個int型別的變數v1，初始值：10
定義一個int型別的變數v2，初始值：3
b) 請分別列印這兩個數加，減，乘，除，取模的結果
c) 將v1自增1，將v2自減1
d) 再次列印這兩個數：加，減，乘，除，取模的結果
程式碼實現：
public class Test {
@SuppressWarnings("resource")
public static void main(String[] args) {
int v1 = 10;
int v2 = 3;
//b)列印這兩個數加，減，乘，除，取模的結果
System.out.println(v1+v2);
System.out.println(v1-v2);
System.out.println(v1*v2);
System.out.println(v1/v2);
System.out.println(v1%v2);
//將v1自增1，將v2自減1
//System.out.println(v1++);
System.out.println(++v1);
//System.out.println(v2--);
System.out.println(--v2);
//再次列印這兩個數：加，減，乘，除，取模的結果
System.out.println(v1+v2);
System.out.println(v1-v2);
System.out.println(v1*v2);
System.out.println(v1/v2);
System.out.println(v1%v2);
}
}
3.1.5 知識點：賦值運算子
要求：
1) 熟練掌握賦值運算子的使用；
題目：
1) 定義類：Test5，定義main()方法，請使用賦值運算子編寫程式碼：
a) 定義一個int型別的變數v1，初始值：10
b) 將此變數加10；
c) 將此變數減5；
d) 將此變數乘3；
e) 將此變數除以10；
f) 將此變數模2
g) 列印v1的值
程式碼實現：
package StudyJavaSE;
/**
* 1)請使用賦值運算子編寫程式碼：
* a)定義一個int型別的變數v1，初始值：10
* b)將此變數加10；
* c)將此變數減5；
* d)將此變數乘3；
* e)將此變數除以10；
* f)將此變數模2
* g)列印v1的值
*
* @author 奮鬥蒙
*
*/
public class FuZhiYunsuanfu {
public static void main(String[] args) {
//a)定義一個int型別的變數v1，初始值：10
int a1 = 10;
int a2 = 10;
System.out.println(a1);
System.out.println(a2);
//b)將此變數加10；
a1+=10;
System.out.println(a1);
a2 = a2 + 10;
System.out.println(a2);
//c)將此變數減5；
a1-=5;
System.out.println(a1);
a2 = a2 - 5;
System.out.println(a2);
//d)將此變數乘3；
a1*=3;
System.out.println(a1);
a2 = a2 * 3;
System.out.println(a2);
//e)將此變數除以10；
a1/=10;
System.out.println(a1);
a2 = a2 / 10;
System.out.println(a2);
//f)將此變數模2
a1%=2;
System.out.println(a1);
a2 = a2 % 2;
System.out.println(a2);
}
}
3.1.6 知識點：比較運算子
要求：
1) 熟練掌握比較運算子的使用；
題目：
1) 定義類：Test6，定義main()方法，請按如下要求編寫程式碼：
a) 定義一個int型別的變數v1，初始值：10
定義一個int型別的變數v2，初始值：3
b) 請列印v1是否等於v2
c) 請列印v1是否大於v2
d) 請列印v1是否小於v2
e) 請列印v1是否大於等於v2
f) 請列印v1是否小於等於v2
g) 請列印v1是否不等於v2
程式碼實現：
public class Test {
@SuppressWarnings("resource")
public static void main(String[] args) {
//a)定義一個int型別的變數v1，初始值：10
//定義一個int型別的變數v2，初始值：3
int v1 = 10;
int v2 = 3;
//b)請列印v1是否等於v2
System.out.println(v1==v2);
//c)請列印v1是否大於v2
System.out.println(v1>v2);
//d)請列印v1是否小於v2
System.out.println(v1<v2);
//e)請列印v1是否大於等於v2
System.out.println(v1>=v2);
//f)請列印v1是否小於等於v2
System.out.println(v1<=v2);
//g)請列印v1是否不等於v2
System.out.println(v1!=v2);
}
}
3.1.7 知識點：邏輯運算子
要求：
1) 熟練掌握邏輯運算子的使用；
題目：
1) 定義類：Test7，定義main()方法，請按如下要求編寫程式碼：
a) 定義一個int型別的變數v1，初始值：24
定義一個double型別的變數v2，初始值：3.14
b) 請列印：v1 是否大於20，並且小於50
c) 請列印：v1是否小於20，或者大於50
d) 請列印：v1是否大於20，並且v2小於3.5
e) 請使用“非運算子”判斷：v1是否不等於25
package StudyJavaSE;
/**
* 請按如下要求編寫程式碼：
* a)定義一個int型別的變數v1，初始值：24
* 定義一個double型別的變數v2，初始值：3.14
* b)請列印：v1 是否大於20，並且小於50
* c)請列印：v1是否小於20，或者大於50
* d)請列印：v1是否大於20，並且v2小於3.5
* e)思考：請使用“非運算子”判斷：v1是否不等於25
* @author 奮鬥蒙
*
*/
public class LuoJiYunsuanfu {
public static void main(String[] args) {
//a)定義一個int型別的變數v1，初始值：24
//定義一個double型別的變數v2，初始值：3.14
int v1 = 24;
double v2 = 3.14;
//b)請列印：v1 是否大於20，並且小於50
System.out.println((v1>10)&(v1<50));
//c)請列印：v1是否小於20，或者大於50
System.out.println((v1<20)|(v1>50));
//d)請列印：v1是否大於20，並且v2小於3.5
System.out.println((v1>20)&(v2<3.15));
}
}
3.1.8 知識點：三元運算子
要求：
1) 熟練掌握三元運算子的使用；
題目：
1) 定義類：Test8，定義main()方法，請按如下要求編寫程式碼：
a) 定義一個int型別的變數v1，初始值：20
定義一個int型別的變數v2，初始值：18
b) 請使用三元運算子求兩個數的最大值，並列印；
程式碼實現：
public class Test {
@SuppressWarnings("resource")
public static void main(String[] args) {
// a)定義一個int型別的變數v1，初始值：20
// 定義一個int型別的變數v2，初始值：18
int v1 = 20;
int v2 = 18;
// b)請使用三元運算子求兩個數的最大值，並列印；
System.out.println(v1>v2?v1:v2);
}
}
2) 定義類：Test9，定義main()方法，請按如下要求編寫程式碼：
a) 定一個int型別的變數v1，初始值20；
定義一個String型別的變數v2，初始值：“”
b) 請使用三元運算子判斷：如果v1大於20，v2的值為：大於，
否則，將v2的值賦值為：不大於。
c) 列印v2的值
程式碼實現：
public class Test {
@SuppressWarnings("resource")
public static void main(String[] args