實驗一 Java編程基礎
實驗1-1 變量的自動類型轉換
一、實驗描述
1、 考核知識點
名 稱：變量的類型轉換
2、 練習目標
- 了解變量進行自動類型轉換的條件
3、 需求分析
變量的自動類型轉換，指的是兩種數據類型在轉換的過程中不需要顯式地進行聲明。為了明確哪些數據類型可以實現自動轉換，本實驗演示的是將一種數據類型的值賦給另外一種數據類型變量的情形。
4、 設計思路（實現原理）
1） 編寫一個類Example01。
2） 在類Example01中，定義byte類型的變量a，int類型的變量b，float類型的變量f，double類型的變量d，其中，變量a的初始值為10，變量f的初始值為12.5f。
3） 將變量a的值賦給變量b，變量a、b、f相加后的結果值賦給變量d。
4） 使用println語句打印出變量b和變量d的值。
二、實驗實現
定義Example01類：
package cn.itcast.Example01;
public class Example01 {
public static void main(String[] args) {
byte a=10;
int b;
float f=12.5f;
double d;
b=a;
d=a+b+f;
System.out.printf("b="+b+" "+"d="+d);
}
}
運行結果截圖為圖1-1
圖1-1 運行結果
三、實驗總結
1、要實現自動類型轉換，必須同時滿足兩個條件，第一是兩種數據類型彼此兼容，第二是目標類型的取值范圍大於源類型的取值范圍。
2、列出三種可以進行自動類型轉換的情況，具體如下：
（1）整數類型之間可以實現轉換，如byte類型的數據可以賦值給short、int、long類型的變量，short、char類型的數據可以賦值給int、long類型的變量，int類型的數據可以賦值給long類型的變量。
（2）整數類型轉換為float類型，如byte、char、short、int類型的數據可以賦值給float類型的變量。
（3）其它類型轉換為double類型，如byte、char、short、int、long、float類型的數據可以賦值給double類型的變量。
實驗1-2 變量的強制類型轉換
一、實驗描述
1、 考核知識點
名 稱：變量的類型轉換
2、 練習目標
- 掌握不同數據類型間的強制類型轉換
3、 需求分析
強制類型轉換也叫顯式類型轉換，指的是兩種數據類型之間的轉換需要進行顯式地聲明。例如，兩種類型彼此不兼容，或者目標類型取值范圍小於源類型，都需要進行強制類型轉換。
4、 設計思路（實現原理）
1） 編寫一個類Example02
2） 在Example02中的main()方法中定義一個int類型的變量i和byte類型的變量b，並將變量i的值賦給變量b
3） 使用println語句打印出變量b的值
二、實驗實現
定義Example02類：
package cn.itcast.Example02;
public class Example02 {
public static void main(String[] args) {
int i=10;
byte b;
b=(byte)i;
System.out.println("b="+b);
}
}
運行結果截圖為圖1-2：
圖1-2 運行結果
三、實驗總結
1、強制類型轉換，具體格式如下：
目標類型 變量 = （目標類型）值
2、在對變量進行強制類型轉換時，會發生取值范圍較大的數據類型向取值范圍較小的數據類型的轉換，如將一個int類型的數轉為byte類型，這樣做極容易造成數據精度的丟失。int在內存中占用4個字節。byte類型的數據在內存中占用1個字節，當將變量i的數據在內存中占的內存大於1個字節時，前面3個高位字節的數據會丟失，數值也會發生改變。
實驗1-3 運算符的優先級
一、實驗描述
1、 考核知識點
名稱：運算符的優先級
2、 練習目標
- 掌握運算符之間的優先級
3、 需求分析
當使用不同的運算符進行運算時，應該按照一定的順序進行運算，即根據運算符的優先級進行運算。
4、 設計思路（實現原理）
1） 編寫一個類Example03
2） 在main方法中定義兩個int型變量x和y
3） 將表達式3>2*x?x++:--x賦值給y
4） 用輸出語句分別輸出變量x和y的值
二、實驗實現
定義Example03類：
package cn.itcast.Example03;
public class Example03 {
public static void main(String[] args) {
int x=1,y;
y=3>2*x?x++:--x;
System.out.println("x="+x+" "+"y="+y);
}
}
運行結果截圖為圖1-3：
圖1-3 運行結果
三、實驗總結
1、本實驗中表達式的運算過程如下所示：
1） 在表達式y=3>2*x?x++:--x；中賦值運算符=的優先級最低，所以要先運算=右側的表達式；
2） ？：為三元運算符，該運算符的優先級較低，要先運算？前面的表達式。
3） *的優先級比>的高，所以3>2*1為true。按照三元運算符的運算規則表達式等價於y=x++
4） x++的++在后面，所以要先進行其它運算再自增，最后結果為x=2,y=1
2、下表列舉了Java中運算符的優先級，數字越小優先級越高。
| 優先級 |
運算符 |
| 1 |
. [] () |
| 2 |
++ -- ~ ! (數據類型) |
| 3 |
* / % |
| 4 |
+ - |
| 5 |
<< >> >>> |
| 6 |
< > <= >= |
| 7 |
== != |
| 8 |
& |
| 9 |
^ |
| 10 |
| |
| 11 |
&& |
| 12 |
|| |
| 13 |
?: |
| 14 |
= *= /= %= += -= <<= >>= >>>= &= ^= |= |
3、其實沒有必要去刻意記憶運算符的優先級。由於運算符“()”的優先級最高，編寫程序時，盡量使用括號“()”來實現想要的運算順序，以免產生歧義。
實驗1-4 if條件語句
一、實驗描述
1、 考核知識點
名稱：if條件語句
2、 練習目標
- 掌握if條件語句的語法格式
- 了解if條件語句的執行流程
3、 需求分析
if…else if…else語句用於對多個條件進行判斷，進行多種不同的處理。本實驗使用if…else if…else語句實現判斷某月是哪個季節的功能。
設計思路（實現原理）
1）編寫一個類Example04
2）定義一個變量month用於存儲月份。
3）用if條件語句，判斷這個月份在哪一個季節並輸出結果，如：春季是3、4、5月，夏季是6、7、8月，秋季是9、10、11月，冬季是12、1、2月
4）由於一年只有12個月，所以要過濾除1-12以外的月份值
二、實驗實現
定義Example04類：
package cn.itcast.Example04;
public class Example04 {
public static void main(String[] args) {
int month=5;
if(month<1||month>12)
System.out.println("月份輸入不合理！");
else
{
if (month==3||month==4||month==5)
System.out.println(month+"月是春季");
else if (month==6||month==7||month==8)
System.out.println(month+"月是夏季");
else if (month==9||month==10||month==11)
System.out.println(month+"月是秋季");
else if (month==12||month==1||month==2)
System.out.println(month+"月是冬季");
}
}
}
運行結果截圖為圖1-4：
圖1-4 運行結果
三、實驗總結
1、f…else if…else語句用於對多個條件進行判斷，進行多種不同的處理。if…else if…else語句具體語法格式如下：
if (判斷條件1) {
執行語句1
} else if (判斷條件2) {
執行語句2
}
...
else if (判斷條件n) {
執行語句n
} else {
執行語句n+1
}
if…else if…else語句的執行流程如圖1-5所示。
圖1-5 流程圖
2、因為一年只有12個月，所以當month>12時是不符合邏輯的數據，這時會打印“沒有這個月份”。在編程過程中，經常要考慮程序在實際環境下是否符合邏輯需求。
3、“||”表示或操作，當運算符兩邊的操作數任何一邊的值為true時，其結果為true，當兩邊的值都為false時，其結果才為false。所以只要符合三個條件中的一個就會被判斷為這個季節。
實驗1-5 switch條件語句
一、實驗描述
1、 考核知識點
名稱：switch條件語句
2、 練習目標
- 熟悉switch條件語句的語法格式
- 了解switch條件語句的特點
3、 需求分析
switch 條件語句也是一種很常用的選擇語句，和if條件語句不同，它只能針對某個表達式的值作出判斷，從而決定程序執行哪一段代碼。本實驗使用switch 條件語句實現判斷選擇題對錯的功能。
4、 設計思路（實現原理）
1）編寫一個類Example05
2）定義一個變量answer用於存儲答案選項
3）用switch條件語句判斷如果變量answer為B則正確，其它則錯誤
4）如果變量answer不等於ABCD四個選擇則打印“不存在此選項”
二、實驗實現
定義Example05類：
package cn.imust.Example05;
public class Example05 {
/**
* @param args
*/
public static void main(String[] args) {
char answer='C';
switch(answer)
{
case 'A':
System.out.println("A答案錯誤");
break;
case 'B':
System.out.println("B答案正確");
break;
case 'C':
System.out.println("C答案錯誤");
break;
case 'D':
System.out.println("D答案錯誤");
break;
default:
System.out.println("不存在此選項");
}
}
}
運行結果截圖為圖1-6：
圖1-6 運行結果
三、實驗總結
1、switch語句的執行流程是：根據表達式的值查找與其匹配的項,如果有匹配項,則執行該匹配項下面的語句。如果沒有匹配項，就會執行default后面的語句。
2、switch關鍵字后括號內的表達式可以是byte,short,int,char四種類型；在JDK5以后表達式可以是枚舉；在.JDK7以后表達式可以是字符串。
3、switch語句只適合判斷若干值的情況，不適合判斷范圍。
4、if和switch都可以判斷值的情況，這時應該使用switch語句，因為switch的效率比if語句高。
實驗1-6 while循環語句
一、實驗描述
1、 考核知識點
名稱：while循環語句
2、 練習目標
- 掌握while循環語句的語法格式和使用
- 了解while循環語句的特點
3、 需求分析
while語句會反復地進行條件判斷，只要條件成立，{}內的執行語句就會執行，直到條件不成立，while循環才會結束。本實驗使用while語句實現統計1-10以內奇數的功能。
4、 設計思路（實現原理）
1）編寫一個類Example06
2）定義一個變量x為1，用while語句循環條件為x<=10
3）在while循環中，使用表達式x%2判斷是否為奇數，如果為奇數，則變量count的值加1。
二、實驗實現
package cn.imust.Example06;
public class Example06 {
public static void main(String[] args) {
int x=1,count=0;
while(x<=10)
{
if(x%2!=0)
count++;
x++;
}
System.out.println("10以內奇數有"+count+"個");
}
}
運行結果截圖為圖1-7：
圖1-7 運行結果
三、實驗總結
1、while循環語句和條件判斷語句有些相似，都是根據條件判斷來決定是否執行大括號內的執行語句。區別在於，while語句會反復地進行條件判斷，只要條件成立，{}內的執行語句就會執行，直到條件不成立，while循環結束。
2、while循環的執行流程如圖1-8所示。
圖1-8 流程圖
實驗1-7 for循環語句
一、實驗描述
1、 考核知識點
名稱：for循環語句
2、 練習目標
- 掌握for循環語句的語法格式和使用
- 了解for循環語句的特點
3、 需求分析
for循環語句是最常用的循環語句，一般用在循環次數已知的情況下。本實驗使用for循環語句計算1+2+3+4+5...+100表達式的結果
4、 設計思路（實現原理）
1）編寫一個類Example07
2）在該類中定義一個變量sum來存儲每次循環整數相加的和。
3）在for循環語句中定義變量x,循環條件為x<=100
二、實驗實現
定義Example07類：
package Example07;
public class Example07 {
/**
* @param args
*/
public static void main(String[] args) {
int i,sum=0;
for(i=1;i<=100;i++){
sum+=i;
}
System.out.println("1~100相加為"+sum);
}
}
運行結果截圖為圖1-9：
圖1-9
三、實驗總結
1、在for循環中，for關鍵字后面()中包括了三部分內容：初始化表達式、循環條件和操作表達式，它們之間用“;”分隔，{}中的執行語句為循環體。
2、通過序號來具體分析for循環的執行流程。具體如下：
for（① ; ② ; ③）{
④
}
第一步，執行①
第二步，執行②，如果判斷結果為true，執行第三步，如果判斷結果為false，執行第五步
第三步，執行④
第四步，執行③，然后重復執行第二步
第五步，退出循環
實驗1-8 for循環嵌套
一、實驗描述
1、 考核知識點
名稱：循環嵌套
2、 練習目標
- 掌握循環嵌套的使用和執行順序
3、 需求分析
在編程過程中，經常需要雙重循環或多重循環，這就需要循環語句的嵌套。最常見的循環嵌套就是在for循環中嵌套for循環。為了讓初學者熟悉for循環嵌套的使用，本實驗將演示如何用for循環嵌套打印由“*”組成的直角三角形。具體要求如下：
l 第一個三角形為倒直角三角形，共5行，第一行5個 “*”，一行減少一個，第5行一個“*”
l 將倒直角三角形上下翻轉為正直角三角形，第一行1一個“*”，第5行5個“*”
4、 設計思路（實現原理）
1） 分析第一個三角形的打印，外層for循環控制行數，初始化表達式從0開始，循環條件為小於5；第一行是5個“*”所以應該內層循環打印5次，初始化表達式從0開始，循環條件為小於5。同理，內層的循環初始化和條件如下所示：
0 1 2 3 4
1 2 3 4
2 3 4
3 4
4
由此可見內層循環的初始化表達式y 與外層的x是相等的，循環條件都是小於5。
2） 分析第二個三角形的打印，第一行1個“*”，第二行2個“*”...由此可見，內層循環的循環次數與行數是相等的，所以內層循環的y小於或等於外層的x。
二、實驗實現
定義Example08類:
package Example08;
public class Example08 {
/**
* @param args
*/
public static void main(String[] args) {
int i,j;
for(i=5;i>0;i--)
{
for(j=i;j>0;j--)
System.out.print("*");
System.out.println();
}
//System.out.println();
for(i=1;i<=5;i++)
{
for(j=i;j>0;j--)
System.out.print("*");
System.out.println();
}
}
}
運行結果截圖為圖1-10：
1-9運行結果
三、實驗總結
由於嵌套循環程序比較復雜，下面分步驟進行講解，具體如下：
第一個三角形：
1、 當x=0時，y=0且y<5，循環5次，完成后返回到外層循環進行換行。
2、 當x=1時，y=1且y<5，循環4次，完成后返回到外層循環換行。
3、 當x=2時，y=2，循環3次，完成后返回到外層循環換行。
4、 當x=3時，y=3，循環2次，完成后返回到外層循環換行。
5、 當x=4時，y=4，循環1次，完成后返回到外層循環換行。由於x<5所以循環終止，打印結束。
第二個三角形：
1、 當x=0時，y=0且y<=0，循環1次，完成后返回到外層循環進行換行。
2、 當x=1時，y=0且y<=1，循環2次，完成后返回到外層循環進行換行。
3、 當x=2時，y=0且y<=2，循環3次，完成后返回到外層循環進行換行。
4、 當x=3時，y=0且y<=3，循環4次，完成后返回到外層循環進行換行。
5、 當x=4時，y=0且y<=4，循環5次，完成后返回到外層循環進行換行。由於x<5所以循環終止，打印結束。
實驗1-9 方法的定義
一、實驗描述
1、 考核知識點
名稱：方法的定義
2、 練習目標
- 掌握方法的定義
3、 需求分析
為了減少重復代碼編寫的問題，Java中可以將具有相同功能的重復代碼提取出來，封裝成方法。本實驗定義一個方法，該方法能夠實現四則運算的功能。
4、 設計思路（實現原理）
1） 編寫一個類Example09
2） 定義一個方法siZe，設置三個參數，兩個數字為int型，一個符號為char型
3） 在方法中，用if選擇語句根據傳入的符號參數進行不同的運算
4） 如果傳入的符號不包含在加減乘除四個符號中則輸出“符號錯誤”
5） 在main方法中調用方法計算3*0的結果，測試方法是否成功運算出正確結果
二、實驗實現
定義Example09類：
package cn.imust.Example010;
public class Example010 {
/**
* @param args
*/
int a=3,c=0;
char b='+';
static int sum;
static int setsize(int a,char b,int c)
{
if(b=='+')
sum=a+c;
else if(b=='-')
sum=a-c;
else if(b=='*')
sum=a*c;
else if(b=='/')
sum=a/c;
System.out.println(sum);
return 0;
}
public static void main(String[] args) {
int a=3,c=0;
char b='*';
if(b=='*'||b=='/'||b=='+'||b=='-')
setsize(a,b,c);
else
System.out.println("符號錯誤！");
//System.out.println(sum);
}
}
運行結果截圖為圖1-11：
圖1-9 運行結果
三、實驗總結
1、在Java中，聲明一個方法的具體語法格式如下：
修飾符 返回值類型 方法名([參數類型 參數名1,參數類型 參數名2,．．．．．．]){
// 執行語句
return 返回值;
}
2、需要特別注意的是，方法中的“參數類型 參數名1，參數類型 參數名2”被稱作參數列表，它用於描述方法在被調用時需要接收的參數，如果方法不需要接收任何參數，則參數列表為空，即()內不寫任何內容。方法的返回值必須為方法聲明的返回值類型，如果方法中沒有返回值，返回值類型要聲明為void，此時，方法中return語句可以省略。
實驗1-10 方法的重載
一、實驗描述
1、 考核知識點
名稱：方法的重載
2、 練習目標
- 了解重載的定義
- 掌握方法重載的用法
3、 需求分析
方法重載指的是方法名相同，參數類型或個數不同。本實驗通過方法重載的方式實現九九乘法表的打印
4、 設計思路（實現原理）
1） 編寫一個類Example10
2） 在Example10中定義一個帶參數的方法print99，該參數用於指定乘法表打印的行數
3） 在Example10中定義一個方法print99，此方法沒有參數。
4） 在main方法中分別調用無參方法print99()和有參方法print99(6)，測試兩個重載的方法print99能否成功打印出符合要求的乘法表。
二、實驗實現
定義Example10類，代碼如下所示:
package cn.imust.Example09;
class print99{
private int b;
public print99()
{
}
public print99(int B)
{
b=B;
}
void setchen()
{
int i,j;
for(i=1;i<=b;i++)
{
for(j=1;j<=i;j++)
{
System.out.print(j+"*"+i+"="+(i*j)+" ");
}
System.out.println();
}
}
}
//import java.util.Scanner;
public class Example09 {
/**
* @param args
*/
public static void main(String[] args) {
print99 p1=new print99();
print99 p2=new print99(6);
p2.setchen();
}
}
運行結果截圖為圖1-12：
圖1-10 運行結果
三、實驗總結
1、方法的重載是在一個程序中定義多個名稱相同的方法，但是參數的類型或個數必須不同。
2、值得注意的是，方法的重載與返回值類型無關，它只有兩個條件，一是方法名相同，二是參數個數或參數類型不相同。
實驗1-11 一維數組的定義
一、實驗描述
1、 考核知識點
名稱：數組的定義
2、 練習目標
- 掌握一維數組的定義
3、 需求分析
數組是指一組數據的集合，數組中的每個數據被稱作元素。在數組中可以存放任意類型的元素，但同一個數組里存放的元素類型必須一致。請定義一個數組，將序列{0,1,2,3,4}賦值給數組，並寫一個方法用來訪問數據的每一個元素。
4、 設計思路（實現原理）
1） 定義一個數組，在初始化數組時有一種方式叫做靜態初始化，就是在定義數組的同時就為數組的每個元素賦值。可以在定義數組時將序列{0,1,2,3,4}賦值給數組。
2） 定義一個方法輸出數組的元素，可以用for循環語句依次輸出數組的元素，各元素用“，”間隔可以更清楚的輸出元素。
3） 在最后一個元素輸出時，后面就不需要加“，”了，所以循環到length-1時不打印“，”。
二、實驗實現
定義Example11類:
package cn.imust.Example111;
public class Example11 {
static int a[]={0,1,2,3,4};
static void print()
{
int i;
System.out.print(a[0]);
for(i=1;i<5;i++)
{
System.out.print(","+a[i]);
}
}
/**
* @param args
*/
public static void main(String[] args) {
print();
}
}
運行結果截圖為圖1-13：
圖1-11 運行結果
三、實驗總結
1、每個數組的索引都有一個范圍，即0~length-1。在訪問數組的元素時，索引不能超出這個范圍，否則程序會報數組越界異常ArrayIndexOutOfBoundsException。所謂異常指程序中出現的錯誤，它會報告出錯的異常類型、出錯的行號以及出錯的原因。
2、在使用變量引用一個數組時，變量必須指向一個有效的數組對象，如果該變量的值為null，則意味着沒有指向任何數組，此時通過該變量訪問數組的元素會出現空指針異常NullPointerException。
實驗1-12 數組最值
一、實驗描述
1、 考核知識點
名稱：數組的常見操作-數組的最值
2、 練習目標
- 掌握如何獲取一維數組的最值
3、 需求分析
在操作數組時，經常需要獲取數組中元素的最值。定義一個數組，並獲取該數組中值最小的元素。
4、 設計思路（實現原理）
1） 定義一個數組。
2） 定義一個方法，用來獲取最小值。該方法應返回一個int型的數值，參數為數組類型。在方法中，定義一個臨時變量min，用於記住數組的最小值。首先假設數組中第一個元素arr[0]為最小值，然后使用for循環對數組進行遍歷，在遍歷的過程中只要遇到比min值還小的元素，就將該元素賦值給min。這樣一來，變量min就能夠在循環結束時記住數組中的最小值。
3） 在main方法中調用該方法，將定義的數組作為參數傳給方法，獲取該數組的最小值。
二、實驗實現
定義Example12類:
package cn.imust.Example12;
public class Example12 {
public static int setmix(int []a)
{
int mix=a[0];
for(int i=1;i<a.length;i++){
if(a[i]<mix)
mix=a[i];
}
return mix;
}
/**
* @param args
*/
public static void main(String[] args) {
int [] a={1,9,7,0,2,5};
int mix=setmix(a);
System.out.print("最小值是"+mix);
}
}
運行結果截圖為圖1-14：
圖1-12 運行結果
三、實驗總結
getMin()方法用於求數組中的最小值，該方法中定義了一個臨時變量min，用於記住數組的最小值。需要注意的是，在for循環中的變量i是從1開始的，這樣寫的原因是程序已經假設第一個元素為最小值，for循環中只需要從第二個元素開始比較，從而提高程序的運行效率。
實驗1-13 數組排序
一、實驗描述
1、 考核知識點
名稱：數組的常見操作-數組的排序
2、 練習目標
- 掌握一維數組中元素的排序
3、 需求分析
在操作數組時，經常需要對數組中元素進行排序。常用的排序算法有選擇排序，冒泡排序等。請定義一個數組，用選擇排序算法將數組中的元素進行從小到大的排序。
4、 設計思路（實現原理）
選擇排序法的原理是：首先找到數組中的最值，將最小值（最大值）的下標與第一個元素
的下標交換，再在剩下的元素中找最小值（最大值）的下標與第二個元素的下標交換，以此類推，完成所有元素的排序。
對數組元素進行選擇排序的設計思路是：
1） 定義排序方法，在方法中，用for循環嵌套實現排序。第一層循環是從數組的第一個元
素開始循環。第二層循環用於與第一層循環中的元素比較找出最值，並將最小值的下標跟第一個元素的下標進行互換。
2） 為了方便觀察排序結果，輸出排序前和排序后的數組元素。
二、實驗實現
定義Example13類:
package cn.imust.Example13;
public class Example13 {
static void setpx(int []a){
int i,j,temp;
for(i=0;i<4;i++)
for(j=i+1;j<5;j++)
if(a[i]>a[j])
{
temp=a[j];
a[j]=a[i];
a[i]=temp;
}
//System.out.print(" "+a[j]);
System.out.println("排序后的數組:");
for(int k=0;k<5;k++)
System.out.print(a[k]+" ");
}
/**
* @param args
*/
public static void main(String[] args) {
int []a={1,9,7,0,5};
System.out.println("排序前的數組:");
for(int k=0;k<5;k++)
System.out.print(a[k]+" ");
System.out.println();
setpx(a);
}
}
運行結果截圖為圖1-15：
圖1-13 運行結果
三、實驗總結
常用的排序算法除了選擇排序外，還有冒泡排序。在冒泡排序的過程中，不斷地比較數組中相鄰的兩個元素，較小者向上浮，較大者往下沉，整個過程和水中氣泡上升的原理相似。
接下來通過幾個步驟來具體分析一下冒泡排序的整個過程，具體如下：
1、 從第一個元素開始，將相鄰的兩個元素依次進行比較，直到最后兩個元素完成比較。如果前一個
元素比后一個元素大，則交換它們的位置。整個過程完成后，數組中最后一個元素自然就是最大值，這樣也就完成了第一輪比較。
2、 除了最后一個元素，將剩余的元素繼續進行兩兩比較，過程與第一步相似，這樣就可以將數組中
第二大的數放在了倒數第二個位置。
3、 以此類推，持續對越來越少的元素重復上面的步驟，直到沒有任何一對元素需要比較為止。