108
java基礎DAY 03
DAY 03
循環結構：
代表語句：while、do while、for
while格式：
初始化表達式；
while (條件表達式)
｛
循環體（執行語句）；
｝
1、while
格式：
while格式：
初始化表達式；
while (條件表達式)
｛
循環體（執行語句）；
｝
例1：先判斷是否滿足條件然後再執行循環體
class xunhuan
{
public static void main(String[] args)
{
int x=1;//如果取偶數直接x=0
while (x<=10)
{
System.out.println("x="+x);
//x++;
x+=2;//取10以內的奇數，x+=2就是x=x+2
/*如果沒有這個X++或x+2的話將是無限循環，因為條件限製將不起作用。
這裏也可以是X--，但是需要改變條件
例如：int x=10
while (x>0)
*/
}
System.out.println("==================");
}
}
2、do while
格式：
do while格式：
定義初始化表達式；
do
｛
執行語句；
｝
while （條件表達式）
例：先執行do語句，然後再判斷。
class while2
{
public static void main(String[] args)
{
int y=11;/*當y的值<=10的時候輸出結果和上麵一樣，但是當y大於10
的時候，do 下麵的執行語句會執行一次
*/
do
{
System.out.println("y="+y);
y+=2;
}
while (y<=10);
System.out.println("==================");
/*
while和do while的區別：
while語句現判斷條件再執行語句，隻有條件滿足才執行循環體
do while語句現執行語句再判斷條件，無論條件是否滿足，循環體都執行一次。
*/
}
}
3、for
格式：
for (初始化表達式；循環條件表達式；循環後的操作表達式)
｛
執行語句；（循環體）;
｝
例1：
class for1
{
public static void main(String[] args)
{
for (int z=0;z<3 ;z++ )
{
System.out.println("z="+z);
}
// System.out.println ("z==="+z);
System.out.println("==================");
}
}
上麵循環的過程：
1、執行變量 int z=0
2、判斷z是否小於3
3、z小於3則直接跳到循環體，打印z=+z 0
4、3執行完後跳到z++第一次自加
5、Z++後判斷z是否小於3
6、小於3，直接跳到循環體，打印z=+z 1
7、6執行完後跳到z++第二次自加
8、Z++後判斷z是否小於3
9、小於3，直接跳到循環體，打印z=+z 2
10、9執行完後跳到z++第三次自加
11、z++後判斷z是否小於3
12、不小於3跳出循環體
例2：while語句與for語句對比
class for1
{
public static void main(String[] args)
{
int a=0;
while (a<3)
{
System.out.println ("a="+a);
a++;
}
System.out.println ("a==="+a); //打印出a自加後的值。
}
}
特點：
1、變量有自己的作用域
2、for和while可以互換使用
初始化變量（z）在for語句中，隻在循環體內生效，如果跳出循環體後內存自動釋放。
while語句的初始化變量(a)在循環體外麵，所以可以打印出a自加後的值。
也就是說，for和while語句中，初始化變量的作用域不同。
for 語句更節省內存。
如果當初始化值隻為循環增量存在的話使用for合適。
for和while可以互換使用，for能寫的while也能寫，while能寫的for也能寫。
總結：什麼時候使用循環結構?
當對某些語句使用很多次時，就使用循環結構。
4、循環語句的其他特點：
例：
class xhother
{
public static void main(String[] args)
{
int x=0;
/*for (System.out.println("A");System.out.println("B") ; System.out.println("C"))
條件表達式，必須要有真假判斷，並且隻要是合法表達式就可以運行。
*/
for (System.out.println("A");x<3 ; System.out.println("C"),x++)
{
System.out.println("D");
}
/*
無限循環的最簡單表現形式：
for(;;){} for循環可以不寫初始化表達式；循環條件表達式；循環後的操作表達式，這時條件表達式默認為true
while(true){}
*/
System.out.println("Over");
}
}
5、for語句累加計數器
例1：
class foradd
{
public static void main(String[] args)
{
int he=0;//定義一個變量用來存儲不斷變化的he
//定義右邊的被加數變量為a，也就是需要進行參加運算的數。
for (int a=0;a<=10;a++ )
{
he+=a;//he=he+a，循環後打印he
}
System.out.println(he);
//while的方式
int a=0;
int x=0;
while (x<=10)
{
a=a+x;
x++;
}
System.out.println(a);
}
/*
0+1+2+3+4也就是0+1=1；1+2=3；3+3=6；6+4=10，就是說左邊的數是
兩個數相加的和（不確定的數），右邊的數是順序變化的（累加的數）。
*/
}
例2：
/*
for語句練習-累加&計數器
1~100之間 7的倍數的個數，並打印。
思路：
1、對1-100進行循環
2、在循環過程中定義條件，隻對7的倍數進行操作。x%7==0
3、判斷那些是7的倍數使用if語句，
4、循環過程中將7的倍數記錄下來，定義一個變量a，a隨著7的倍數遞增。
將其定義到循環外麵，
如果定義到裏麵循環結束後將被內存釋放
*/
class foradd2
{
public static void main(String[] args)
{
int a=0; //定義一個變量用來記憶循環次數。
for (int x=1 ;x<=100 ;x++ )//對1-100進行一個循環。
{
if (x%7==0) //x%7=0時也就是可以整除7的數，也就是7的倍數。
{
a++;//記憶不斷變化的循環次數。
}
}
System.out.println(a); //打印出一共循環了多少次。
}
}
/*
編程思想：
1、累加思想，通過變量記錄住，循環操作後的結果。（字符串的不斷延長）
通過循環的形式，進行累加動作。
2、計數器思想，通過一個變量，記錄住數據的狀態變化，也需要通過循環完成。
*/
6、for嵌套
例：for嵌套就是在for語句中再加一個for語句。
class forandfor
{
public static void main(String[] args)
{
for (int x=0;x<3 ;x++ )//當x小於3滿足後進入內循環
{
for (int y=0;y<4 ;y++ )//當內循環，循環結束後，
//也就是打印4次y後再次回到外循環。
{
System.out.print("*");
}
System.out.println();//隻有一個功能就是換行
}
}
}
解釋：
****
****
****
對於上麵的長方形外循環控製行數，內循環控製每一行的列數，也就是一行中元素的個數。
例：三角形循環01
class forandfor
{
public static void main(String[] args)
{
for (int x=0;x<5 ;x++ )//當x小於5滿足後進入內循環
{
for (int y=x;y<5 ;y++)//當內循環，循環結束後，
//內循環變量y根據X的變化逐漸接近5，使打印的列數越來越小。
{
System.out.print("*");
}
System.out.println();//隻有一個功能就是換行
}
}
}
解釋：
*****
****
***
**
*
對於上麵圖形首先確定，外循環控製的行數為5，
內循環控製的列數為5，並且遞減。
例：三角形循環2
class forandfor
{
public static void main(String[] args)
{
for (int x=0;x<5 ;x++ )//當x小於5滿足後進入內循環
{
for (int y=0;y<=x ;y++)//當內循環，循環結束後，
//內循環變量y根據X的變化逐漸接近5，使打印的列數越來越小。
{
System.out.print("*");
}
System.out.println();//隻有一個功能就是換行
}
}
}
解釋：
*
**
***
****
*****
初始化值x=0的時候是5個星號,x=1的時候是4個星號。。。。。。
當條件y<x的時候圖形發生變化。變成正三角。
1、尖朝上，可以改變條件，讓條件隨著外循環變化。
2、尖朝下，可以改變初始化值，讓初始化值隨著外循環變化。
例：九九乘法表
class forandfor
{
public static void main(String[] args)
{
for (int x=1;x<=9 ;x++ )
{
for (int y=1;y<=x ;y++) //條件語句y<=x，y根據x的變化而變化，
{
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
}
}
解釋：
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
乘數都是1
被乘數遞增
7、其他流程控製語句
break（跳出）：應用範圍，選擇結構和循環結構。定義在循環語句內才有效果
continue：繼續循環。continue下麵的語句無法執行，將會返回上麵的操作。結束本次循環繼續下次循環。
例：
class forandfor
{
public static void main(String[] args)
{
w:for (int x=0;x<3 ;x++ )
{
System.out.println("x="+x);
//break;//打印一次後跳出循環，
//System.out.println("OK") 這行不能加，break下麵的語句無效。
q:for (int y=0;y<3 ;y++ )
{
System.out.println("y="+y);
System.out.println("跳出循環w");
break w ;//不加標識符時，隻跳內循環
}//w ,q是標識符break標誰跳誰
}
System.out.println("===========================");
for (int x=1;x<=10 ;x++ )
{
if (x%2==1)
{
continue;//如果 x%2==1則打印下麵的語句。
}
System.out.println("x="+x);
System.out.println("當x為偶數時continue繼續循環");
}
System.out.println("===========================");
w:for (int x=0;x<9 ;x++ )
{
for (int y=0;y<9 ;y++ )
{
System.out.println("y");
continue w;// 循環跳到外循環。
//System.out.println("x");這行如果不注釋會報錯，因為continue下麵的語句無法執行.
}
}
System.out.println("===========================");
}
}
8、練習
例：等邊三角形
class forandfor
{
public static void main(String[] args)
{
for (int x=0 ; x<5 ; x++ ) //定義外循環，來控製行數，上圖刪掉空格是5行。
{
for (int y=x+1;y<5 ;y++ )//定義內循環控製列數，打印出-號。
//注意倒三角改變初始化值。
{
System.out.print("-");
}
for (int z=0;z<=x ;z++ )//再次定義內循環打印出星號。
//注意正三角改變條件。
{
System.out.print("* ");
}
System.out.println();
}
System.out.println("==================================");
for (int x=0;x<5;x++ )
{
for (int y=x;y<5 ;y++ )
/*初始化值x=0的時候是5個星號,x=1的時候是4個星號。。。。。。
當條件y<x的時候圖形發生變化。變成正三角。
1、尖朝上，可以改變條件，讓條件隨著外循環變化。
2、尖朝下，可以改變初始化值，讓初始化值隨著外循環變化。
*/
{
System.out.print("-");
}
System.out.println();
}
}
}
9、函數
函數的定義：函數就是定義在類中的具有特定功能的一段獨立小程序。
函數也稱為方法。
格式：
修飾符 返回值類型 函數名 （參數類型 形式參數1，參數類型 形式參數2 ...）
{
執行語句；
return 返回值；
}
返回值類型：函數運行後的結果的數據類型
參數類型：是形式參數的數據類型
形式參數：是一個變量，用於存儲調用函數時傳遞給函數的實際參數。
實際參數：傳遞給形式參數的具體數值。
return: 用於結束函數。
返回值： 該值會返回給調用者
提高代碼和功能的複用性
例1：重複代碼的出現
class function1
{
public static void main(String[] args)
{
int x=1;
System.out.println(x*3+5);
int y=2;
System.out.println(x*3+5);
/*打印出任意數乘以3加5的值，如果多個值都要保存時，
需要重複輸入相同的輸出語句。
發現以上的運算，因為獲取不同數據的運算結果，代碼出現了重複。
為了提高代碼的複用性，對代碼進行抽取。
將這個部分定義成一個獨立的功能，方便日後使用。
JAVA中對功能的定義是通過函數的形式來體現的。
這時就需要定義一個函數。
*/
}
}
例2：解決重複代碼問題
class function1
{
public static void main(String[] args)
{
int z=get(5);//調用函數get 注意該行調用語句不能直接在類下，並且不要寫在函數中。
System.out.println(z);
}
public static int get(int num)
{
return num*3+5;
}
}
例3：沒有返回值時返回值類型使用void
class function1
{
public static void main(String[] args)
{
get2(2);
}
public static void get2(int a)
{
System.out.println (a*3+5);
//當函數運算後，沒有具體的返回值時，這時返回值使用void代表，
//void代表的是函數沒有具體返回值的情況。
//當函數返回值類型為void時，函數中的return語句可以省略不寫。
}
}
10、函數的應用
函數的應用：
1、定義功能時，把不同的功能定義到函數中。
2、主函數的功能主要是，調用函數用。
如何定義函數：
1、既然函數是一個獨立的功能，那麼該功能的運算結果是什麼先明確。
2、在明確在定義該功能的過程中是否需要未知的內容參與運算。
例1：
需求：定義一個功能，完成3+4的運算，並將結果返回給調用者。
思路：
1、明確功能的結果是一個整數的和；
2、在實現該功能過程中是否有未知內容參與運算。沒有！！！
為了方便用戶需求，有用戶來指定加數和被加數才有意義。
其實這兩個功能就是在明確函數的定義：
1、是在明確函數的返回值類型。
2、明確函數的參數列表（參數類型和形式參數）
該函數沒有實際意義，因為不管誰調用返回值都是一樣的。
class function1
{
public static void main(String[] args)
{
int x=he();
System .out.println(x);
}
public static int he ()
{
return 3+4;
}
}
例2：根據例1定義一個求和的函數，可以輸出任何兩個數的和。多個參數使用逗號隔開。
class function1
{
public static void main(String[] args)
{
int x=he(2,4);
System.out.println(x);
}
public static int he (int a ,int b)
{
return a+b;
}
}
例3：同一個類中函數的名稱相同，兩個相同名稱的函數隻有參數列表不同。
class function1
{
public static void main(String[] args)
{
int x=he(2,4);
System.out.println(x);
int y=he(0,2,3);
System.out.println(y);
}
public static int he (int a ,int b)
{
return a+b;
}
public static int he (int a, int b, int c)
{
return a+b+c;
}
}
11、三元運算符
用來完成簡單的選擇邏輯，即根據條件判斷，從兩個選擇中選擇一種執行。
使用格式：
(條件表達式)？表達式1：表達式2；
運算規則：
a) 判斷條件表達式，結果為一個布爾值。
b) true，運算結果為表達式1
c) false，運算結果為表達式2
例1：創建一個比較兩個參數是否相等的函數。
class function1
{
public static void main(String[] args)
{
boolean x=bj(1,2);
System.out.println(x);
}
public static boolean bj(int a, int b)
{
if (a==b)
return true;
else
return false;
}
}
例2：使用三元運算符，將例1簡化
class function1
{
public static void main(String[] args)
{
boolean x=bj(1,2);
System.out.println(x);
}
public static boolean bj(int a, int b)
{
return (a==b)? true:false; //三元運算符，直接使用return返回結果。
}
}
例3：因為比較運算符預算完成後就有真假值，直接返回即可，再次簡化例2。隻是針對於返回值為True或false時。
class function1
{
public static void main(String[] args)
{
boolean x=bj(1,2);
System.out.println(x);
}
public static boolean bj(int a, int b)
{
return (a==b);
}
}
例4、比較大小並返回一個大的值
class function1
{
public static void main(String[] args)
{
int x=bj(1,2);
System.out.println(x);
}
public static int bj(int a, int b)
{
return (a>b)? a:b ; //三元運算符，判斷a和b那個值大，並返回大的值
}
}
12、函數重載
函數重載:
在同一個類中，允許存在一個以上的同名函數，隻要他們的參數個數或者參數類型不同即可。
特點：
與返回值無關，隻看參數列表
重載好處：
方便閱讀，優化程序設計
什麼時候用重載？
當定義的功能相同，但參數運行的未知內容不同，
那麼這時就定義一個函數名稱以表示其功能，方便閱讀，
而通過參數列表的不同區分多個同名函數。
例1：傳統函數調用，相同函數名稱，參數不同。
class function1
{
public static void main(String[] args)
{
int x=bj(1,2);
int y=bj(1,2,3);
System.out.println("x"+"="+x+"\t"+"y"+"="+y);
}
public static int bj(int a, int b)
{
return (a+b);
}
public static int bj(int a, int b, int c)
{
return (a+b+c);
}
}
例2、根據例1進行優化，發現三個參數的函數包含了兩個參數的功能。
class function1
{
public static void main(String[] args)
{
int x =add(1,2);
int y =add(1,2,3);
System.out.println(x);
System.out.println(y);
}
public static int add(int a, int b)
{
return a+b;
}
public static int add(int a, int b, int c)
{
return add(a,b)+c;
}
}
例3：99乘法表分別調用cf和cf99；cf是個變化的乘法表，cf99是一個固定的乘法表。
class function1
{
public static void main(String[] args)
{
cf(4);
System.out.println("***********************************************************************");
cf99();
}
public static void cf (int num)
{ for (int x=1;x<=num ;x++ )
{
for (int y=1;y<=x ;y++ )
{
System.out.print(y+"*"+x+"="+y*x+"\t");//\t是製表符，對其表格
}
System.out.println();
}
}
public static void cf99 ()
{ for (int x=1;x<=9 ;x++ )
{
for (int y=1;y<=x ;y++ )
{
System.out.print(y+"*"+x+"="+y*x+"\t");//\t是製表符，對其表格
}
System.out.println();
}
}
}
結果：
D:\Skill\JAVA\2017>java function1
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
***********************************************************************
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
D:\Skill\JAVA\2017>
例4：乘法表重載，例3的乘法表代碼出現了重複，優化如下cf99直接調用cf這個函數並傳入9這個值
class function1
{
public static void main(String[] args)
{
cf(4);
System.out.println("***********************************************************************");
cf99();
}
public static void cf (int num)
{ for (int x=1;x<=num ;x++ )
{
for (int y=1;y<=x ;y++ )
{
System.out.print(y+"*"+x+"="+y*x+"\t");//\t是製表符，對其表格
}
System.out.println();
}
}
public static void cf99 ()
{
cf(9);
}
}
練習：根據例句，檢查下麵那些沒有重載。
例： void show (int a, char b, double c){}
1.void show (int x, char y, double z){}
沒有重載，因為參數類型和個數相同。
2.int show (int a, double c, char b){}
有重載，因為參數類型不同（double c）
3.void show (int a, double c, char b){}
有重載，因為參數類型不同（double c）
4.boolean show (int c, char b){}
有重載，因為參數個數不同
5.void show (double c){}
有重載，因為參數個數不同
6double show (int x,char y,double z){}
沒有重載，這個函數不可以和給定函數存在同一個類中，因為當調用show函數時，不知道返回的時double還是沒有返回值
最後更新：2017-08-21 21:32:18