/*
 * 1.循环
 * 2.循环三要素：
 *    1)循环变量的初始化
 *    2)循环的条件（以循环变量为基础）
 *    3)循环变量的改变（向着循环的结束变）
 *    循环变量：在循环过程中的那个量
 * 3.循环结构：
 *    1）while循环：先判断后执行，有可能一次都不执行
 *    2)do.....while结构：先执行后判断，至少执行一次
 *                       第1要素与第3要素相同时，首选
 *    3)for结构:应用率最高
 *    
 * 1.while(boolean表达式){//boolean为true，执行语句块，否则退出
 *      if(true){
 *         break;   //break用再循环体中用于退出循环
 *      }
 *      语句块  //被重复的操作
 * }
 *     循环能跳出的条件：1）条件为假
 *                     2）碰着break
 * 
 * 2.do-while//无论boolean表达式是否为true,都先执行一次语句块
 *    do{
 *        语 句 块        
 *    }while(boolean表达式)
 *    
 *    
 * 3.for结构应用：
 *    for(要素1;要素2;要素3){
 *         语句块;
 *    }
 *  特殊用法：
 *    要素1;
 *    for(;要素2;要素3){
 *    }  
 * 4.break:跳出循环,常常与条件语句一起使用
 *   continue:跳过循环体中剩余语句而执行下一次循环


   5..三种循环结构的更加适用情况：
 *   5.1）while:"当---"循环
 *   5.2）do--while:"直到---"循环
 *                第1要素与第3要素相同时首选
 *  5. 3）for:固定次数循环，应用率最高
 *
 * 6.嵌套循环：
 *  6.1）循环中套循环，一般多行多列时使用,
 *     外层控制行，内层控制列
 *  6.2）执行过程：外层循环走一次，内层循环走所有次
 *  6.3）建议：嵌套层次越少越好，能用一层就不能用两层
 *           若逻辑必须要通过3层以上才能解决，说明设计
 *           有问题.
 *  6.4）break只能跳出一层循环 
 * */

案例1.
/*  随机加法运算器：
 *     程序依次出10道题目，由用户输入题目的答案;
 *     用户每答完一道题，程序判断对错，并提示："答对了"
 *     或“答错了”
 *     10道题目答完之后，系统计算得分并输出；
 *     用户希望提前结束，可以输入-1提前退出。
 * */
import java.util.Scanner;

public class PracticeAdd1 {

	public static void main(String[] args) {
	Scanner scan = new Scanner(System.in);
	int score=0;
	for(int i=1;i<=10;i++){
		int x = (int)(Math.random()*100);
		int y = (int)(Math.random()*100);
		int result = x+y;
		System.out.print("("+i+")"+x+"+"+y+"=");
		int n= scan.nextInt();
		if(n==-1){
			break;
		}
		if(result==n){
			System.out.println("答对了");
			score+=10;
		}else{
			System.out.println("答错了");
		}
	}
	System.out.println(score);
	}

}
案例2.
    //while的演示


/*案例：程序随机生成并存储一个整数：
*      用户输入一个整数，程序给出与存储的数字“大”或“小”
*      的比较结果提示；直到用户猜对数字为止；
*      如果中途，用户希望结束程序，可以输入0退出
*  Math.random()------0.0~0.999999
* *1000-------------0.0~999.99999
*  +1---------------1.0~1000.99999
*  
* */
import java.util.Scanner;
public class Guessing {

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int num = (int)(Math.random()*1000+1);
		System.out.println(num);
		
		int guess;
		do{
			System.out.println("猜吧");
			guess = scan.nextInt();
			if(guess==0){
				break;
			}
			if(guess>num){
				System.out.println("太大了");
			}else if(guess<num){
				System.out.println("太小了");
			}
		}while(guess!=num);
		  if(guess==num){
		    	System.out.println("恭喜，猜对啦");
		    }else{
		    	System.out.println("下次再来吧");
		    }
		
		/*
		System.out.println("猜吧");
		int guess = scan.nextInt();
		while(guess!=num){
			if(guess==0){
				break;
			}
			if(guess>num){
				System.out.println("太大了");
			}else{
				System.out.println("太小了");
			}
			System.out.println("猜吧");
			guess = scan.nextInt();
		}
	    if(guess==num){
	    	System.out.println("恭喜，猜对啦");
	    }else{
	    	System.out.println("下次再来吧");
	    }
         */
	}

}

表达式 （Expression）

语句 ：以分号结束

语句块

 


java中程序的三种结构：顺序结构     分支结构   循环结构


if（逻辑表达式，备注，和c不同，一定是逻辑结果）{

条件为真时执行

}

else {

条件为假时执行

}

if（true）条件

switch（int类型|string类型| Enum类型）

case 条件1：

…

case 条件2：

break;

…

default;

}

注意：回车用%n 不用\n

循环结构：

while （条件）{

//在Java中多了一种for的形势 foreach

//for(元素类型 变量名 ：容量数组）{

//}

}

for（初始化 ；条件；后续动作）

{

}

do{

}while (条件）

continue 和break 都支持带标签的形式

public static void fied () {

int [] array ={1,2,3,4,5,6,7};

for(int i=0;i<array.length

break;

}

}

方法组成：


限定符：
	
返回值类型，如果没有返回值，要明确写void
	
方法名称，命名习惯：收个单词全小写，以后的单词首字母大写，多为动词
	
参数列表            () | 参数类型 参数名称
	
异常声明    throw
	
** 方法体{}



public  static int caleSum(int[] array)  thows Exception{

…                                  //下划线分别为1——6

}


 

重点：关于方法签名 （Method signature）

方法名称+参数列表

int sum(int a ,int b){}    void sum (int a, int b) {} 一样

int sum (int a,int b ,int c){}不一样

方法名称相同，但参数列表不同

重载 （overload)通常情况下，用不到重载，例外：重载在构造方法中很常见

要和 重写 区分

 

public class cation{
//计算n的位数，n一定为正数	
public static int calcDigitNum (long n) {
int  digitNum=0;
while (n>0)
{
	n=n/10;
	digitNum++;
}
return digitNum;
}

//pubilc stactic int factorial(int n)
public static void main (String[] args)
{
	//long n=Long.parseLong(long 
int m =calcDigitNum(1234);
System.out.printf("%d",m);
}
}

利用简单whlie循环判断位数

public class cation{
//计算n阶乘
public static int calcDigitNum1 (int n) {
if (n==1){
	return 1;
}
else {
	return n*calcDigitNum1(n-1);
}
}
public static long calcDigitNum2 (int n) {
	long fact=1;
for (int i=1;n>=i;i++)
{
	fact =fact*i;
}
return fact;
}
public static void main (String[] args)
{
long m =calcDigitNum1(5);
System.out.printf("%d",m);
long fact =calcDigitNum2(5);
System.out.printf("%d",fact);

}
}

 函数递归思想计算阶乘

当n=1时，n!=1

当n>1时，n!=n*(n-1)!

public class cation{
//计算e=1-1/1!+1/2!-…+1/n!

public static long factorial (int n){
//求阶乘1.递归 2.循环
if (n==1|n==0){
	return 1;
}
else {
	return n*factorial(n-1);
}
}
public static double calcE(int n) {
//加法
double sum =0.0;
int j=1;
for (int i=0;i<n;i++)
{
	sum =j*(sum+1.0/factorial( i)) ;
	j=j*-1;
}
return sum;
}

public static void main (String[] args){
long m=factorial(5);
System.out.printf("%d%n",m);
double sum=calcE(5);
System.out.printf("%f",sum);
}
}

利用1.函数递归 （同上一个代码）   2.循环的方法 计算e=1-1/1!+1/2!-…+1/n!

public class cation{
//反转字符串

public static String reverse (String s){
	int length=s.length();
	String r="";
	for (int i=length-1 ;i>=0;i--)
	{
		char ch =s.charAt(i);
		r=r+ch;
	}
	return r;
}
public static String decToHex(int dec ) {
	//10进制变为16进制
	String hex ="";
	while (dec>=16)
	{
		int remainder =dec%16;
		dec=dec/16;
		if(remainder<10) {
			hex=hex+remainder;
		}
		else {
			char ch=(char )('A'+(remainder-10));
			hex=hex+ch;
		}
		
	}
	return reverse (hex);
}

public static void main (String[] args){
String message ="Hello";
String r=reverse (message);
System.out.printf(r);
//反转为“olleH"
System.out.printf(decToHex(212324));
}
}

 1.反转字符串例子：hello变为olleh  

2.将十进制数字转为16进制

原理：/16，%16


在Java中，递归没有任何特殊性

但是利用了数学归纳法的思想   

核心：要有局部性原则，不要在写递归时尝试展开递归过程

举例：汉诺塔游戏

* 三种循环语句的区别:
* do...while循环至少执行一次循环体。
* 而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句。
* for循环和while循环的区别：
* A:如果你想在循环结束后，继续使用控制条件的那个变量，用while循环，
* B:用for循环的话。for循环执行语句后变量会被释放，及早的从内存中消失，可以提高内存的使用效率。

 

1.复合语句

同C语言或其他语言相同，Java语言的复合语句是以整个块区为单位的语句，所以又称块语句。复合语句由开括号“{”开始，闭括号“}”结束。

例如在定义一个类或方法时，类体就是以“{ }”作为开始与结束的标记，方法体同样也是以“{ }”作为标记。

如下列例子中，就在主语句中嵌套进了两个语句，这两个语句就称之为复合语句。

2.循环语句

(1).while循环语句
while循环语句也称条件判断句，它的循环方式是利用一个条件来控制是否继续反复执行这个语句。
语法如下：
while(条件表达式）
{
执行语句

}
这个语句的意思是，当while的条件表达式为真时，就执行语句，当执行完时，又重新返回判断{}中的返回值，直到表达式返回结果为假时，退出循环。

(2).do…while语句
do…while语句与while语句类似，它们的区别在于while语句为先判断条件是否成立再执行循环体，而do…while语句是先执行一遍语句之后，再判断条件是否成立，也就是说do…while语句要先至少被执行一次。
语法如下：
do
{
执行语句
}
while(条件表达式）;
do…while语句和while语句的一个明显区别在于do…while语句在结尾多了一个分号。

(3).for语句
语法如下：
for(表达式1；表达式2；表达式3）
{
 语块

}
表达式1：初始化表达式，完成变量的初始化；
表达式2：循环条件表达式，返回值为布尔型，指循环条件；
表达式3：循环后操作表达式，负责修整变量，改变循环条件。
执行for循环语句时，首先初始化表达式1，下一步判断表达式2，如果表达式2 的值为ture,则进入循环体；执行完循环体紧接着计算表达式3.第二轮循环从表达式2 开始，一直到表达式2判断为false结束。


3.三种循环语句的区别


4.跳转语句

countinue：用来终止本次循环，继续下一次循环。

break：用来跳出循环，在switch或者循环中使用。

return：用来结束方法。
5.Java循环结构案例

分析以下需求，并用代码实现：

1.按照从大到小的顺序输出四位数中的个位+百位=十位+千位 的数字及个数

2.每行输出5个满足条件的数，之间用空格分隔

3.如：9999 9988 9977 9966 9955



其中一部分运行结果



九九乘法表



运行结果为