2. 程式人生 > >Java基礎篇之順序、選擇、迴圈結構

Java基礎篇之順序、選擇、迴圈結構

阿新 • • 發佈：2018-11-06

程式流程

 java程式語句執行的順序包括4種基本控制結構：順序結構、選擇結構、迴圈結構、異常處理邏輯結構。

順序結構

 Java程式中，語句執行的基本順序按各語句出現的位置先後順序執行，即為順序結構。

  • 例1：順序結構：已知三角形三邊，求三角形面積：
public class Inorder {
    public static void main(String[] args) {
     double a, b, c, p,area;
        Scanner scan = new Scanner(System.in);//Scanner可用於掃描控制檯輸入
        System.out.print("請輸入三角形的邊A:  ");
        String s = scan.nextLine();
        a = Double.parseDouble(s); //將數字字串轉換成等效的雙精度浮點數
        System.out.print("請輸入三角形的邊B：  ");
        s = scan.nextLine();
        b = Double.parseDouble(s); //將數字字串轉換成等效的雙精度浮點數
        System.out.print("請輸入三角形的邊C：  ");
        s = scan.nextLine();
        c = Double.parseDouble(s); //將數字字串轉換成等效的雙精度浮點數
        System.out.printf("三角形的三邊分別為：a =%6.1f,b=%6.1f,c=%6.1f\n",a,b,c);
        p = (a+b+c)/2;
        area = Math.sqrt(p*(p-a)*(p-b)*(p-c));
        System.out.printf("三角形的面積是= %8.1f\n",area);
    }
 }
  • 執行結果：
請輸入三角形的邊A:  3
請輸入三角形的邊B：  4
請輸入三角形的邊C：  5
三角形的三邊分別為：a =   3.0,b=   4.0,c=   5.0
三角形的面積是=      6.0
  • 這裡用到了Scanner類，Java 5添加了java.util.Scanner類，這是一個用於掃描輸入文字的新的實用程式。例子中用到到了Scanner類的一個常用方法nextline()，同時下面將nextline()和next()兩個方法做簡單對比：
package kkee;
import java.util.Scanner; //匯入包
/**
 * @Package: kkee
 * @Author:kkz
 * @Description:
 * @Date:Created in 2018/10/13 15:44
 */
public class Text {
    public static void main(String []args) {
        Scanner scanner = new Scanner(System.in);
      //  System.out.println("請輸入一個字串(中間能加空格或符號)");
        // String a = scanner.nextLine();
        System.out.println("請輸入一個字串(中間不能加空格或符號)");
        String b = scanner.next();
       /* System.out.println("請輸入一個整數");
        int c;
        c = scanner.nextInt();
        System.out.println("請輸入一個double型別的小數");
        double d = scanner.nextDouble();
        System.out.println("請輸入一個float型別的小數");
        float f = scanner.nextFloat();
        System.out.println("按順序輸出abcdf的值：");
        System.out.println(a);*/
        System.out.println(b);
       // System.out.println(c);
       // System.out.println(d);
       // System.out.println(f);
    }
}
  • 執行結果：
請輸入一個字串(中間能加空格或符號)
solo
請輸入一個字串(中間不能加空格或符號)
solo
請輸入一個整數
123
請輸入一個double型別的小數
12.1234
請輸入一個float型別的小數
2.34567
按順序輸出abcdf的值：
solo
solo
123
12.1234
2.34567
  • 當在next()方法下，輸入帶符號或空格的值，所得結果：
請輸入一個字串(中間不能加空格或符號)
so lo
so

  總結：
（1) next():只讀取輸入直到空格，無法識別空格鍵，遇到即退出。它不能讀兩個由空格或符號隔開的單詞。此外，next()在讀取輸入後將游標放在同一行中。(next()只讀空格之前的資料,並且游標指向本行)
（2）nextLine():讀取輸入，包括單詞之間的空格和除回車以外的所有符號。讀取輸入後，nextLine()將游標定位在下一行。
（3）nextlnt():只讀取int值，就是隻能讀取整數型別的資料，如果輸入了非整型的資料（浮點型字串等）就會報錯。 nextFloat()、nextDouble()這些也是以此類推，只能讀取符合該型別的資料。

選擇結構

 選擇結構根據條件來控制程式碼的執行分支，也成分支結構。Java包括兩種控制分支的條件語句，if語句、switch語句。

  • if語句包含多種形式：單分支、雙分支、多分支。
  • （1）單分支：語法形式：
     if(條件表示式)
      語句/語句塊；
     該語句的作用是當條件表示式的值為真（true）時，執行if後的語句（塊），否則不做任何操作，控制轉到if語句的結束點。
  • 典例：判斷當前年，是否為閏年？
  • 1.年份能被4整除並且不能被100整除；
    2.能被400整除；

public class Year {
        public static boolean loopYear ( int year){
            if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
                return true;
            }
            return false;
        }
    public static void main(String[] args) {
       boolean k = loopYear(2018);
       System.out.println(k);
    }
}

false
  • （2）雙分支：語法形式：
     if(條件表示式)
      語句/語句塊1；
    else
     語句/語句塊2；
     該語句的作用是當條件表示式的值為真時，執行if後的語句/語句塊1，否則執行語句/語句塊2。
  • 典例：輸入兩個數，判斷兩個數的大小。
public class Copab {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("請輸入2個整數：");
        int a = s.nextInt();
        int b = s.nextInt();
        if(a < b){
            System.out.println("a < b");
        }else{
            System.out.println("a>b");
        }
    }


請輸入2個整數：
2
3
a < b
  • (3)多分支：
     if(條件表示式1)
      語句/語句塊1；
    else if(條件表示式2)
     語句/語句塊2；
    else if(條件表示式2)
     語句/語句塊2；
    ……
  • 典例:已知課程的成績，根據成績80-100、70-80、60-70、60以下，將其分等級為A、B、C、D。輸入成績時，輸出評價。
public class Grade {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("請輸入成績：");
        int mark = scanner.nextInt();
        if(mark >= 80) {
            System.out.println('A');
        } else  if(mark >=70   && mark <=80 ){
            System.out.println('B');
        }else if(mark >=60 && mark <=70 ){
            System.out.println('C');
        }else if(mark <60 ){
            System.out.println('D');
        }
    }
}

請輸入成績：
68
C
  • (4)if語句的巢狀:
     if(條件表示式1){
      if(條件表示式2){
      語句/語句塊1;
     }else{
     語句/語句塊2;}
    }
  • switch語句是一個控制語句，它通過將控制傳遞給其體內的case語句來處理多個選擇和列舉。
    -語法形式：
    switch(表示式){
    case 常量表達式1: 語句1;
    break;
    case 常量表達式2: 語句2;
    break;
    …
    case 常量表達式n: 語句n;
    break;
    default: 語句n+1;
    break;
    }
  • 典例：已知課程的成績，根據成績80-100、70-80、60-70、60以下，將其分等級為A、B、C、D。輸入等級時，輸出成績範圍。
package kkee;

/**
 * @Package: kkee
 * @Author:kkz
 * @Description:
 * @Date:Created in 2018/10/13 22:26
 */
public class School {
    public static char fun(char ch) {
        switch (ch) {
            case 'A':
                System.out.println("80-100");
                break;
            case 'B':
                System.out.println("70-80");
                break;
            case 'C':
                System.out.println("60-70");
                break;
            case 'D':
                System.out.println("60以下");
                break;
            default:
                System.out.println("沒救了！");
                break;
        }
        return ch;
    }
    public static void main(String[] args) {
        char k = fun('A');
        System.out.println(k);

    }
}


80-100
A
  • 注意：
     （1）switch控制表示式所允許的資料型別：整型型別（byte、short、int）、字元型別（char）和列舉型別；不能允許的資料型別有：double、long、float。
     （2）case標籤後的常量表達式只能是常數或者常量，不能為變數。

迴圈結構

 Java提供了4種不同的迴圈機制：for、while、do…while、for each，在滿足某個條件之前，可以重複執行程式碼塊。

  • for迴圈是計數型迴圈語句，一般用於已知迴圈次數的情況，所以也稱定次迴圈。
  • for(初始化設定表示式；迴圈執行條件；迴圈變數的增減量)
    { 迴圈語句序列 }
  • 典例：求輸入的數字是否為素數？
 public static boolean isPrime(int n){
        for (int a = 2; a > 2; a++){
           if( n % a == 0) {
               return false;
           }
        }
        return true;
    }
  • 典例：求5的階乘。
package kkee;



/**
 * @Package: kkee
 * @Author:kkz
 * @Description:
 * @Date:Created in 2018/10/13 23:05
 */
public class fun {
     public static int Pulse(int n) {
        int j = 1;
        for (int i = 1; i <= n; i++) {
            j = j * i;
        }
         return  j;
    }
    public static void main(String[] args) {
        int k = Pulse(5);
        System.out.println(k);
    }
}
  • 典例：求1-100之內的和，1-100之內奇數的和。
package kkee;

/**
 * @Package: kkee
 * @Author:kkz
 * @Description:
 * @Date:Created in 2018/10/13 23:17
 */
public class SumAll {
    public static void main(String[] args) {
        int sum = 0;
        int sumOdd = 0;//奇數和
        int sumEven = 0;//偶數和
        for(int i = 1;i <= 100;i += 1){
            sum += i;
        }
        for(int i = 1;i <= 100;i += 2){
            sumOdd += i;
        }
        for(int i = 2;i <= 100;i += 2){
            sumEven += i;
        }
        System.out.printf("1-100中所有數的和為%d、奇數和為%d、偶數和為%d\n",sum,sumEven,sumOdd);
    }
}


1-100中所有數的和為5050、奇數和為2550、偶數和為2500
  • 注意：
     （1）for 迴圈中，第二個引數若沒有，則預設為真；
     （2）for 迴圈結構中的3個表示式都可省略。例如，下列程式片創造了一個無限迴圈，for（；；）{ //This will run forever }
  • Tips:
  • (1)求斐波那契數列的前40項的和？
     斐波那契數列指的是這樣一個數列 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368……特別指出：第0項是0，第1項是第一個1。這個數列從第3項開始，每一項都等於前兩項之和。
package kkee;

/**
 * @Package: kkee
 * @Author:kkz
 * @Description:
 * @Date:Created in 2018/10/14 14:04
 */
public class Main {
    public int Fob(int n){
        if (n < 0)
            return -1;//終止遞迴
        if ( n == 1 || n == 2)
            return 1;
        return Fob(n-1)+Fob(n-2);//遞迴呼叫
    }
    public static void main(String[] args) {
        Main main = new Main();//例項化物件
        int sum = 0;
        for (int i = 1; i <= 40 ; i++) { //迴圈次數40,即前40項
            sum += main.Fob(i);//求和
        }
        System.out.println(sum);//列印並輸出
    }
}


267914295
  • (2)用for迴圈產生20個隨機數（10-20）。
     應用Math類的Random()方法，Math.random() – 返回0和1之間的偽隨機數 可能為0，但總是小於1，[0,1)； a-b： Math.random() *(b-a)+a 。
package kkee;

/**
 * @Package: kkee
 * @Author:kkz
 * @Description:
 * @Date:Created in 2018/10/14 10:47
 */
// 用for迴圈產生20個隨機數（10-20）
//  a-b;  Math.random() *(b-a)+a      Math.random():[0,1)  double
public class RandomNumber {
    public static void main(String[] args) {
        for(int i = 0; i < 20; i++){      //控制迴圈次數，即產生隨機數個數
            double a = (double) (Math.random()*10+10);
                                       //a-b;  Math.random() *(b-a)+a
                                      //設定隨機數產生範圍10-20
            System.out.print(a+"\n");//換行輸出
        }
    }
}

12.981837264734592
13.006022254093143
12.487037794538924
13.145405893027164
12.458942902107488
15.43507744667718
14.259679971672586
15.509221626909214
19.940084712858457
19.772918004113755
13.68682288744929
14.386686400881068
17.878611177117385
10.93307850365068
17.73783786843079
17.264961318332702
11.128319978032376
16.24171939063554
10.588602457917593
10.624208022042762
  • (3)輸入一個數字，求他是幾位數，並且順序輸出，逆序輸出。
     charAt(int index)方法是一個能夠用來檢索特定索引下的字元的String例項的方法，charAt()方法返回指定索引位置的char值。
package kkee;
import java.util.Scanner;//匯入Scanner

/**
 * @Package: kkee
 * @Author:kkz
 * @Description:
 * @Date:Created in 2018/10/14 11:43
 */
public class Order {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);//獲得從控制檯輸入的引數
        String str = scanner.nextLine();//nextline()方法
        System.out.println("這個數是：" + str.length() + "位");
        System.out.println("順序輸出為：" + str);
        System.out.print("逆序輸出為：");
        for(int i = str.length() - 1; i >= 0; i--) {
            System.out.print(str.charAt(i));//str.charAt()檢索str中的字元，並列印
        }
    }
}


1234
這個數是：4位
順序輸出為：1234
逆序輸出為：4321
  • (4)求一個數字的二進位制數有幾個1?
package kkee;

/**
 * @Package: kkee
 * @Author:kkz
 * @Description:
 * @Date:Created in 2018/10/14 15:03
 */
public class funn {
    public static int getBinary(int value){  
        int count = 0;
        int remainder = 0;
        while (value != 0){
            remainder = value % 2;  //儲存餘數
            if (remainder == 1)
                count++;
                value = value / 2;
        }
        return count;  //返回count的值
    }
    public static void main(String[] args) {
        int k = getBinary(8);
        System.out.println(k);
    }
}


1

Over…

相關推薦

Java基礎篇之順序、選擇、迴圈結構

程式流程  java程式語句執行的順序包括4種基本控制結構：順序結構、選擇結構、迴圈結構、異常處理邏輯結構。 順序結構  Java程式中，語句執行的基本順序按各語句出現的位置先後順序執行，即為順序結構。 例1：順序結構：已知三角形三邊，求三角形面積： pub

Java基礎篇之常量、變數、運算子

資料型別 ： Java中的基本型別功能簡單，不具備物件的特性，為了使基本型別具備物件的特性，所以出現了包裝類，就可以像操作物件一樣操作基本型別資料。 基本型別對應的包裝類 基本型別 byte int short long float double boolean char 包裝型別

java基礎篇之-----------抽象類 、最終類、介面

一、抽象類： 我們把一類事物抽象出來，類中只宣告方法，不實現，這就是抽象類存在的意義； 抽象類： 含有抽象方法的類，被abstract 關鍵字修飾； 抽象方法：只有方法宣告沒有方法實體，被abstract關鍵字修飾； 注意要點： 1、抽象類沒有例項物件，只能通過別的類繼承實現抽象方法

Java基礎知識之synchronized同步方法、程式碼塊、靜態方法、靜態程式碼塊的區別

      Java中的同步塊用synchronized標記，是同步在某個物件上，所有同步在一個物件上的同步塊在同一時刻只能被一個執行緒進入並執行操作，其他等待進入該同步塊的執行緒將被阻塞，直到執行該同步塊中的執行緒退出。 有四種不同的同步塊： 例項方法同步；

java基礎篇之nio與aio

sre 非阻塞 只有一個 accept ava 使用步驟 截取 city writable 1.同步和異步 同步：指一個任務運行完以後接著運行下一個任務 異步：接到一個任務後開啟一個新的線程運行此任務，基本不占用原線程時間 2.阻塞與非阻塞 阻塞：多個線程同時訪問一份數據時

Java基礎篇之環境搭建

伺服器環境：Centos jdk安裝包：.tar.gz 第一步：在官網下載JDK安裝包 第二步：解壓縮安裝包：tar -xzvf jdk-8u131-linux-x64.tar.gz -C /usr/local/java ps：壓縮到/usr/local/java目錄

java基礎篇之GC

概述 java和C++有著一堵 記憶體動態分配 和 垃圾收集技術 圍成的“高牆”，外面的人想進去，裡面的人想出來。 java垃圾回收 GC（Garbage Collection） 的歷史比java還要久遠，1960年誕生的Lisp語言當時就在考慮三個問題：

java基礎篇之最基礎

靜態程式碼塊執行一次，隨著類載入而載入 public class Test { static HashMap hashMap = new HashMap(){ // map優雅的寫法 { put("1","2"

java基礎篇之5-------一維陣列的拷貝

作業： 1、{1,2,3,4,5,6} 將奇數放在偶數前面 大小順序不要求 public static int[] sortArray(int[] a) { int odd = 0;// 奇數下標 int even

Java 基礎篇之程式設計基礎

基本資料型別 java 是強型別語言，在 java 中儲存的資料都是有型別的，而且必須在編譯時就確定其型別。 基本資料型別變數儲存的是資料本身，而引用型別變數存的是資料的空間地址。 基本型別轉換 自動型別轉換 把一個表數範圍小的數值或變數直接賦給另一個表數範圍大的變數時，系統將會進行自動型別轉換，否則需要

Java 基礎篇之異常

異常 異常層次 Error：Java 執行時系統的內部錯誤和資源耗盡錯誤。應用程式不應該丟擲這種型別的物件。如果出現了這樣的內部錯誤，除了通告給使用者，並盡力使程式安全地終止之外，再也無能為力了。 Exception RuntimeException：由程式錯誤導致的異常 其他異常：程式本身沒有問題，

Java 基礎篇之集合

List 集合 List 集合中元素有序、可重複，集合中每個元素都有其對應的索引順序。 List 判斷兩個物件相等，只要通過 equals 方法比較返回 true 即可。 看個例子： public class A { public boolean equals(Object obj) {

Java 基礎篇之反射

反射 使用反射獲取程式執行時的物件和類的真實資訊。 獲取 Class 物件 每個類被載入之後，系統會為該類生成一個對應的 Class 物件，通過該 Class 物件可以訪問到 JVM 中的這個類。 使用 Class 類的 forName(String clazzName) 靜態方法。字串引數的值是某個類

Java之三大基礎排序（冒泡、選擇、插入）

注：以下排序均為從小到大 一、氣泡排序 package com.yunche.testsort; import java.util.Arrays; /** * @ClassName: BubbleSort * @Description: * @author: yunche

Java基礎加強之多執行緒篇 - 執行緒建立與終止、互斥、通訊、本地變數

執行緒建立與終止 執行緒建立 Thread類與 Runnable 介面的關係 public interface Runnable { public abstract void run(); } public class Thread implements Run

Java語句之順序結構&選擇結構（if、switch）&迴圈結構（for、while）

Java中，語句分為三大類，順序結構，選擇結構（if語句、switch語句），迴圈結構（for語句、while語句）。 一、順序結構 就是按照輸出語句來 例： System.out.printl

Java學習日記基礎篇（七) —— 數組、排序

為什麽 border color oat () 引用 order test exc 數組 為什麽要有數組？ 案例：一個養雞場有六只雞，他們的體重分別為3kg，5kg，1kg，3.4kg，2kg，50kg。請問這六只雞的總體重和平均體重是多少？ 1 public cla

Java基礎篇 - 強引用、弱引用、軟引用和虛引用

splay 查看 tla 之前 for 應用 幹貨 程序 策略 前言 Java執行GC判斷對象是否存活有兩種方式其中一種是引用計數。 引用計數：Java堆中每一個對象都有一個引用計數屬性，引用每新增1次計數加1，引用每釋放1次計數減1。 在JDK 1.2以前的版本中，若

java基礎學習之函式、陣列

1、函式 1、函式的定義 函式是定義在類中有特定功能的一小段程式，也稱方法。定義格式： 修飾符 返回值型別 函式名(引數型別 形式引數1，引數型別 形式引數2， ) { 執行語句; return 返回值; } 2、功能 定義函式可以對功能程式碼進行封裝，提高程式碼的複用性

Java基礎篇（一）--- 資料型別、函式、控制符

基本資料型別 1.整數型別： byte(1 位元組 ), short(2 位元組 ), int(4 位元組 ), long(8 位元組 ) 1位元組=8位,而每一個數的第一位為符號位,並且-0(負零)用-128表示，所以byte的範圍為：-2^(位元組8-1) --> 2^(位元組