2章　制御文
1.順次構造
　制御文とは､プログラムの流れを制御するもの。他の多くの言語と同様､上から下にプログラムは実行される。この流れを「順次構造」という。しかし、ある処理を繰り返したり、条件によって異なる処理をさせたい場合は、順次構造以外の流れが必要になる。
　
2.単一分岐
分岐の条件が一つだけの場合を単一分岐という。
変数nが0なら処理1を、
0以外なら処理2を実行する

        |
　   ／＼　
　／n=0 ＼___no__
　＼      ／        |
  　 ＼／           |
        | yes        |
 _______| _____  ______| _______
 |   処理1 _| |   処理2 _|
        |              |
        |←――― l
        |

  if(n==0) {
              　処理1;
  }
  else{
                処理2;
  }

 nがm以上なら処理1を、
未満なら処理2を実行する

        | 
　   ／＼　
　／n≧m ＼___no__
　＼      ／        |
  　 ＼／           |
        | yes        |
 _______| _____  ______| _______
 |   処理1 _| |   処理2 _|
        |              |
        |←――― l
        |

  if(n>=m) {
              　処理1;
  }
  else{
                処理2;
  }

 左記に同じ、
こういう書き方もある

        | 
　   ／＼　
　／ n:0 ＼___<___
　＼      ／        |
  　 ＼／≧        |
        | yes        |
 _______| _____  ______| _______
 |   処理1 _| |   処理2 _|
        |              |
        |←――― l
        |

 
 
 
 
 
 
 

 charの内容が'A'であれば処理1を実行し、それ以外ならば何もしない
        | 
　   ／＼　
  ／ch='A'＼__no__
　＼      ／        |
  　 ＼／           |
        | yes        |
 _______| _____        |
 |   処理1 _|       |
        |              |
        |←――― l
        |

  if(ch=='A') {
              　処理1;
  }
  else{
                処理2;
  }
どの処理の例もすべて、処理後合流していることが重要。多重分岐など含めて必ず合流しなくてはならない。　
import   java.io.*;　

class Test {
     public static void main (String args[ ]) {
          int n;
          n = readNumber( );
          if ( 10 <= N && n < 20 )
              System.out.println("10代");
     }

     // キーボードから数字を入力するメソッド
     public static int readNumber ( ) {
           byte b [ ] = new byte[100];

           try {
                   System.in.read(b);
                   return integer.parselnt((new String(b)).trim());
           } catch (Exception e) {
                  return 0;
           }
      }
}
「10代以上」という条件と「20代未満」という条件を「&&」で区切ることで、その両方を満たす場合に限り以下の文が実行される。
さらに、複数の条件のうちどれか一つでもみたされていれば実行させたい場合は、「&&」の代わりに、「 || 」で区切る。
また、条件が満たされない場合の処理がなければ、「else」文を省略することもできる。
 
3.多重分岐
多重分岐とは、単一分岐を組み合わせたもので､単一分岐の処理の中にまたは条件分岐を含むためのものである。

　　　 |
　   ／＼　
  ／条件1＼___yes
　＼      ／        |
  　 ＼／         ／＼　
　　　 |no   　／条件2 ＼__yes___
　　　 |　　　  ＼       ／          |
　　　 |            ＼／             |
 _______|______  ______| no___   ______|______ 
 |   処理1 _| |   処理2 _|  |___処理3_|
        |              |                 |
        |←――― l ―――――l       
        |

Javaでの表記
    
    
    
    
if(条件1) {
                 if(条件2) {
                               処理3;
             {
             else{
                               処理2;
             }
}
else {
              処理1;
}		 　
下記の例はキーボードから数字を入力し､その数字が負数なら「負数」、0なら「0」、整数なら「整数」と表示する。2例とも同じ結果。
import  java.io.*;

class Test {
       public static void main (String args[]) {
            int n;
            n = readNumber() ;
            if  ( n < 0 ) {
                  System.out.println("負数") ;
            }
            else {
                    if ( n = = 0 ) {
                                System.out.println("0") ;
                    }
                    else {
                           System.out.println("正数") ;
                    }
             }
        }

       // キーボードから数字を入力するメソッド
       public static int readNumber ( ) {
             byte b [] = new byte [100];

             try {
                    System.in.read ( b ) ;
                    return Integer.parselnt ( ( new Stirng ( b ) ).trim ( ) ) ;
             } catch( Exception e) {
                         return 0 ;
             }
       }
}

 import java.io.*;

class Test {
      public static void main(String args[]) {
            int n ;
            n = readNumber ( ) ;
            if  ( n < 0 ) {
                System.out.println("負数") ;
            }
           else if  ( n == 0 ) {
                System.out.println ( "0") ;          
            }
            else {
                   System.out.printin("正数") ;
            }
      }

      // キーボードから数字を入力するメソッド
　　 public static int readNumber ( ) {
               byte b [] = new byte[100] ;

      try {
             System.in.read (b) ;
             return Integer.parselnt ( ( new String ( b ) ).trim( ) ) ;
      } catch ( Exception e) {
             return 0
            }
      }
}

 
　
4.ケース構造
　 3つ以上の異なった処理の中から、条件にあった処理を行うことを多方向分岐という。
例）char の内容が'A'だったらwに65を、'B'ならば66をそれ以外なら0を代入する。
        |
　   ／＼　
　／char  ＼
　＼      ／
  　 ＼／
    　  | "A"       __________________
        |――――|     65 → w  |―――l
   　   | "B"      ___________________          |
        |――――|     66 → w  |―――|
     　 | default  ___________________          |
        |――――|     0 → w    |―――|
    　                                             |
    　  l―――――――――――――l
    　  |		 switch(chara) {
     case'A' : w=65 : break ;
     case'B' : w=66 : break ;
     default :  w=0 :  break ;
}
        |
　   ／＼　
　／char  ＼
　＼      ／
  　 ＼／
    　  | "A"       __________________
        |――――|     65 → w  |―――l
        |            |―――――――――l
    　  | "B"    ↓___________________         
        |――――|     66 → w   |―――l
        |             |―――――――――l
     　 | default ↓__________________          
        |――――|     0 → w    |―――l
    　                                             |
    　  l―――――――――――――l
    　  |		 switch(chara) {
     case'A' : w=65 :
     case'B' : w=66 :
     default :  w=0 :
}
　
5.反復構造(while)
　while文は､前判定型であり、繰り返し処理に入る前に繰り返し条件をチェックする。したがって条件によっては繰り返し処理を1度も実行しない場合もある。
  1から100までの合計を求めてみる。
import java.io.*;

class  Test {
    public static void main (String args[ ]) {
        int n. t;

        n = 1;
        t = 0;

        while (n <= 100) {
             t = t + 1;
             n = n + 1;
        }
        System.out.println("1から100までの合計は"+t+"です") ;
    }
}
   　    　　
while文ではwhileの後の括弧の中に条件式を記述し、その条件式が真になる間処理が繰り返される。もちろん、複数の条件式を「&&」「||」でつなげることもできる。　
　
6.反復構造(do)　
　do～while文は、後判定型であり、繰り返し処理を行った後に繰り返し条件をチェックする。
例）１～100までの合計を求めてみる。　
import java.io.*;

class Test {
      public static void main(String args[ ]) {
              int n. t;
 
              n = 1;
              t = 0;
 
              do { 
                      t = t + n;
                n = n + 1;
              } while(n <= 100);
              System.out.println("1から100までの合計は"+t+"です") ;
      }
} 
 　
　
7.反復構造(for)　
　for文は、前判定型であり、繰り返し処理に入る前に繰り返しチェックする。
for文は、while文に初期設定と、変化式を組み合わせたものです。これまでの例と同様に1～100までの合計を求めてみる。 
import java.io.*;

class Test {
     public static void main (String args[])
          int n. t;

          n =  1;                                                   // 初期設定
          t = 0;                                                　  // 初期設定

          while(n <=100) {
                t = t + n;
                n = t + 1;      // 変化式
　　　　}
         System.out.println("1～100までの合計は"+t+""です") ;
     }
}
　for文ではこれらを一緒に組み込む事ができる。
import java.io.*;　

class Test{
      public static void main(String args[]) {
             int n.t;

             for( n = 1.t = 0 : n <= 100 : n = n + 1) {
                    t = t + n;
             }
             System.out.println("1～100までの合計は"+t+"です") ;
       }
}
すなわち　
　　　　　　　for ( 初期設定 ; 条件式 ; 変化式 )
                            　繰り返し処理
import java.io.*;

class Test {
      public static void main (String args[]) {
           int n. t;

           n = 1 ;
           t = 0 ;

          for( ; n <=100 : n = n + 1) {
               t = t + n :
          System.out.println("1～100までの合計は"+t+"です") ;
     }
}

 import java.io.*;

class Test {
     public static void main(String args[]) {
           int n. t;

           n = 1;                                                       // 初期設定
           t = 0 ;                                                       // 初期設定

　　　　  for ( : n <= 100 ; n = n + 1)
                    t = t + n ;

           System.out.println("1～100までの合計は"+t+"です") ;
     }
}

　
8.補助制御文　
　実際のプログラムでは、反復処理中に処理から抜け出した方がプログラムがすっきり書ける場合も少なくない。
　break 「while」「for」 などの反復処理中に使用すると、強制的に反復処理を抜ける。
　continue 反復構造中に使用すると、反復処理が終了した事になる。条件が真ならば再度反復処理。
　return 関数から抜ける。
●　キーボードから月（1～12）を入力し、その月の日数を表示するプログラム
import java.io.*;

class Test {
     public static void main (String args[]) {
          int month;
          System.out.print("月（1～12）を入力してください　:　") ;
          month = readNumber( ) ;

          swtich (month) {
          case 1;
          case 3;
          case 5;
          case 7;
          case 8;
          case 10;
          case 12;
                System.out.println(month+"月は31日です") ;
                break ;
          case 2;
                System.out.println(month+"月は28日か29日です") ;
                break ;
          case 4;
          case 6;
          case 9;
          case 11;
                System.out.println(month+"月は30日です") ;
                break ;
          default ;
                System.out.println("1～12を入力してください") ;
          }
     }

     // キーボードから数字を入力するメソッド
     public static int readNumber( ) {
           byte b[] = new byte[100];

           try {
                   System.in.read(b) ;
                   return Integer.parselnt((new String(b)) . trim( )) ;
           } catch (Exception e) {
                   return 0 ;
           }
      }
}
　
11.多重ループの抜け方　
class Test{
     public static void main (String args[]) {
          boolean bContinue = true;
          for(  int i = 0 ; i < 10 && bContinue : i++ ) {
                 for( int  j = 0 : j < 10 && bContinue : i++ ) {
                      System.out.println("i =" + i + " j=" + j ) ;
                      if ( i == 5 && j == 5 ) {
                          bContinue = false ;
                          break ;
                      }
                 }
           }
      }
}　
上記の例では処理が少ないからこれでもスッキリして見えるが、処理が複雑になると、上述のようにひとつめのfor文の条件にフラグ判定をいれるのではなく、入れ子になっているfor文が終わった場所にif文で更に条件分岐が必要になる場合もある。
class Test{ｃ　
     public static void main (String args[]) {
          boolean bContinue = true;
          for ( int i = 0 ; i < 10 && bContinue ; i++  ) {
                for ( int j = 0 ; j < 10 ; j++ ) {
                      System.out.println("i=" + i + " j=" + j ) ;
                      if ( i == 5 && j == 5 ) {
                          bContinue = false;
                          break ;
                      }
                }
                if ( !bContinue )
                    break ;
           }
      }
}
これでもまだ余分な処理が書かれていないからいいが、これが実際にプログラムになると他にもいろいろ入ってくるからみにくい。
実はJavaではforやwhileといった反復構造のみにラベルを使用することができ、break文でどのループを抜け出すか指定ができる。
class Test{
     public static void main (String args[]) {
     LOOP1;
     for ( int i = 0 : i < 10 : i++  ) {
            for( int j = 0 : j < 10 : i++ ) {
                 System.out.println("i=" + i + " j=" + j ) ;
                 if ( i == 5 && j == 5 ) {
                      break LOOP1 ;
                 }
            }
         }
    }
}