java學習第二章-數據類型和運算符（僅做個人學習筆記用）

2.1註釋

 單行註釋：  使用“//”開頭，“//”後面的單行內容均爲註釋。

多行註釋：   以“/*”開頭以“*/”結尾，在“/*”和“*/”之間的內容爲註釋，我們也可以使用多行註釋作爲行內註釋。但是在使用時要注意，多行註釋不能嵌套使用。

文檔註釋：   以“/**”開頭以“*/”結尾，註釋中包含一些說明性的文字及一些JavaDoc標籤(後期寫項目時，可以生成項目的API)

2.2標識符

標識符是用來給變量、類、方法以及包進行命名的，如Welcome、main、System、age、name、gender等。標識符需要遵守一定的規則：

標識符必須以字母、下劃線_、美元符號$開頭。

標識符其它部分可以是字母、下劃線“_”、美元符“$”和數字的任意組合。

Java 標識符大小寫敏感，且長度無限制。

標識符不可以是Java的關鍵字

標識符的使用規範：

表示類名的標識符：每個單詞的首字母大寫，如Man, GoodMan

表示方法和變量的標識符：第一個單詞小寫，從第二個單詞開始首字母大寫，我們稱之爲“駝峯原則”，如eat(), eatFood()

【注意】：Java不採用通常語言使用的ASCII字符集，而是採用Unicode這樣標準的國際字符集。因此，這裏字母的含義不僅僅是英文，還包括漢字等等。但是不建議大家使用漢字來定義標識符！

2.2java中的關鍵字/保留字

Java關鍵字是Java語言保留供內部使用的，如class用於定義類。 關鍵字也可以稱爲保留字，它們的意思是一樣的，我們不能使用關鍵字作爲變量名或方法名。

Java中的關鍵字/保留字
abstract	assert	boolean	break	byte	case
catch	char	class	const	continue	default
do	double	else	extends	final	finally
float	for	goto	if	implements	import
instanceof	int	interface	long	native	new
null	package	private	protected	public	return
short	static	strictfp	super	switch	synchronized
this	throw	throws	transient	try	void
volatile	while

2.4.1變量的本質

 Java是一種強類型語言，每個變量都必須聲明其數據類型。變量的數據類型決定了變量佔據存儲空間的大小。

變量作爲程序中最基本的存儲單元，其要素包括變量名，變量類型和作用域。變量在使用前必須對其聲明, 只有在變量聲明以後，才能爲其分配相應長度的存儲空間。

注意事項

每個變量都有類型，類型可以是基本類型，也可以是引用類型。

變量名必須是合法的標識符

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

 2.4.2變量的分類

從整體上可將變量劃分爲局部變量、成員變量(也稱爲實例變量)和靜態變量。

局部變量、成員變量、靜態變量的區別
類型	聲明位置	從屬於	生命週期
局部變量	方法或語句塊內部	方法/語句塊	從聲明位置開始，直到方法或語句塊執行完畢，局部變量消失
成員變量 (實例變量)	類內部，方法外部	對象	對象創建，成員變量也跟着創建。對象消失，成員變量也跟着消失；
靜態變量 (類變量)	類內部，static修飾	類	類被加載，靜態變量就有效；類被卸載，靜態變量消失。

局部變量(local  variable)：

方法或語句塊內部定義的變量。生命週期是從聲明位置開始到到方法或語句塊執行完畢爲止。局部變量在使用前必須先聲明、初始化(賦初值)再使用。

public void test() {
   int i;
   int j = i+5 ; // 編譯出錯，變量i還未被初始化 
} 
  
public void test() {
   int i;
   i=10;
   int j = i+5 ; // 編譯正確
}

 

成員變量（也叫實例變量  member variable）：

 方法外部、類的內部定義的變量。從屬於對象，生命週期伴隨對象始終。如果不自行初始化，它會自動初始化成該類型的默認初

實例變量的默認初始值
數據類型	實始值
int	0
double	0.0
char	‘\u0000’
boolean	false

public class Test {
    int i;
}

 

 靜態變量（類變量 static variable）：

使用static定義。 從屬於類，生命週期伴隨類始終，從類加載到卸載。如果不自行初始化，與成員變量相同會自動初始化成該類型的默認初始值，如上面表所示。

/**
 * 測試變量
 * 
 * @author 
 *
 */
public class TestVariable {
 
    int a;            //成員變量, 從屬於對象； 成員變量會自動被初始化
    static  int  size;   //靜態變量，從屬於類
     
    public static void main(String[] args) {
 
        {
            int age;        //局部變量，從屬於語句塊；
            age = 18;
        }
         
        int salary = 3000;    //局部變量，從屬於方法
 
        int gao = 13;
        System.out.println(gao);
 
        int i;
    //    int j = i + 5; // 編譯出錯，變量i還未被初始化
         
    }
}

2.5常量（Constant）

常量通常指的是一個固定的值，例如：1、2、3、’a’、’b’、true、false、”helloWorld”等。

在Java語言中，主要是利用關鍵字final來定義一個常量。 常量一旦被初始化後不能再更改其值。

聲明格式爲：

1	final  type  varName = value;

    public static void main(String[] args) {
        final double PI = 3.14;
        // PI = 3.15; //編譯錯誤，不能再被賦值！ 
        double r = 4;
        double area = PI * r * r;
        double circle = 2 * PI * r;
        System.out.println("area = " + area);
        System.out.println("circle = " + circle);
    }
}

爲了更好的區分和表述，一般將1、2、3、’a’、’b’、true、false、”helloWorld”等稱爲字面常量，而使用final修飾的PI等稱爲符號常量。

變量和常量命名規範：

1、所有變量、方法、類名：見名知意

2、類成員變量：首字母小寫和駝峯原則:  monthSalary

3、局部變量：首字母小寫和駝峯原則

4、常量：大寫字母和下劃線：MAX_VALUE

5、類名：首字母大寫和駝峯原則:  Man, GoodMan

6、方法名：首字母小寫和駝峯原則: run(), runRun()

2.6基本數據類型(primitive data type)

Java是一種強類型語言，每個變量都必須聲明其數據類型。 Java的數據類型可分爲兩大類：基本數據類型（primitive data type）和引用數據類型（reference data type）。

Java中定義了3類8種基本數據類型

數值型－ byte（1）、 short（2）、int（4）、 long（8）、float（4）、 double（8）

字符型－ char（2）

布爾型－boolean （1Bit）

注意事項

引用數據類型的大小統一爲4個字節，記錄的是其引用對象的地址！

2.6.1整型變量/常量

整型用於表示沒有小數部分的數值，它允許是負數。整型的範圍與運行Java代碼的機器無關，這正是Java程序具有很強移植能力的原因之一。與此相反，C和C++程序需要針對不同的處理器選擇最有效的整型。

整型數據類型
類型	佔用存儲空間	表數範圍
byte	1字節（8位）	-27 ~   27-1（-128~127）【2的7次方】
short	2字節	-215 ~   215-1（-32768~32767）【2的15次方】
int	4字節	-231 ~   231-1 (-2147483648~2147483647)約21億【2的31次方】
long	8字節	-263 ~   263-1【2的63次方】

Java 語言整型常量的四種表示形式

十進制整數，如：99, -500, 0

八進制整數，要求以 0 開頭，如：015

十六進制數，要求 0x 或 0X 開頭，如：0x15

二進制數，要求0b或0B開頭，如：0b01110011

 Java語言的整型常數默認爲int型，聲明long型常量可以後加‘ l ’或‘ L ’ 。

long a = 55555555;  //編譯成功，在int表示的範圍內(21億內)。
long b = 55555555555;//不加L編譯錯誤，已經超過int表示的範圍。
long b = 55555555555L;//無錯

 

2.6.2浮點型變量/常量

帶小數的數據在Java中稱爲浮點型。浮點型可分爲float類型和double類型。

浮點型數據類型
類型	佔用存儲空間	表數範圍
float	4字節	-3.403E38~3.403E38
double	8字節	-1.798E308~1.798E308

float類型又被稱作單精度類型，尾數可以精確到7位有效數字，在很多情況下，float類型的精度很難滿足需求。而double表示這種類型的數值精度約是float類型的兩倍，又被稱作雙精度類型，絕大部分應用程序都採用double類型。浮點型常量默認類型也是double。

Java浮點類型常量有兩種表示形式

十進制數形式，例如:3.14       314.0      0.314 

科學記數法形式，如314e2      314E2      314E-2

 

 

 

2.6.3字符型變量/常量

字符型在內存中佔2個字節，在Java中使用單引號來表示字符常量。例如’A’是一個字符，它與”A”是不同的，”A”表示含有一個字符的字符串。

char 類型用來表示在Unicode編碼表中的字符。Unicode編碼被設計用來處理各種語言的文字，它佔2個字節，可允許有65536個字符。

Unicode具有從0到65535之間的編碼，他們通常用從’\u0000’到’\uFFFF’之間的十六進制值來表示（前綴爲u表示Unicode） 

 Java 語言中還允許使用轉義字符 ‘\’ 來將其後的字符轉變爲其它的含義。

轉義符	含義	Unicode值
\b	退格（backspace）	\u0008
\n	換行	\u000a
\r	回車	\u000d
\t	製表符（tab）	\u0009
\“	雙引號	\u0022
\‘	單引號	\u0027
\\	反斜槓	\u005c

/**
 * 測試字符類型和布爾類型
 * @author 
 *
 */
public class TestPrimitiveDataType3 {
	public static void main(String[] args) {
	char a = 'T';
	char b = '上';
	char c = '\u0061';
	System.out.println(c);//a
	
	//轉義字符
	System.out.println('a'+'b');//195
	System.out.println(""+'a'+'b');//ab
	System.out.println(""+'a'+'\n'+'b');//a換行b
	System.out.println(""+'a'+'\t'+'b');//a	b
	System.out.println(""+'a'+'\''+'b');//a'b
	
	//String就是字符序列
	String d = "abc";
	
	//測試布爾類型
	boolean man = true;
	if(man) {  //極端不推薦：man == true;
		System.out.println("男性");
	}
	}
	

}

---

2.6.4 boolean類型變量/常量

boolean類型有兩個常量值，true和false，在內存中佔一位（不是一個字節），不可以使用 0 或非 0 的整數替代 true 和 false ，這點和C語言不同。 boolean 類型用來判斷邏輯條件，一般用於程序流程控制 。

---

 

2.7運算符

算術運算符	二元運算符	+，-，*，/，%
	一元運算符	++，--
賦值運算符		=
擴展運算符		+=，-=，*=，/=
關係運算符		>，<，>=，<=，==，!=  instanceof
邏輯運算符		&&，||，!，^
位運算符		&，|，^，~ ， >>，<<，>>>
條件運算符		? :
字符串連接符		+

---

 

2.7.1算數運算符

算術運算符中+，-，*，/，%屬於二元運算符，二元運算符指的是需要兩個操作數才能完成運算的運算符。其中的%是取模運算符，就是我們常說的求餘數操作。

　　二元運算符的運算規則：

　　整數運算：

　　1. 如果兩個操作數有一個爲Long, 則結果也爲long。

　　2. 沒有long時，結果爲int。即使操作數全爲short，byte，結果也是int。

　　浮點運算：

　　3. 如果兩個操作數有一個爲double，則結果爲double。

　　4. 只有兩個操作數都是float，則結果才爲float。

　　取模運算：

　　1.其操作數可以爲浮點數,一般使用整數，結果是“餘數”，“餘數”符號和左邊操作數相同，如：7%3=1，-7%3=-1，7%-3=1。

　　算術運算符中++，--屬於一元運算符，該類運算符只需要一個操作數。

/**
 * 測試算數運算符
 * @author 
 *
 */
public class TestOperator01 {
	public static void main(String[] args) {
		/*
		byte a = 1;
		int b = 2;
		long b2 = 3;
		//byte c = a+b;//報錯
		//int d = b+b2;//報錯
		
		float f1 = 3.14f;//不加f也會報錯，因爲默認Double類型
		float d = b+b2;
		
		//float f2 = f1+6.4;//報錯，6.4位Double類型
		
		//取餘
		System.out.println(9%5);
		*/
		
		
		//測試自增和自減
		int a = 3;
		int b = a++;
		System.out.println("a="+a+"\nb="+b);//a=4,b=3
		a = 3;
		b = ++a;
		System.out.println("a="+a+"\nb="+b);//a=4,b=4
		
		
		
	}
}

---

2.7.2賦值及其擴展賦值運算符

運算符	用法舉例	等效的表達式
+=	a += b	a = a+b
-=	a -= b	a = a-b
*=	a *= b	a = a*b
/=	a /= b	a = a/b
%=	a %= b	a = a%b

                int a = 3;
		int b = 4;
		a+=b;//a=a+b
		System.out.println("a="+a+"\nb="+b);//a=7,b=4
		a=3;
		a*=b+3;//a=a*(b+3);
		System.out.println("a="+a+"\nb="+b);//a=21,b=4

---

2.7.3關係運算符

關係運算符用來進行比較運算，關係運算的結果是布爾值：true/false；

運算符	含義	示例
==	等於	a==b
!=	不等於	a!=b
>	大於	a>b
<	小於	a<b
>=	大於或等於	a>=b
<=	小於或等於	a<=b

=是賦值運算符，而真正的判斷兩個操作數是否相等的運算符是==。

==、!= 是所有（基本和引用）數據類型都可以使用

> 、>=、 <、 <= 僅針對數值類型（byte/short/int/long,  float/double。以及char）

/**
 * 測試關係運算符
 * @author 
 *
 */
public class TestOperator02 {
	public static void main(String[] args) {
		int a = 3;
		System.out.println(a==3);//true
		System.out.println(a!=3);//false
		
		char b='a';
		char b2='c';
		
		System.out.println((int)b);//97
		System.out.println(0+b);//97
		System.out.println(0+b2);//99
		System.out.println(b<b2);//true
	}
}

---

 

 2.7.4邏輯運算符

 邏輯運算的操作數和運算結果都是boolean值。

運算符		說明
邏輯與	&( 與)	兩個操作數爲true，結果纔是true，否則是false
邏輯或	|(或)	兩個操作數有一個是true，結果就是true
短路與	&&( 與)	只要有一個爲false，則直接返回false
短路或	||(或)	只要有一個爲true， 則直接返回true
邏輯非	!（非）	取反：!false爲true，!true爲false
邏輯異或	^（異或）	相同爲false，不同爲true

短路與和短路或採用短路的方式。從左到右計算，如果只通過運算符左邊的操作數就能夠確定該邏輯表達式的值，則不會繼續計算運算符右邊的操作數，提高效率。 

 

/**
 * 邏輯運算符
 * @author 
 *
 */
public class TestOperator03 {
	public static void main(String[] args) {
		boolean b1 = true;
		boolean b2 = false;
		System.out.println(b1&b2);//b1與b2，false
		System.out.println(b1|b2);//b1或b2,true
		System.out.println(b1^b2);//b1異或b2,true
		System.out.println(!b2);//b2取反,true
		
		//短路
		//int c = 3/0;//報錯
		//boolean b3 = 1>2&2<(3/0);//報錯
		boolean b3 = 1>2&&2<(3/0);//短路與，第一個操作的值爲false。則不需要再計算後面的操作數。
		System.out.println(b3);
	}
}

---

 2.7.5位運算符

位運算符	說明
~	取反
&	按位與
|	按位或
^	按位異或
<<	左移運算符，左移1位相當於乘2
>>	右移運算符，右移1位相當於除2取商

 

1. &和|既是邏輯運算符，也是位運算符。如果兩側操作數都是boolean類型，就作爲邏輯運算符。如果兩側的操作數是整數類型，就是位運算符。

2. 不要把“^”當做數學運算“乘方”，是“位的異或”操作。

 

/**
 * 位運算符
 * @author 
 *
 */
public class TestOperator04 {
	public static void main(String[] args) {
	int a=3;//011
	int b=4;//100
	System.out.println(a&b);//0
	System.out.println(a|b);//7
	System.out.println(a^b);//7
	System.out.println(~a);//-4
	
	//移位
	int c=3<<2;//左移兩位*4，左移移位*2；
	System.out.println(c);//12
	System.out.println(12>>1);//6
	}
}

---

2.7.6字符串連接符

 “+”運算符兩側的操作數中只要有一個是字符串(String)類型，系統會自動將另一個操作數轉換爲字符串然後再進行連接。

/**
 * 字符串連接符
 * @author niu
 *
 */
public class TestOperator05 {
	public static void main(String[] args) {
		String a="3";
		int b=4;
		int c=5;
		System.out.println(a+b+c);//345，因爲有字符串a在，所以加號就是連接符
		System.out.println(b+c+a);//93
		
		char d='a';
		System.out.println(d+4);//101=97(ASCII值)+4
	}
}

---

2.7.7條件運算符

 

語法格式：

1

x ? y : z

 其中 x 爲 boolean 類型表達式，先計算 x 的值，若爲true，則整個運算的結果爲表達式 y 的值，否則整個運算結果爲表達式 z 的值。

/**
 * 條件運算符（三元運算符）
 * @author 
 *
 */
public class TestOperator06 {
	public static void main(String[] args) {
		int score = 80;
		int x = -100;
		String type = score<60?"不及格":"及格";
		System.out.println(type);
		
		
		if(score<60){
			System.out.println("不及格");
		}else {
			System.out.println("及格");
		}
		
		System.out.println(x>0?1:(x==0?0:-1));
	}
}

---

2.7.8運算符優先級的問題

優先級	運算符	類	結合性
1	()	括號運算符	由左至右
2	!、+（正號）、-（負號）	一元運算符	由左至右
2	~	位邏輯運算符	由右至左
2	++、--	遞增與遞減運算符	由右至左
3	*、/、%	算術運算符	由左至右
4	+、-	算術運算符	由左至右
5	<<、>>	位左移、右移運算符	由左至右
6	>、>=、<、<=	關係運算符	由左至右
7	==、!=	關係運算符	由左至右
8	&	位運算符、邏輯運算符	由左至右
9	^	位運算符、邏輯運算符	由左至右
10	|	位運算符、邏輯運算符	由左至右
11	&&	邏輯運算符	由左至右
12	||	邏輯運算符	由左至右
13	? :	條件運算符	由右至左
14	=、+=、-=、*=、/=、%=	賦值運算符、擴展運算符	由右至左

不需要去刻意的記這些優先級，表達式裏面優先使用小括號來組織！！

邏輯與、邏輯或、邏輯非的優先級一定要熟悉！（邏輯非>邏輯與>邏輯或）。如：

a||b&&c的運算結果是：a||(b&&c)，而不是(a||b)&&c 

---

 2.8.1自動類型轉換

自動類型轉換指的是容量小的數據類型可以自動轉換爲容量大的數據類型。如圖所示，紅色的實線表示無數據丟失的自動類型轉換，而虛線表示在轉換時可能會有精度的損失。

 可以將整型常量直接賦值給byte、 short、 char等類型變量，而不需要進行強制類型轉換，只要不超出其表數範圍即可。

/**
 * 測試類型轉化,容量小的向容量大的轉化
 * @author 
 *
 */
public class TestTypeConvert {
	public static void main(String[] args) {
	int a=324;
	long b=a;
	double d=b;
	//a=b;//報錯，b的類型大於a的類型
	
	//long e=3.23f;//報錯，float雖然四字節，long八字節，但是float範圍比long大
	float f=234324L;//不報錯
	
	//特例
	byte b2=123;//byte範圍是-128~+127
	
	}
}

---

 2.8.2強制類型轉換

強制類型轉換，又被稱爲造型，用於顯式的轉換一個數值的類型。在有可能丟失信息的情況下進行的轉換是通過造型來完成的，但可能造成精度降低或溢出。

語法格式：

1

(type)var

 運算符“()”中的type表示將值var想要轉換成的目標數據類型。

當將一種類型強制轉換成另一種類型，而又超出了目標類型的表數範圍，就會被截斷成爲一個完全不同的值。

不能在布爾類型和任何數值類型之間做強制類型轉換。

        //強制轉換
	double x=3.14;
	int nx=(int)x;
	char c='a';
	int d=c+1;
	System.out.println(nx);//3
	System.out.println(d);//98
	System.out.println((char)d);//b
	
	//強制轉換超出了表數範圍
	int y=300;
	byte by=(byte)y;
	System.out.println(by);//值爲44

---

2.8.3基本類型轉化時常見錯誤和問題

操作比較大的數時，要留意是否溢出，尤其是整數操作時。

/**
 * 轉換出錯
 * @author 
 *
 */
public class TestTypeConvertError {
	public static void main(String[] args) {
		int money = 1000000000;//10億
		int years = 20;
		//返回的total是負數，超過了int的範圍
		int total = money*years;
		System.out.println("total="+total);//total1=-1474836480
		//返回的total1仍然是負數。默認是int，因此結果會轉換成int值，再轉換成long。但是已經發生了數據丟失
		long total1 = money*years;
		System.out.println("total1="+total1);//total1=-1474836480
		//返回的total2正確，先將一個引子變成long，整個表達式發生提升。全部用long來計算
		long total2=money*((long)years);
		System.out.println("total2="+total2);//total2=20000000000
		
		long total3 = 34L*3223*years*223423;
		System.out.println("total3="+total3);//total3=489662783720
	}
}

 

---

2.9簡單的鍵盤輸入輸出

import java.util.Scanner;
/**
 * 測試獲得鍵盤輸入
 * @author 
 *
 */
public class TestScanner {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("請輸入名字：");
		String name = scanner.nextLine();
		System.out.println("請輸入你的愛好：");
		String favor = scanner.nextLine();
		System.out.println("請輸入你的年齡：");
		int age = scanner.nextInt();
		
		System.out.println("$$$$$$$$");
		System.out.println(name);
		System.out.println(favor);
		System.out.println(age);
	}

}

結果：

請輸入名字：
bab
請輸入你的愛好：
打球
請輸入你的年齡：
66
$$$$$$$$
bab
打球
66

 

---

第二章作業

一、選擇題

1、CD//public屬於關鍵字，標識符不可以以數字開頭

2、C

3、A

4、AB

5、AB

二、簡答題

1、.Java是一種強類型語言，說明Java的數據類型分類。答：

Java是一種強類型語言，每個變量都必須聲明其數據類型。 Java的數據類型可分爲兩大類：基本數據類型（primitive data type）和引用數據類型（reference data type）。

Java中定義了3類8種基本數據類型

數值型－ byte、 short、int、 long、float、 double

字符型－ char

布爾型－boolean 

引用數據類型的大小統一爲4個字節，記錄的是其引用對象的地址！

2、 i++和++i的異同之處。答：

i++，先賦值再加1

++i，先加1再賦值

3、運算符||和|的異同之處。答：

邏輯或（|）：兩個操作數有一個是true，結果就是true；

短路或（||）：只要有一個爲true，則直接返回true。

4、.Java中基本數據類型轉換的規則。答：

自動類型轉換指的是容量小的數據類型可以自動轉換爲容量大的數據類型；

 可以將整型常量直接賦值給byte、 short、 char等類型變量，而不需要進行強制類型轉換，只要不超出其表數範圍即可；

紅色的實線表示無數據丟失的自動類型轉換，而虛線表示在轉換時可能會有精度的損失。

 三、編碼題

1、輸入圓形半徑，求圓形的周長和圓形的面積，並將結果輸出。

import java.util.Scanner;
/**
 * 作業第二章1題
 * @author niu
 *
 */
public class ZuoYe201 {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("請輸入圓的半徑：");
		float R = scanner.nextFloat();
		float C = 2*3.14F*R;
		float S = 3.14F*R*R;
		
		System.out.println("該圓的半徑爲R="+R);
		System.out.println("該圓的周長爲C="+"2*3.14*"+R+"="+C);
		System.out.println("該圓的面積爲S="+"3.14*"+R+"*"+R+"="+S);
		
	}		
}

結果：

請輸入圓的半徑：
12.5
該圓的半徑爲R=12.5
該圓的周長爲C=2*3.14*12.5=78.5
該圓的面積爲S=3.14*12.5*12.5=490.625

2、 銀行利率表如下表所示，請計算存款10000元，活期1年、活期2年，定期1年，定期2年後的本息合計。

 

java.math.BigDecimal;
/**
 * 作業第二章2題，用BigDecimal
 * @author 
 *
 */
public class ZuoYe202_2 {
	public static void main(String[] args) {
		BigDecimal Money = BigDecimal.valueOf(10000);
		BigDecimal Hqck = BigDecimal.valueOf(0.0035);
		BigDecimal Dq_3Month = BigDecimal.valueOf(0.011);
		BigDecimal Dq_6Month = BigDecimal.valueOf(0.013);
		BigDecimal Dq_12Month = BigDecimal.valueOf(0.015);
		BigDecimal Dq_24Month = BigDecimal.valueOf(0.021);
		BigDecimal Year = BigDecimal.valueOf(2);
		
		BigDecimal Money_HqOneYear = Money.multiply(Hqck);
		BigDecimal Money_DqOneYear = Money.multiply(Dq_12Month);
		BigDecimal Money_HqTwoYear = Money.multiply(Hqck.multiply(Year));
		BigDecimal Money_DqTwoYear = Money.multiply(Dq_24Month.multiply(Year));
		
		System.out.println("本金："+Money);
		System.out.println("活期一年本金總計："+Money+Money_HqOneYear);
		System.out.println("定期一年本金總計："+Money+Money_DqOneYear);
		System.out.println("活期兩年本金總計："+Money+Money_HqTwoYear);
		System.out.println("定期兩年本金總計："+Money+Money_DqTwoYear);
	}

}

結果：

本金：10000
活期一年本金總計：1000035.0000
定期一年本金總計：10000150.000
活期兩年本金總計：1000070.0000
定期兩年本金總計：10000420.000

3、 某個公司採用公用電話傳遞數據，數據是四位的整數，在傳遞過程中是加密的，加密規則如下：每位數字都加上5,然後用和除以10的餘數代替該數字，再將第一位和第四位交換，第二位和第三位交換。結果如圖所示。

import java.util.Scanner;
/**
 * 作業第二章3題
 * @author 
 *
 */
public class ZuoYe203 {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int a;//申請四位的變量
		int b;
		int c;
		int d;
		int f;//交換時用
		
		System.out.println("請輸入一個4位正整數：");
		int number = scanner.nextInt();
		
		d = number%10;//求得個位數
		c = number/10%10;//求得十位數
		b = number/100%10;//求得百位數
		a = number/1000%10;//求得千位數
		
		d = (d+5)%10;
		c = (c+5)%10;
		b = (b+5)%10;
		a = (a+5)%10;
		
		f = a;//個位和千位換位置
		a = d;
		d = f;
		
		f = b;//十位和百位換位置
		b = c;
		c = f;
		
		number = a*1000+b*100+c*10+d;//求得最後要輸出的數
		
		System.out.println(number);
	}

}

結果：

請輸入一個4位正整數：
1357
2086