java入門學習總結_04

時間  2019-11-20
標籤 java 入門 學習 總結 欄目 Java 简体版
原文   原文鏈接

 

一、循環結構

二、方法

循環結構

概述

一、對於某些須要重複執行的，相同或者類似的語句，使用某種格式來完成對代碼的簡化。

二、實現的語句：

  • for語句【經常使用】

  • while語句【經常使用】

  • do...while語句

for語句

一、格式java

for (初始化語句1 ; 循環的條件表達式2; 初始化變量的自增3 ) {編程

循環體語句;4服務器

}學習

模擬執行時會出現的狀況：（從左邊開始）this

1spa

2 false for語句結束設計

2true -4-3-2true-4-3-2true-4-3-2false-結束code

二、執行流程：對象

  • 一、執行初始化語句
  • 二、計算循環的條件表達式
  • 三、若是計算爲false，就結束for循環
  • 四、若是計算爲true，就執行循環體語句
  • 五、執行初始化變量的自增
  • 六、回到第2步

三、說明：blog

  • 一、初始化語句，聲明一個變量，用於記錄循環次數
  • 二、循環的條件表達式，控制循環的條件
  • 三、初始化變量的自增，將初始化語句中聲明的變量，進行變化，通常是向着循環不能執行的方向變化
  • 四、循環體語句，就是那個要重複執行的內容

代碼示例

for語句格式的注意事項
  • 一、初始化語句，聲明一個變量，用於記錄循環次數，只執行一次。
  • 二、條件表達式，必須是boolean類型的運算結果
  • 三、循環體語句，在初始化變量自增以前，執行的
  • 四、初始化變量的自增，能夠是自增、也能夠是自減，也能夠一次自增多步
  • 五、左大括號以前，不要有分號，不然for循環沒法控制大括號中的語句。
  • 六、循環體語句，若是隻有一句，那麼大括號能夠省略。建議全部時候都加上大括號

而且：（偏門用法）

  • * for循壞的三個參數，須要注意的問題，
    * 第一個初始語句，初始數據時能夠初始多個變量，
    * 第二個判斷表達式，能夠多條件判斷使用關係運算符鏈接，
    * 第三個自增表達式：能夠同時遞增多個或者進行取模或算式操做等
    * 以上三個參數符合各自要求的表達式就能夠了

代碼示例

class Demo_3 {

//for語句的注意事項

public static void main(String[] args) {

//初始化變量只執行一次

for(int i = 1,j=6;i < j/*必須是boolean類型的*/;i = i +3,j=j - 1)/*;*/{

//若是循環體語句中只有一條語句，咱們能夠省略大括號

//循環體語句

System.out.println(i+" "+j);//循環體語句是在初始化變量自增前執行

}

}

}

for循環練習

練習1

打印數字1-5

練習2

打印數字5-1

練習3

計算1+2+3+...+100的和

練習4

計算1-100的偶數和

練習5

列舉全部的「四葉玫瑰數」，並統計四葉玫瑰數的個數

四葉玫瑰數：是一個四位數，各個位的數字的四次方的和，爲該數字自己

嵌套循環

一、在一次大的循環中，每次的循環內容（循環體語句）又是一個複雜的操做，是重複的操做，就須要在大的循環體語句中，定義小的循環，稱爲循環的嵌套（在打印矩形或其餘形狀的圖案時，若是使用兩層for嵌套，外層循壞表示行數，內層循環表示列的個數）

二、格式：

for（初始化語句1  （1）;  循環條件表達式1（2）；初始變量的自增1（3））{

for（初始化語句2（4）；循環條件表達式2（5）；初始變量自增2（6））{

循環體語句7

}

}  

模擬語句運行的流程以下：

1->2false 結束

1 -> 2true ->4  -> 5 false 內層循環結束->3->2 直到2爲false 循環結束

1 -> 2true  -> 4 -> 5 true -> 7 -> 6 ->5 true(回到7) false-> 3 -> 2(true)回到4 ，2爲false結 束

三、執行流程

  • 一、初始化語句1
  • 二、循環條件表達式1 ，計算結果是false，結束
  • 三、循環條件表示式1，計算結果爲true，初始化語句2，
  • 四、計算循環條件表達式2的結果，false，內層循環結束，初始變量的自增1

   循環條件表達式1，true，初始化語句2，循環條件表達式2，true，循環體語句，初始變量自增2，循環條件表達式2，false，

代碼示例

class Demo_2 {

public static void main(String[] args) {

//嵌套循環

/*

for(初始化語句1;循環條件表達式1;初始化變量自增1){

for(初始化語句2;循環條件表達式2;初始變量自增2){

循環體語句;

}

}

*/

for(int i = 1;i < 6 ;i++){//外層循環循環一次，內層循環是要執行完

for(int j = 1;j < 4;j++){

System.out.println("i = " + i +";j = " + j);

}

}

}

}

練習1

使用嵌套循環，打印四行五列星星矩形

*****

*****

*****

*****

提示：打印不換行，使用print方法，不要加ln

class Demo_7 {

public static void main(String[] args) {

/*

使用嵌套循環，打印四行五列星星矩形

*****

*****

*****

*****

提示：打印不換行，使用print方法，不要加ln

*/

//外層循環控制行數，內層循環控制列數

for(int i = 1;i < 5;i++){

//內層循環控制列數

for(int j = 1;j < 6;j++){

System.out.print("*");

}

//換行

System.out.println();

}

}

}

 

練習2

使用嵌套循環，打印5行5列的直角三角形

*

**

***

****

class Demo_8 {

public static void main(String[] args) {

/*

使用嵌套循環，打印5行5列的直角三角形

*         1行 打印1列，內層循環1次         

**   2行 打印2列，內層循環2次

***   3行 打印3列，內層循環3次

****

*****

*/

for(int i = 1;i < 6;i++){

for(int j = 1;j <= i;j++){

System.out.print("*");

}

System.out.println();

}

}

}

 

練習3

打印99乘法表

1*1=1

1*2=2 2*2=4

1*3=3 2*3=6 3*3=9

........................................

1*9=9 2*9=18 3*9=27 .......... 8*9=72 9*9=81

class Demo_9 {

public static void main(String[] args) {

/*

打印99乘法表

1*1=1

1*2=2 2*2=4

1*3=3 2*3=6 3*3=9

........................................

1*9=9 2*9=18 3*9=27 .......... 8*9=72 9*9=81

*/

for(int i = 1; i<=9 ; i++){

for(int j = 1; j <= i; j++){

System.out.print(j + "*" + i + "=" + i*j +"\t");

}

System.out.println();

}

}

}

 

while語句

一、格式：

初始化語句

while(條件表達式) {

循環體語句;

初始化變量的自增;

}

二、執行流程：

  • 一、初始化語句
  • 二、計算條件表達式，若是爲false，循環直接結束
  • 三、若是爲true，執行循環體語句
  • 四、執行初始化變量的自增
  • 五、回到第二步

三、注意事項：

  • 一、條件表達式必須爲boolean類型
  • 二、初始化變量的自增，不要忘記

代碼示例

class Demo_10 {

public static void main(String[] args) {

//while語句

/*

初始化語句

while(條件表達式){

循環體語句；

初始變量的自增;

}

*/

int i = 1;

while(i < 6){

System.out.println("愛你一萬年");

//初始變量的自增

// i++;//i = i * 2;

System.out.println(i++);

}

}

}

 

練習

使用while循環，統計1-100範圍內，有多少數字能夠被7整除

class Demo_11 {

public static void main(String[] args) {

//使用while循環，統計1-100範圍內，有多少數字能夠被7整除

int i = 1;

//定義一個輔助變量用來統計被7整除的個數

int count = 0;

while(i <= 100){

//判斷是否能夠被7整數

if(i % 7 == 0){

count++;

}

//初始變量的自增

i++;

}

System.out.println(count);

}

}

 

do...while語句

一、格式：

初始化語句;

do {

循環體語句;

初始化變量的自增;

} while (循環條件表達式);

二、執行流程：

  • 一、初始化語句
  • 二、循環體語句
  • 三、初始化變量的自增
  • 四、計算循環條件表達式的值，若是爲false，循環結束
  • 五、若是爲true，回到第二步

三、注意事項：

  • 一、循環條件表達式必須是boolean類型
  • 二、while循環條件後面，要有一個分號

代碼示例

class Demo_12 {

public static void main(String[] args) {

//do while 語句

//初始化變量

int i = 1;

do{

System.out.println("do while虛幻");

//初始化變量的自增

++i;

}while(i < 5);

//經常使用的循環語句，for語句，while語句

}

}

 

三種循環語句的區別for, while,do..while

一、do while語句和其餘兩種語句的區別：

  • do while語句至少能夠執行一次，另外兩種有可能一次都執行不了

二、while語句和for的區別：

  • 一、代碼層面：while語句聲明的初始化變量，在while結束以後，還能繼續使用；for中聲明的初始化變量，在for結束以後，就沒法使用了。
  • 二、設計層面：while語句通常用於描述相對模糊的範圍，其餘的條件；for用於描述相對準確，知道循環次數的循環
死循環

一、死循環：無限循環。循環永遠都不中止。

二、格式：

一、for語句的死循環：

  for ( ; ; ) {

循環體語句;

}

二、while語句的死循環：【經常使用】

  while (true) {

循環體語句;

}

注意：

//破壞循環的方法：使條件變爲false
//方式：1.直接使判斷表達式條件變爲false 2.經過修改自增表達式（不必定使用a++這種），使判斷表達式失效即爲false 3.使用break，continue，return，system.exit（0）結束循環/方法/虛擬機

三、死循環的做用：

  • 一、在格式上使用了死循環，可是在循環體中，可能出現了須要循環結束的狀況，準備了一些跳出、終止循環的跳轉語句。
  • 二、在服務器的設計中，但願服務器永遠給咱們服務下去，因此須要使用死循環。

代碼示例

import java.util.Scanner;

class Demo_14 {

public static void main(String[] args) {

//死循環

//for語句的死循環

/* for(;;){

System.out.println("死循環");

}

*/

//System.out.println("我能執行到嗎，好好想一想");

//while語句的死循環

//while (true){

// System.out.println(true);

// }

Scanner sc = new Scanner(System.in);

System.out.println("選擇你心儀的戰隊");

while(true){

int a = sc.nextInt();

if(a == 1){

System.out.println("I like RNG");

break;

}else if(a == 2){

System.out.println("I like IG");

break;

}else if(a == 3){

System.out.println("I like FPX");

break;

}else if(a == 4){

System.out.println("I like SKT");

break;

}else if(a == 5){

System.out.println("I like DWG");

break;

}else{//不加else有可能一個語句體都不執行，加上後要執行一個語句體

System.out.println("你輸入的戰隊不存在，請從新輸入");

}}

}}

 

跳轉語句

一、跳轉語句：在循環的循環體語句中，結束循環，控制循環，使用的語句。

二、continue語句：

  • 結束本次循環，繼續下次循環

三、break語句：

  • 結束當前層次的循環

四、return語句：

  • 結束當前的方法

五、System.exit(0);

  • 用於結束虛擬機

代碼示例

class Demo_15 {

public static void main(String[] args) {

//跳轉語句

for(int i = 1;i<=10;i++){

//continue

if(i == 5){

continue;//結束本次循環，繼續下次循環

}

System.out.println(i);

}

System.out.println("----------==================");

// break語句

for(int i = 1;i<=10;i++){

if( i == 5){

break;//  把整個循環結束了

}

System.out.println(i);

}

System.out.println("------------------------------------");

//return

for(int i = 1;i<=5;i++){

for(int j = 1;j < 8;j++){

if( j == 5){

return;//  直接把方法結束了

//break; //結束的是內層循環，外層循環不受影響

//System.exit(0);//把虛擬機結束了

}

System.out.println("i = "+i +";j="+j);

}}}}

 

方法概述:

一、具備某種特定功能的代碼段

二、某段代碼常用，因此使用大括號，將這段代碼包起來，起個名字。之後就使用這個名字來代替這段代碼。

三、好處：

  • 一、提升了代碼的複用性
  • 二、提升了代碼的封裝性，大括號中的內容，其餘調用者看不到也沒法直接訪問
  • 三、簡化了軟件設計的思惟難度
方法的定義

一、方法定義的格式

修飾符 返回值類型 方法名稱 (參數列表) {

方法體語句;

return語句;//使用void時，return後面不接東西，表示結束這個方法，其餘返回值類型，return返回對應類型數據做爲這個方法的一個結果輸出

}

二、詳細解釋：

  • 一、修飾符：如今全都寫成public static(靜態方法)

  注：靜態方法在訪問本類的成員時，只容許訪問靜態成員（即靜態成員變量和靜態方法），而不容許訪問實例成員變量和實例方法；實例方法則無此限制。

  • 二、返回值類型：方法具備功能，有可能會有一些產出，就須要將數據返回給調用者。調用者須要知道生產出來的數據的數據類型。（int double，float，char,String void等）
  • 三、方法名稱：給這段代碼起的名字。只要是一個合法的標識符便可。第一個單詞的首字母小寫，從第二個單詞開始首字母大寫。動詞、動賓結構。（小駝峯寫法）
  • 四、參數列表：這段代碼要完成功能，可能會須要一些資源。在參數列表中，須要定義一些變量，內存中表示爲容器，在調用本方法的時候，會由外界傳入數據，存儲到這些變量容器中。使用變量符號，表示那些未來可能傳入的數據。
  • 五、方法體語句：真正要完成該方法功能的執行邏輯。
  • 六、return語句：最終生產出來的結果，要返回給調用者，使用return語句返回。若是沒有任何生產內容，就能夠寫一個return;，用於表示方法結束。
方法的調用

一、格式：直接書寫方法名稱便可（在不使用面向對象編程的時候）

方法名稱(實際參數);

二、方法調用的三種形式：

  • 一、直接調用：表示某些內容的執行，而沒有生產結果的狀況
  • 二、輸出調用：方法的返回值，須要打印。若是這個結果只打印一次，不作其餘的操做。
  • 三、賦值調用：方法的返回值，使用某個變量來接收。若是這個結果須要反覆使用。

三、方法調用整體特色：

方法不調用，就不執行。

代碼示例

class Demo_17 {

public static void main(String[] args) {

//方法的調用

//直接調用

method_1();

method_2(/*實際參數*/5,8);

//輸出調用

method_3(1,2);//sum

System.out.println(method_3(3,4));

//賦值調用

int a = method_3(2,3);

System.out.println(a);

}

//無參數列表，無返回值

public static void method_1(){

System.out.println("method_1 方法被調用了");

}

//有參數列表的，無返回值

public static void method_2(/*定義諾幹個變量*/int i ,int j){

System.out.println("method_2 方法被調用了"+ "i= "+i +";j="+ j );

}

//有參數列表，有返回值的

public static int method_3(/*定義諾幹個變量*/int i ,int j){

System.out.println("method_3");

int sum = i + j;

return sum;

}

}

 

方法注意事項

一、方法定義：

  • 一、方法不能嵌套定義，方法都是定義在主方法的下面。
  • 二、方法的前後沒有區別
  • 三、方法的定義是平級關係
  • 四、方法能夠嵌套調用，甚至能夠本身調用本身

二、參數列表：

  • 一、形式參數：在定義方法時使用，須要加上數據類型的參數，也就是對於變量進行聲明。各個變量之間，使用逗號分隔。
  • 二、實際參數：在方法調用時使用，不能加上數據類型的參數，也就是對於變量進行賦值。各個實際參數之間，也使用逗號分隔。順序必須和定義的方法的形式參數的順序一致。

三、return語句：

  • 一、語句表達方法結束了；表示方法的產出內容。
  • 二、若是方法沒有具體的返回內容，能夠寫成return; 此時的return語句能夠省略。返回值類型必須寫成void。
  • 三、若是方法有具體的返回內容，那麼return後面就須要加上返回的那個數據。返回值類型必須和return語句後面的數據的數據類型一致。
  • 四、return語句返回數據，返回給調用者。誰來調用當前方法，當前方法就將數據返回給誰。
方法在內存中的理解：main方法運行時，建立main方法內存塊，main方法調用到test_1()，test_1()建立內存進棧，test_1()運行調用test_2（），test_2()建立內存空間同時進棧，當test_2()運行完全部代碼，this出棧,此時test_1()運行完最後的代碼，也this出棧，最後main代碼運行完也，this出棧，程序結束，棧空

wps1

方法的重載

一、重載：Overload，超載

二、方法的重載：（只有參數的數據類型，個數，參數的位置這三個改變，纔算方法重載）

  • 在同一個類中，方法名相同，參數列表不一樣，與返回值類型無關

三、說明：

  • 一、在同一個類中。不一樣無關類中，不可能發生方法的重載的。
  • 二、方法名稱相同：如出一轍。
  • 三、參數列表不一樣：參數類型不一樣；參數個數不一樣；參數類型的順序不一樣；
  • 參數的名稱不一樣（不算）
  • 四、與返回值類型無關。方法是不是重載，與返回值類型沒有關係。
  • 若是方法的名稱和參數列表都同樣，即便返回值類型不一樣，也不算重載，屬於方法 的重複定義。

四、方法重載的好處：

  • 一、沒有重載的時候，相同邏輯相同功能的代碼，須要定義不少個方法名稱。調用者在記憶方法名稱的時候，就有很大的負擔。
  • 二、有重載以後，相同功能邏輯的方法，只須要記憶一個名字。

五、當前學習過的常見重載：

println方法，任意類型的數據，均可以放到這個方法中打印

在System.out類型中，將各類數據類型的打印方法，都定義出來了，都起了println方法的名稱

代碼示例

class Demo_20 {

public static void main(String[] args) {

//方法的重載

int a = 1;

int b = 2;

System.out.println(sum(a,b));

double m = 1.2;

double n = 1.3;

System.out.println(sum(1.2,1.3));

//重載

System.out.println(1);//PrintStream

System.out.println(1.2);

System.out.println("asdf");

}

//在同一個類中，方法名字同樣，參數列表不一樣（參數的數據類型不同，參數的順序不同，參數的個數不同）與返回值類型無關

public static int sum(int a,int b){

return a + b;

}

public static double sum(double a,double b){

return a + b;

}

/*public static double sum(double aa,double bb){

return aa + bb;不是方法的重載

}*/

public static double sum(double a,int b){

return a + b;

}

public static double sum(int a,double b){

return a + b;

}

public static int sum(int a,int b,int c){

return a + b + c;

}

}

 

方法練習

練習1

定義一個方法getMax，能夠獲取兩個整數的較大值

在主方法中，鍵盤錄入兩個整數，調用方法獲取二者最大值

練習2

定義一個方法isEqual，能夠判斷兩個小數是否相等

在主方法中，鍵盤錄入兩個整數，自動提高爲小數，調用方法比較二者是否相等

練習3

定義一個方法，能夠打印指定行數和列數的矩形

在主方法中，鍵盤錄入兩個整數，做爲行數和列數，調用方法打印對應規模的矩形import java.util.Scanner;class Practice {

public static void main(String[] args) { /*
 練習1
 定義一個方法getMax，能夠獲取兩個整數的較大值 在主方法中，鍵盤錄入兩個整數，調用方法獲取二者最大值 練習2 定義一個方法isEqual，能夠判斷兩個小數是否相等 在主方法中，鍵盤錄入兩個整數，自動提高爲小數，調用方法比較二者是否相等 練習3 定義一個方法，能夠打印指定行數和列數的矩形 在主方法中，鍵盤錄入兩個整數，做爲行數和列數，調用方法打印對應規模的矩形 */ Scanner sc = new Scanner(System.in); int a = sc.nextInt(); int b = sc.nextInt(); //boolean boo = isEqual_1(a,b); //System.out.println(boo); //int max = getMax(a,b); //System.out.println(max);  printJuXing(a,b); } //獲取兩個整數的最大值 public static int getMax(int x,int y){ if(x > y){ return x ; }else{ return y; } //int z = x > y ? x : y; //return z;  } //比較兩個數是否相等 public static void isEqual(double d1,double d2){ String str = d1 == d2 ? "相等":"不相等"; System.out.println(str); } //比較兩個數是否相等 public static boolean isEqual_1(double d1,double d2){ return d1 == d2 ? true:false; } //能夠打印指定行數和列數的矩形 public static void printJuXing(int hang,int lie){ //嵌套循環 //外層循環控制行，hang for(int i = 1 ;i <= hang;i++){ //內層循環控制列數 for(int j = 1 ;j <= lie; j++){ System.out.print((char)3+" "); } System.out.println(); } return ; } }
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程