DAY 03
循环结构：
代表语句：while、do while、for
while格式：
初始化表达式；
while (条件表达式)
｛
循环体（执行语句）；
｝
1、while
格式：
while格式：
初始化表达式；
while (条件表达式)
｛
循环体（执行语句）；
｝
例1：
先判断是否满足条件然后再执行循环体
class xunhuan
{
public static void main(String[] args)
{
int x=1;
//如果取偶数直接x=0
while (x<=10)
{
System.out.println("x="+x);
//x++;
x+=2;
//取10以内的奇数，x+=2就是x=x+2
/*如果没有这个X++或x+2的话将是无限循环，因为条件限制将不起作用。
这里也可以是X--，但是需要改变条件
例如：int x=10
while (x>0)
*/
}
System.out.println("==================");
}
}
2、do while
格式：
do while格式：
定义初始化表达式；
do
｛
执行语句；
｝
while （条件表达式）
例：
先执行do语句，然后再判断。
class while2
{
public static void main(String[] args)
{
int y=11;
/*当y的值<=10的时候输出结果和上面一样，但是当y大于10
的时候，do 下面的执行语句会执行一次
*/
do
{
System.out.println("y="+y);
y+=2;
}
while (y<=10);
System.out.println("==================");
/*
while和do while的区别：
while语句现判断条件再执行语句，只有条件满足才执行循环体
do while语句现执行语句再判断条件，无论条件是否满足，循环体都执行一次。
*/
}
}
3、for
格式：
for (初始化表达式；循环条件表达式；循环后的操作表达式)
｛
执行语句；（循环体）;
｝
例1：
class for1
{
public static void main(String[] args)
{
for (int z=0;z<3 ;z++ )
{
System.out.println("z="+z);
}
// System.out.println ("z==="+z);
System.out.println("==================");
}
}
上面循环的过程：
1、执行变量 int z=0
2、判断z是否小于3
3、z小于3则直接跳到循环体，打印z=+z 0
4、3执行完后跳到z++第一次自加
5、Z++后判断z是否小于3
6、小于3，直接跳到循环体，打印z=+z 1
7、6执行完后跳到z++第二次自加
8、Z++后判断z是否小于3
9、小于3，直接跳到循环体，打印z=+z 2
10、9执行完后跳到z++第三次自加
11、z++后判断z是否小于3
12、不小于3跳出循环体
例2：
while语句与for语句对比
class for1
{
public static void main(String[] args)
{
int a=0;
while (a<3)
{
System.out.println ("a="+a);
a++;
}
System.out.println ("a==="+a);
//打印出a自加后的值。
}
}
特点：
1、变量有自己的作用域
2、for和while可以互换使用
初始化变量（z）在for语句中，只在循环体内生效，如果跳出循环体后内存自动释放。
while语句的初始化变量(a)在循环体外面，所以可以打印出a自加后的值。
也就是说，for和while语句中，初始化变量的作用域不同。
for 语句更节省内存。
如果当初始化值只为循环增量存在的话使用for合适。
for和while可以互换使用，for能写的while也能写，while能写的for也能写。
总结：什么时候使用循环结构?
当对某些语句使用很多次时，就使用循环结构。
4、循环语句的其他特点：
例：
class xhother
{
public static void main(String[] args)
{
int x=0;
/*for (System.out.println("A");System.out.println("B") ; System.out.println("C"))
条件表达式，必须要有真假判断，并且只要是合法表达式就可以运行。
*/
for (System.out.println("A");x<3 ; System.out.println("C"),x++)
{
System.out.println("D");
}
/*
无限循环的最简单表现形式：
for(;;){} for循环可以不写初始化表达式；循环条件表达式；循环后的操作表达式，这时条件表达式默认为true
while(true){}
*/
System.out.println("Over");
}
}
5、for语句累加计数器
例1：
class foradd
{
public static void main(String[] args)
{
int he=0;
//定义一个变量用来存储不断变化的he
//定义右边的被加数变量为a，也就是需要进行参加运算的数。
for (int a=0;a<=10;a++ )
{
he+=a;
//he=he+a，循环后打印he
}
System.out.println(he);
//while的方式
int a=0;
int x=0;
while (x<=10)
{
a=a+x;
x++;
}
System.out.println(a);
}
/*
0+1+2+3+4也就是0+1=1；1+2=3；3+3=6；6+4=10，就是说左边的数是
两个数相加的和（不确定的数），右边的数是顺序变化的（累加的数）。
*/
}
例2：
/*
for语句练习-累加&计数器
1~100之间 7的倍数的个数，并打印。
思路：
1、对1-100进行循环
2、在循环过程中定义条件，只对7的倍数进行操作。x%7==0
3、判断那些是7的倍数使用if语句，
4、循环过程中将7的倍数记录下来，定义一个变量a，a随着7的倍数递增。
将其定义到循环外面，
如果定义到里面循环结束后将被内存释放
*/
class foradd2
{
public static void main(String[] args)
{
int a=0;
//定义一个变量用来记忆循环次数。
for (int x=1 ;x<=100 ;x++ )
//对1-100进行一个循环。
{
if (x%7==0)
//x%7=0时也就是可以整除7的数，也就是7的倍数。
{
a++;
//记忆不断变化的循环次数。
}
}
System.out.println(a);
//打印出一共循环了多少次。
}
}
/*
编程思想：
1、累加思想，通过变量记录住，循环操作后的结果。（字符串的不断延长）
通过循环的形式，进行累加动作。
2、计数器思想，通过一个变量，记录住数据的状态变化，也需要通过循环完成。
*/
6、for嵌套
例：for嵌套就是在for语句中再加一个for语句。
class forandfor
{
public static void main(String[] args)
{
for (int x=0;x<3 ;x++ )
//当x小于3满足后进入内循环
{
for (int y=0;y<4 ;y++ )
//当内循环，循环结束后，
//也就是打印4次y后再次回到外循环。
{
System.out.print("*");
}
System.out.println();
//只有一个功能就是换行
}
}
}
解释：
****
****
****
对于上面的长方形外循环控制行数，内循环控制每一行的列数，也就是一行中元素的个数。
例：三角形循环01
class forandfor
{
public static void main(String[] args)
{
for (int x=0;x<5 ;x++ )
//当x小于5满足后进入内循环
{
for (int y=x;y<5 ;y++)
//当内循环，循环结束后，
//内循环变量y根据X的变化逐渐接近5，使打印的列数越来越小。
{
System.out.print("*");
}
System.out.println();
//只有一个功能就是换行
}
}
}
解释：
*****
****
***
**
*
对于上面图形首先确定，外循环控制的行数为5，
内循环控制的列数为5，并且递减。
例：三角形循环2
class forandfor
{
public static void main(String[] args)
{
for (int x=0;x<5 ;x++ )
//当x小于5满足后进入内循环
{
for (int y=0;y<=x ;y++)
//当内循环，循环结束后，
//内循环变量y根据X的变化逐渐接近5，使打印的列数越来越小。
{
System.out.print("*");
}
System.out.println();
//只有一个功能就是换行
}
}
}
解释：
*
**
***
****
*****
初始化值x=0的时候是5个星号,x=1的时候是4个星号。。。。。。
当条件y<x的时候图形发生变化。变成正三角。
1、尖朝上，可以改变条件，让条件随着外循环变化。
2、尖朝下，可以改变初始化值，让初始化值随着外循环变化。
例：九九乘法表
class forandfor
{
public static void main(String[] args)
{
for (int x=1;x<=9 ;x++ )
{
for (int y=1;y<=x ;y++)
//条件语句y<=x，y根据x的变化而变化，
{
System.out.print(y+"*"+x+"="+y*x+"\t");
}
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*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
乘数都是1
被乘数递增
7、其他流程控制语句
break（跳出）：应用范围，选择结构和循环结构。定义在循环语句内才有效果
continue：继续循环。continue下面的语句无法执行，将会返回上面的操作。结束本次循环继续下次循环。
例：
class forandfor
{
public static void main(String[] args)
{
w:for (int x=0;x<3 ;x++ )
{
System.out.println("x="+x);
//break;//打印一次后跳出循环，
//System.out.println("OK") 这行不能加，break下面的语句无效。
q:for (int y=0;y<3 ;y++ )
{
System.out.println("y="+y);
System.out.println("跳出循环w");
break w ;
//不加标识符时，只跳内循环
}
//w ,q是标识符break标谁跳谁
}
System.out.println("===========================");
for (int x=1;x<=10 ;x++ )
{
if (x%2==1)
{
continue;
//如果 x%2==1则打印下面的语句。
}
System.out.println("x="+x);
System.out.println("当x为偶数时continue继续循环");
}
System.out.println("===========================");
w:for (int x=0;x<9 ;x++ )
{
for (int y=0;y<9 ;y++ )
{
System.out.println("y");
continue w;
// 循环跳到外循环。
//System.out.println("x");这行如果不注释会报错，因为continue下面的语句无法执行.
}
}
System.out.println("===========================");
}
}
8、练习
例：等边三角形
class forandfor
{
public static void main(String[] args)
{
for (int x=0 ; x<5 ; x++ )
//定义外循环，来控制行数，上图删掉空格是5行。
{
for (int y=x+1;y<5 ;y++ )
//定义内循环控制列数，打印出-号。
//注意倒三角改变初始化值。
{
System.out.print("-");
}
for (int z=0;z<=x ;z++ )
//再次定义内循环打印出星号。
//注意正三角改变条件。
{
System.out.print("* ");
}
System.out.println();
}
System.out.println("==================================");
for (int x=0;x<5;x++ )
{
for (int y=x;y<5 ;y++ )
/*初始化值x=0的时候是5个星号,x=1的时候是4个星号。。。。。。
当条件y<x的时候图形发生变化。变成正三角。
1、尖朝上，可以改变条件，让条件随着外循环变化。
2、尖朝下，可以改变初始化值，让初始化值随着外循环变化。
*/
{
System.out.print("-");
}
System.out.println();
}
}
}
9、函数
函数的定义：函数就是定义在类中的具有特定功能的一段独立小程序。
函数也称为方法。
格式：
修饰符 返回值类型 函数名 （参数类型 形式参数1，参数类型 形式参数2 ...）
{
执行语句；
return 返回值；
}
返回值类型：函数运行后的结果的数据类型
参数类型：是形式参数的数据类型
形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。
实际参数：传递给形式参数的具体数值。
return: 用于结束函数。
返回值： 该值会返回给调用者
提高代码和功能的复用性
例1：重复代码的出现
class function1
{
public static void main(String[] args)
{
int x=1;
System.out.println(x*3+5);
int y=2;
System.out.println(x*3+5);
/*打印出任意数乘以3加5的值，如果多个值都要保存时，
需要重复输入相同的输出语句。
发现以上的运算，因为获取不同数据的运算结果，代码出现了重复。
为了提高代码的复用性，对代码进行抽取。
将这个部分定义成一个独立的功能，方便日后使用。
JAVA中对功能的定义是通过函数的形式来体现的。
这时就需要定义一个函数。
*/
}
}
例2：解决重复代码问题
class function1
{
public static void main(String[] args)
{
int z=get(5);//调用函数get 注意该行调用语句不能直接在类下，并且不要写在函数中。
System.out.println(z);
}
public static int get(int num)
{
return num*3+5;
}
}
例3：没有返回值时返回值类型使用void
class function1
{
public static void main(String[] args)
{
get2(2);
}
public static void get2(int a)
{
System.out.println (a*3+5);
//当函数运算后，没有具体的返回值时，这时返回值使用void代表，
//void代表的是函数没有具体返回值的情况。
//当函数返回值类型为void时，函数中的return语句可以省略不写。
}
}
10、函数的应用
函数的应用：
1、定义功能时，把不同的功能定义到函数中。
2、主函数的功能主要是，调用函数用。
如何定义函数：
1、既然函数是一个独立的功能，那么该功能的运算结果是什么先明确。
2、在明确在定义该功能的过程中是否需要未知的内容参与运算。
例1：
需求：定义一个功能，完成3+4的运算，并将结果返回给调用者。
思路：
1、明确功能的结果是一个整数的和；
2、在实现该功能过程中是否有未知内容参与运算。没有！！！
为了方便用户需求，有用户来指定加数和被加数才有意义。
其实这两个功能就是在明确函数的定义：
1、是在明确函数的返回值类型。
2、明确函数的参数列表（参数类型和形式参数）
该函数没有实际意义，因为不管谁调用返回值都是一样的。
class function1
{
public static void main(String[] args)
{
int x=he();
System .out.println(x);
}
public static int he ()
{
return 3+4;
}
}
例2：根据例1定义一个求和的函数，可以输出任何两个数的和。多个参数使用逗号隔开。
class function1
{
public static void main(String[] args)
{
int x=
he(2,4);
System.out.println(x);
}
public static int he (int a ,int b)
{
return a+b;
}
}
例3：同一个类中函数的名称相同，两个相同名称的函数只有参数列表不同。
class function1
{
public static void main(String[] args)
{
int x=
he(2,4);
System.out.println(x);
int y=
he(0,2,3);
System.out.println(y);
}
public static int he (int a ,int b)
{
return a+b;
}
public static int he (int a, int b, int c)
{
return a+b+c;
}
}
11、三元运算符
用来完成简单的选择逻辑，即根据条件判断，从两个选择中选择一种执行。
使用格式：
(条件表达式)？表达式1：表达式2；
运算规则：
a) 判断条件表达式，结果为一个布尔值。
b) true，运算结果为表达式1
c) false，运算结果为表达式2
例1：创建一个比较两个参数是否相等的函数。
class function1
{
public static void main(String[] args)
{
boolean x=
bj(1,2);
System.out.println(x);
}
public static boolean bj(int a, int b)
{
if (a==b)
return true;
else
return false;
}
}
例2：使用三元运算符，将例1简化
class function1
{
public static void main(String[] args)
{
boolean x=bj(1,2);
System.out.println(x);
}
public static boolean bj(int a, int b)
{
return (a==b)? true:false; //三元运算符，直接使用return返回结果。
}
}
例3：因为比较运算符预算完成后就有真假值，直接返回即可，再次简化例2。只是针对于返回值为
True或
false时。
class function1
{
public static void main(String[] args)
{
boolean x=bj(1,2);
System.out.println(x);
}
public static boolean bj(int a, int b)
{
return (a==b);
}
}
例4、比较大小并返回一个大的值
class function1
{
public static void main(String[] args)
{
int x=bj(1,2);
System.out.println(x);
}
public static int bj(int a, int b)
{
return (a>b)? a:b ; //三元运算符，判断a和b那个值大，并返回大的值
}
}
12、函数重载
函数重载:
在同一个类中，允许存在一个以上的同名函数，只要他们的参数个数或者参数类型不同即可。
特点：
与返回值无关，只看参数列表
重载好处：
方便阅读，优化程序设计
什么时候用重载？
当定义的功能相同，但参数运行的未知内容不同，
那么这时就定义一个函数名称以表示其功能，方便阅读，
而通过参数列表的不同区分多个同名函数。
例1：传统函数调用，相同函数名称，参数不同。
class function1
{
public static void main(String[] args)
{
int x=
bj(1,2);
int y=
bj(1,2,3);
System.out.println("x"+"="+x+"\t"+"y"+"="+y);
}
public static int bj(int a, int b)
{
return (a+b);
}
public static int bj(int a, int b, int c)
{
return (a+b+c);
}
}
例2、根据例1进行优化，发现三个参数的函数包含了两个参数的功能。
class function1
{
public static void main(String[] args)
{
int x =add(1,2);
int y =add(1,2,3);
System.out.println(x);
System.out.println(y);
}
public static int add(int a, int b)
{
return a+b;
}
public static int add(int a, int b, int c)
{
return
add(a,b)+c;
}
}
例3：99乘法表分别调用cf和cf99；cf是个变化的乘法表，cf99是一个固定的乘法表。
class function1
{
public static void main(String[] args)
{
cf(4);
System.out.println("***********************************************************************");
cf99();
}
public static void cf (int num)
{ for (int x=1;x<=num ;x++ )
{
for (int y=1;y<=x ;y++ )
{
System.out.print(y+"*"+x+"="+y*x+"\t");//\t是制表符，对其表格
}
System.out.println();
}
}
public static void cf99 ()
{ for (int x=1;x<=9 ;x++ )
{
for (int y=1;y<=x ;y++ )
{
System.out.print(y+"*"+x+"="+y*x+"\t");//\t是制表符，对其表格
}
System.out.println();
}
}
}
结果：
D:\Skill\JAVA\2017>java function1
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*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*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
D:\Skill\JAVA\2017>
例4：乘法表重载，例3的乘法表代码出现了重复，优化如下cf99直接调用cf这个函数并传入9这个值
class function1
{
public static void main(String[] args)
{
cf(4);
System.out.println("***********************************************************************");
cf99();
}
public static void cf (int num)
{ for (int x=1;x<=num ;x++ )
{
for (int y=1;y<=x ;y++ )
{
System.out.print(y+"*"+x+"="+y*x+"\t");//\t是制表符，对其表格
}
System.out.println();
}
}
public static void cf99 ()
{
cf(9);
}
}
练习：根据例句，检查下面那些没有重载。
例： void show (int a, char b, double c){}
1.void show (int x, char y, double z){}
没有重载，因为参数类型和个数相同。
2.int show (int a, double c, char b){}
有重载，因为参数类型不同（double c）
3.void show (int a, double c, char b){}
有重载，因为参数类型不同（double c）
4.boolean show (int c, char b){}
有重载，因为参数个数不同
5.void show (double c){}
有重载，因为参数个数不同
6double show (int x,char y,double z){}
没有重载，这个函数不可以和给定函数存在同一个类中，因为当调用show函数时，不知道返回的时double还是没有返回值
