/*
  需求：
    A:求1-100之和。
    B:求出1-100之間偶數(shù)和
*/
class ForTest1 {
  public static void main(String[] args) {
    //求1-100之和。
    int sum1 = 0;
    
    for(int x=1; x<=100; x++) {
      sum1 +=x;
    }
    
    System.out.println("1-100之和是："+sum1);
    System.out.println("------------------");
    
    //求出1-100之間偶數(shù)和
    //方式1
    int sum2 = 0;
    
    for(int x=1; x<=100; x++) {
      if(x%2 == 0) {
        sum2 += x;
      }
    }
    
    System.out.println("1-100偶數(shù)之和是："+sum2);
    System.out.println("------------------");
    
    //方式2
    int sum3 = 0;
    
    for(int x=0; x<=100; x+=2) {
        sum3 += x;
    }
    
    System.out.println("1-100偶數(shù)之和是："+sum3);
    System.out.println("------------------");
  }
}

/*
  需求：求5的階乘。
  
  什么是階乘呢?
    n! = n*(n-1)! 規(guī)則
    n! = n*(n-1)*(n-2)*...*3*2*1
    
  求和思想。
  求階乘思想。
*/
class ForTest2 {
  public static void main(String[] args) {
    //定義最終結(jié)果變量
    int jc = 1;
    
    //這里的x其實(shí)可以直接從2開始
    //for(int x=1; x<=5; x++) 
    
    for(int x=2; x<=5; x++) {
      jc *=x;
    }
    
    System.out.println("1-5的階乘是："+jc);
  }
}

/*

  需求：在控制臺輸出所有的”水仙花數(shù)”
  
  分析：
    我們都不知道什么叫"水仙花數(shù)"，你讓我怎么做呢?
    
    所謂的水仙花數(shù)是指一個三位數(shù)，其各位數(shù)字的立方和等于該數(shù)本身。
    舉例：153就是一個水仙花數(shù)。
    153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153

    A:三位數(shù)其實(shí)是告訴了我們范圍。
    B:通過for循環(huán)我們就可以實(shí)現(xiàn)獲取每一個三位數(shù)
     但是麻煩是如何獲取這個三位數(shù)的個,十,百位上的數(shù)據(jù)
     
     我們?nèi)绾潍@取一個數(shù)據(jù)的個,十,百呢?
      假設(shè)有個一個數(shù)據(jù):153
      ge:  153%10 = 3
      shi: 153/10%10 = 5
      bai：153/10/10%10 = 1
      qian：x/10/10/10%10
      wan: x/10/10/10/10%10
      ...

    C:讓ge*ge*ge+shi*shi*shi+bai*bai*bai和該數(shù)據(jù)比較
     如果相同，就把該數(shù)據(jù)在控制臺輸出。
*/
class ForTest3 {
  public static void main(String[] args) {
    //三位數(shù)其實(shí)是告訴了我們范圍。
    for(int x=100; x<1000; x++) {
      int ge = x%10;
      int shi = x/10%10;
      int bai = x/10/10%10;
      
      //讓ge*ge*ge+shi*shi*shi+bai*bai*bai和該數(shù)據(jù)比較
      if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) {
        //如果相同，就把該數(shù)據(jù)在控制臺輸出。
        System.out.println(x);
      }
    }
  }
}

/*
  我國最高山峰是珠穆朗瑪峰：8848m，我現(xiàn)在有一張足夠大的紙張，厚度為：0.01m。
  請問，我折疊多少次，就可以保證厚度不低于珠穆朗瑪峰的高度?

  分析：
    A:定義一個統(tǒng)計(jì)變量，默認(rèn)值是0
    B:最高山峰是珠穆朗瑪峰：8848m這是最終的厚度
     我現(xiàn)在有一張足夠大的紙張，厚度為：0.01m這是初始厚度
    C:我折疊多少次，就可以保證厚度不低于珠穆朗瑪峰的高度?
     折疊一次有什么變化呢?就是厚度是以前的2倍。
    D:只要每次變化的厚度沒有超過珠穆朗瑪峰的高度，就折疊，統(tǒng)計(jì)變量++
    E:輸出統(tǒng)計(jì)變量。
*/

class WhileTest01 {
  public static void main(String[] args) {
    //定義一個統(tǒng)計(jì)變量，默認(rèn)值是0
    int count = 0;
    
    //最高山峰是珠穆朗瑪峰：8848m這是最終的厚度
    //我現(xiàn)在有一張足夠大的紙張，厚度為：0.01m這是初始厚度
    //為了簡單，我把0.01變成1，同理8848就變成了884800
    int end = 884800;
    int start = 1;
    
    while(start<end) {
      //只要每次變化的厚度沒有超過珠穆朗瑪峰的高度，就折疊，統(tǒng)計(jì)變量++
      count++;
      
      //折疊一次有什么變化呢?就是厚度是以前的2倍。
      start *= 2;
      
      System.out.println("第"+count+"次厚度是"+start);
    }
    
    //輸出統(tǒng)計(jì)變量。
    System.out.println("要疊"+count+"次");
  }
}

/*
  需求：請輸出下列的形狀
    *
    **
    ***
    ****
    *****

    提示：外循環(huán)控制行數(shù)，內(nèi)循環(huán)控制列數(shù)
*/
class ForForTest01 {
  public static void main(String[] args) {
    //通過簡單的觀察，我們看到這是一個行是5，列數(shù)是變化的形狀
    //我們先打印出一個5行5列的形狀
    for(int x=0; x<5; x++) {
      for(int y=0; y<5; y++) {
        System.out.print("*");
      }
      System.out.println();
    }
    
    System.out.println("--------------");
    
    //我們實(shí)現(xiàn)了一個5行5列的形狀
    //但是這不是我們想要的
    //我們要的是列數(shù)變化的
    //列數(shù)是如何變化的呢?
    //第一行：1列  y=0,y<=0,y++
    //第二行：2列  y=0,y<=1,y++
    //第三行：3列  y=0,y<=2,y++
    //第四行：4列  y=0,y<=3,y++
    //第五行：5列  y=0,y<=4,y++
    //在看外循環(huán)x的變化，恰好就是x=0,1,2,3,4
    //所以這個最終版的程序就是如下
    for(int x=0; x<5; x++) {
      for(int y=0; y<=x; y++) {
        System.out.print("*");
      }
      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*9=9  2*9=18  3*9=27  ...
    
  我們先把這個九九乘法表看出是這樣的一個形狀：
    *
    **
    ***
    ****
    *****
    ******
    *******
    ********
    *********
    
  注意：
    '\x' x表示任意，這種做法叫轉(zhuǎn)移字符。
    
    '\t'  一個制表符的位置（tabtab鍵）
    '\r'  回車
    '\n'  換行
*/
class ForForTest02 {
  public static void main(String[] args) {
    for(int x=0; x<9; x++) {
      for(int y=0; y<=x; y++) {
        System.out.print("*");
      }
      System.out.println();
    }
    System.out.println("--------------");
    //為了使用數(shù)據(jù)，我們從1開始
    for(int x=1; x<=9; x++) {
      for(int y=1; y<=x; y++) {
        System.out.print(y+"*"+x+"="+y*x+"\t");
      }
      System.out.println();
    }
  }
}

/*
  控制跳轉(zhuǎn)語句：
    break:中斷
    continue:繼續(xù)
    return:返回
  
  break:中斷的意思
  使用場景：
    A:switch語句中
    B:循環(huán)語句中。
      (循環(huán)語句中加入了if判斷的情況)
    注意：離開上面的兩個場景，無意義。
    
  如何使用呢?
    A:跳出單層循環(huán)
    B:跳出多層循環(huán)
      要想實(shí)現(xiàn)這個效果，就必須知道一個東西。帶標(biāo)簽的語句。
      格式：
        標(biāo)簽名: 語句
*/
class BreakDemo {
  public static void main(String[] args) {
    //在 switch 或 loop 外部中斷
    //break;
    
    //跳出單層循環(huán)
    for(int x=0; x<10; x++) {
      if(x == 3) {
        break;
      }
      System.out.println("HelloWorld");
    }
    
    System.out.println("over");
    System.out.println("-------------");
    
    //跳出多層循環(huán)
    wc:for(int x=0; x<3; x++) {
      nc:for(int y=0; y<4; y++) {
        if(y == 2) {
          //break nc;
          break wc;
        }
        System.out.print("*");
      }
      System.out.println();
    }
  }
}

for(int x=1; x<=10; x++) {
    if(x%3==0) {
      //在此處填寫代碼

    }
    System.out.println("Java學(xué)習(xí)");
  }

/*
  需求：小芳的媽媽每天給她2.5元錢，她都會存起來，但是，
     每當(dāng)這一天是存錢的第5天或者5的倍數(shù)的話，她都會花去6元錢，
     請問，經(jīng)過多少天，小芳才可以存到100元錢。

  分析：
    A:小芳的媽媽每天給她2.5元錢
      double dayMoney = 2.5;
    B:她都會存起來
      double daySum = 0;
    C:從第一天開始存儲
      int dayCount = 1;
    D:經(jīng)過多少天，小芳才可以存到100元錢。
      double result = 100;
    E:這一天是存錢的第5天或者5的倍數(shù)的話，她都會花去6元錢，
      說明要判斷dayCount的值，如果對5整除就減去6元錢。
        daySum -= 6;
     由此還隱含了一個問題，就是如果不是5的倍數(shù)天的話，錢要累加
        daySum += dayMoney;
    F:因?yàn)椴恢朗嵌嗌偬欤晕矣盟姥h(huán)，一旦超過100元我就退出循環(huán)。
*/
class WhileDemo {
  public static void main(String[] args) {
    //每天要存儲的錢是2.5元
    double dayMoney = 2.5;
    
    //存錢的初始化值是0
    double daySum = 0;
    
    //從第一天開始存儲
    int dayCount = 1;
    
    //最終存儲不小于100就不存儲了
    int result = 100;
    
    //因?yàn)椴恢朗嵌嗌偬?，所以我用死循環(huán)，
    while(true) {
      //累加錢
      daySum += dayMoney;
      
      //一旦超過100元我就退出循環(huán)。
      if(daySum >= result) {
        System.out.println("共花了"+dayCount+"天存儲了100元");
        break;
      }
      
      if(dayCount%5 == 0) {
        //花去6元錢
        daySum -= 6;
        System.out.println("第"+dayCount+"天花了6元錢");
      }
      
      //天數(shù)變化
      dayCount++;
    }
  }
}