黑马程序员--java基础流程控制与方法（下）

——- android培训、java培训、期待与您交流！ ———-

while循环：

基本格式：

while(循环判断语句){

循环体

}

完整结构：

初始化语句

while(循环判断语句){

循环体

循环变化语句

}

for循环结构：
for(初始化语句;循环判断语句;循环变化语句){
循环体
}

for循环和while可以相互转换，也就是说，for循环能做的while都能做。

循环四大要素：
初始化语句
循环判断语句
循环变化语句
循环体

class WhileDemo {
public static void main(String[] args) {
//求1-10之间的和
int sum = 0;
/*
for (int a = 1;a<=10;a++) {
sum = sum + a;
}
System.out.println(sum);

初始化语句：int a = 1;
循环判断：a<=10;
循环变化语句：a++;
循环体：sum = sum + a;
*/

int a = 1;
while(a<=10){
sum = sum + a;
a++;
}
System.out.println(sum);

}
}

while循环和for循环的区别（不绝对）：

for循环：在循环之外不能访问循环变量。

while循环：可以在循环之外访问循环变量。

while循环更加适合不知道循环次数的循环。

class WhileFor {
public static void main(String[] args) {
int sum = 0;
/**/
int a = 1;
for (;a<=10;a++) {
sum = sum + a;
}
System.out.println(a);

/*
int a = 1;
while(a<=10){
sum = sum + a;
a++;
}
System.out.println(a);
*/
}
}

珠穆朗玛峰：

珠峰的高度：8848m

纸张的厚度：0.0002m

求，折叠多少次，纸张的厚度可以超过珠峰

分析：
定义珠峰的高度，和纸张的厚度
double zg = 8848;
double zh = 0.0002;

初始化语句：定义纸张折叠的次数。int count = 0;
循环判断：zh < zg   纸张的厚度小于珠峰的高度时继续循环
循环变化：count++;
循环体：zh = zh * 2;

class WhileTest {
public static void main(String[] args) {
//定义珠峰的高度，和纸张的厚度
double zg = 8848;
double zh = 0.0002;
//初始化语句：定义纸张折叠的次数
int count = 0;
while(zh < zg){
//循环体，每次让纸张的厚度乘以2
zh = zh * 2;
//循环变化，每折叠一次，让折叠次数+1
count++;
}
System.out.println(count);
}
}

do-While循环格式：

基本格式：

do{

循环体

}while(循环判断);

完整格式：

初始化语句;

do{

循环体

循环变化语句。

}while(循环判断);

class DoWhileDemo {
public static void main(String[] args) {
//定义的和
int sum = 0;
/*
for (int a = 1;a<=10;a++) {
sum = sum + a;
}

//初始化
int a = 1;
while(a<=10){ //a<=10是循环判断
//循环体
sum = sum + a;
//循环变化
a++;
}
*/

//do-while循环
//初始化
int a = 1;
do{
//循环体
sum = sum + a;
//循环变化
a++;
}while(a<=10); //a<=10是循环判断

System.out.println(sum);
}
}

do-while和While的区别

while循环：先判断，然后去执行。

do-while循环：先执行后判断。

for、while和do-while循环：
首选for，然后选择while，最后选择do-while。
如果已知循环次数的循环，首选for
如果不知道循环次数，首选while
如果要求先执行后判断，或者是要求至少执行一次，则选do-while

class DoWhileWhile {
public static void main(String[] args) {
//初始化语句
/*
int a = 0;
while(a > 0){
System.out.println("While循环");
//循环变化
a++;
}
*/

int a = 0;
do{
System.out.println("do-While循环");
a--;
}while(a > 0);
}
}

求1-100之间的和

class XunHuanTest {
public static void main(String[] args) {
/*
求和必须先有一个和
int sum = 0;

求1-100之间的和
初始化语句：int a = 1;
循环判断：a <= 100
循环变化：a++
循环体：sum = sum + a;
*/

//求和必须先有一个和
int sum = 0;
/*
//for循环
for (int a = 1;a <= 100;a++) {
sum = sum + a;
}

//while循环
int a = 1;
while(a <= 100){
sum = sum + a;
a++;
}
*/

//do-while循环
int a = 1;
do{
sum = sum + a;
a++;
}while(a <= 100);

System.out.println(sum);
}
}

去买衣服，总共有5家商店，每家商店有3件衣服。买衣服的时候，每一件都要去试一下。

现在有5家商店。

初始化语句：int a = 1;

循环判断：a<=5

循环变化：a++

循环体：进入商店，开始试衣服

每家有3件衣服。

初始化：int b = 1;

判断：b<=3

变化：b++

循环体：试衣服

需求增加：
假设，我在第三家商店，试第2件衣服的时候，发现，很满意，买了。后边的我们就不再试衣服了。

break只能结束当前循环，而且只能结束一层。

使用标签解决这种问题：
标签格式：
标签名:循环体    //就是给这个循环起了个别名
使用：
break 标签名;    //结束名字叫做"标签名"的循环
continue 标签名; //结束名字叫做"标签名"的本次循环

class BiaoQianDemo {
public static void main(String[] args) {
//控制5家商店
wc:for (int a = 1;a<=5;a++) {
System.out.println("进入第"+ a +"家商店，开始试衣服");
//控制三件衣服
for (int b = 1;b<=3;b++) {
System.out.println("正在试第"+ b +"件衣服");

//在这里判断如果是第三家商店，第二件衣服，我们就买了，然后停止。
if (a==3 && b==2) {
break wc;
}
}
}

//
System.out.println("一块去吃个饭吧，吃包子");
}
}

我要去餐厅吃“狮子头”，我觉的自己太饿了，所以觉得一口气能吃10个。

初始化语句：从第一个开始吃。所以int a = 1;

循环判断：a<=10

循环变化：a++

循环体：就是吃“狮子头”

吃到第5个的时候，我发现，吃不了了。所以我说，停下来，不吃了。

break：让循环停止执行。

break作用：
1.结束switch语句结构。
2.结束循环。

break注意事项：
a.break结束的是循环，必须放在switch或循环中。
b.break后边的代码不会被执行，也就是说，当程序遇到break时，直接停止语句结构。
c.同一级别break的后边不能直接写代码。

class BreakDemo {
public static void main(String[] args) {
for (int a = 1;a<=10;a++) {
System.out.println("吃“狮子头”,正在吃第"+a+"个");
if(a==5){
//System.out.println("吃不了了。停下来，不吃了");
break;
}

System.out.println("----------");
}
}
}

买苹果，买了10个，然后准备把他全部吃掉.

吃到第5个的时候，发现，这里边多了点蛋白质，这第5个苹果就不再吃了

continue:只能在循环中使用。
作用：结束本次循环，执行下次循环
当程序遇到continue时，本次循环结束，执行下次循环。
注意：
continue同一级别下，continue后不能直接写代码。

class ContinueDemo {
public static void main(String[] args) {
for (int a = 1;a<=10;a++) {
if (a == 5) {
//这个苹果不吃了
continue;
}
System.out.println("吃第"+a+"个苹果");

}
}
}

方法:

参数只和调用有关系。

有参方法：

调用:方法名(参数列表);

无参方法：

调用:方法名();

返回值只和方法调用之后的使用有关。和方法的调用没有任何关系。

有返回值方法：

“方法的调用”可以当作值来使用。

无返回值方法：

“方法的调用”不可以当作值来使用。

class MethodDemo {
public static void main(String[] args) {
/*
//有参方法：
ycwf(1);  //有参无返回值
ycyf(1);  //有参有返回值
//无参方法：
wcwf();   //无参无返回值
wcyf();   //无参有返回值
*/

//有返回值：
int a = wcyf();   //无参有返回值
int b = ycyf(1);  //有参有返回值
//无返回值：
System.out.println(wcwf());   //无参无返回值
System.out.println(ycwf(1));  //有参无返回值
}

//无参无返回值方法
public static void wcwf(){
System.out.println("无参无返回值");
}
//无参有返回值，返回值就是1
public static int wcyf(){
System.out.println("无参有返回值");
return 1;
}
//有参无返回值，参数就是int类型
public static void ycwf(int a){
System.out.println("有参无返回值");
}
//有参有返回值，参数int类型，返回值就1
public static int ycyf(int a){
System.out.println("有参有返回值");
return 1;
}
}

对于重复的内容，Java给我们提供了一项技术，让我们可以把重复性的内容抽取出来，当我们使用时，直接拿出来使用。

这种技术就是“方法(函数)”

方法(函数)：就是在类中，完成特定功能的代码块。方法其实就是一个功能或者一个动作。

当我们需要复用一段代码时，我们需要把这段代码提取出来做成一个模块，而这个模块就是方法。

方法的优点：
1.提高了代码的复用性。
2.提高了代码的可维护性。

方法意义：
对于现实生活中而言，方法其实就是一个功能或者一个动作。比如，"吃饭"、"睡觉","学习"这些都叫做方法。
我现在让你去"学习",这个就是我在调用你的“学习”方法。

方法的组成：
访问修饰符：限制我们方法的调用。  public static
返回值：方法执行之后都会有结果，方法给我们带回来的结果就是返回值。
返回值类型：给我们带回来的结果的数据类型
返回值：给我们带回来的结果
方法名：给方法起的名字。
参数：方法执行的要求。
参数类型：要求的类型。
参数名：参数的名字
方法体：方法具体的代码。

方法的分类：
对于方法而言，返回值和参数的不同，可以让方法分为4类。
没有参数，没有返回值的方法。//无参无返回值方法
没有参数，有返回值方法。    //无参有返回值
有参数，没有返回值方法      //有参无返回值
有参数，有返回值方法      //有参有返回值方法。

方法的格式：
访问修饰符 返回值类型 方法名(参数类型1 参数名,参数类型2 参数名2……){
//方法体
return 返回值。
}
注意：
1.这个方法格式，是完整的方法格式。
2.()里边的参数，有一个统一称呼叫做参数列表。
3.()里边的参数可以有多个，可以没有。
4.如果方法没有返回值，方法不允许出现“return 返回值”.

方法的特点：
1.方法与方法平级。不允许嵌套定义。
2.方法必须调用才会执行。

写一个方法，叫做定义一个方法，也就是说，写方法其实就是定义方法。

class FunctionDemo {
public static void main(String[] args) {
System.out.println("-------------------");
}

public static void sum(){
int a = 11;
int b = 6;
int sum = a + b;
System.out.println(sum);
}
}

无参无返回值方法

格式：

访问修饰符 void 方法名(){

//方法体

}

无返回值方法的返回值类型是void

求两个数的和。
public static void sum(){
//方法体
}

无参无返回值方法的调用：方法名();.

1.方法的调用其实就是让方法里边的代码去执行。
2.我们想让代码在那里运行，就让方法在哪里被调用。

class WcWfFunction {
//main方法是程序的开始。
public static void main(String[] args) {
//让方法在main方法中调用
sum();
}

//求两个数的和的方法。
public static void sum(){
int a = 5;
int b = 6;
int sum = a + b;
System.out.println(sum);
}
}

无参有返回值:

格式：

访问修饰符 返回值类型 方法名(){

//方法体

return 返回值。

}

求两个数的和。

无参有返回值方法的调用：方法名();

无参有返回值方法的调用“方法名()”，这个东西本身就可以看作是一个数值。这个值就是返回值。
既然是数值：
1.可以直接输出。
2.可以作为数值进行赋值。

总结：
无参方法的调用：方法名();

如果一个名字后边没有()，则一定是个变量，如果名字后有(),则这个名字一定是方法

class WcYfFunction {
public static void main(String[] args) {
//调用求和方法
//sum();
System.out.println(sum()); //sum();System.out.println(11);
//int c = sum();
//System.out.println(c);
}

public static int sum(){
int a = 5;
int b = 6;
int sum = a + b;
System.out.println("----");
return sum;
}

public static String test(){
String s = "我爱中国";
return "我爱Java";
}

//返回一个1
public static int re1(){
return 1;
}
}

有参数，有返回值方法

格式：

访问修饰符 返回值类型 方法名(参数类型1 参数名,参数类型2 参数名2……){

//方法体

return 返回值。

}

调用：方法名(参数列表);

有返回值方法"方法的调用"这个东西就可以当作是一个值来使用，这个值就是返回值。

方法的调用：只和参数有关系。
如果是无参方法调用：方法名();
有参方法调用：方法名(参数列表);

class YcYfFunction {
public static void main(String[] args) {
int a = 5;
int b = 6;
sum(a,b);
//System.out.println(sum);
}

//求两个数的和，这两个数，要求我们给，返回计算之后的和
public static int sum(int a,int b){
System.out.println(a);
System.out.println(b);
int sum = a + b;
return sum;
}
}

有参数，没有返回值方法 :

访问修饰符 void 方法名(参数类型1 参数名,参数类型2 参数名2……){

//方法体

}

调用：方法名(参数列表);

class YcWfFunction {
public static void main(String[] args) {
String s = "HelloWorld";
say(s);
//调用sum方法
int a = 5;
int b = 6;
sum(a,b);
}

//输出
public static void say(String str){
System.out.println(str);
}

//求和方法，求两个数的和，当然这里边什么都没有
public static void sum(int a,int b){

}
}

return和break都能立即结束循环。

break结束的只是循环。

return：结束的是方法。

class ReturnDemo {
public static void main(String[] args) {
for (int a = 1;a<=10;a++) {
System.out.println("吃“狮子头”,正在吃第"+a+"个");
if(a==5){
return;
//break;
}
}

System.out.println("学习《Java》");
System.out.println("学习《Java》");
System.out.println("学习《Java》");
System.out.println("学习《Java》");

总结：

方法分类：

有参和无参方法：

参数之和方法的调用有关系

。

有参方法的调用

：方法名(参数列表);

无参方法的调用

：方法名();

有返回值方法和无返回值方法

有无返回值只和方法的使用

有关，和方法调用无关。

有返回值方法：”

方法的调用”可以直接当作值来使用。赋值和打印

都可以。

无返回值方法：”

方法的调用”不能当作值来使用，他只是方法中代

码的运行。

方法的特点：

1.方法与方法平级，不能嵌套定义。

2.方法不调用不执行。

3.方法必须先定义然后才能调用。

4.一个类中不能出现两个完全相同的方

法。

顺序结构：语句顺序执行

从main方法开始，自上而下，从左到右，有（）先执行（）里边的。

条件结构：语句在满足条件下执行

if,

格式：

if(布尔表达式){

当布尔表达式结果为true时，执行｛｝中的内容

}

if-else,

格式：

if(布尔表达式){

当布尔表达式结果为true时，执行｛｝中的内容

}else{

当布尔表达式结果为false时，执行else模块中的内容。

}

if-else-if

格式：

if(条件1){

当条件1成立时，执行这里。

}else if(条件2){

当条件1不成立，条件2成立，则执行这里。

}else if(条件3){

当条件1不成立，条件2也不成立，条件3成立，则执行这里

}else{

上述条件都不成立时，执行这里。

}

选择结构：switch

格式：

swicth(表达式或者变量){

case 值1:

语句1; //当表达式或者变量的值是“值1”时，执行这里。

break;

case 值2:

语句2; //当表达式或者变量的值是“值2”时，执行这里。

break;

……

default: //代表否则，当表达式或者变量

语句; //当表达式或者变量的值和以上case都不匹配时，执行这里。

break;

}

注意事项：

1.case和default没有顺序要求。

2.case的值不允许重复

3.case的值只能是常量，

4.表达式或者变量的值的数据类型只能是“byte、short、int、char、String(JDK1.7之后可以使用)”

5.default可以省略，但不建议。

6.break可以省略，但是不允许省略，如果省略则会出现穿透效果。

循环结构：语句在满足条件下循环执行多次

循环四要素：

初始化语句：一般用来定义循环变量。

循环判断语句：用来判断循环是否继续执行下去。

循环变化语句：用来控制循环变量的变化。循环体执行之后执行。

循环体：被循环的内容。

for循环

格式：

for(初始化语句;循环判断语句;循环变化语句){

循环体

}

执行流程：

1.先执行初始化语句。

2.然后执行循环判断语句。

如果结果为true，则执行下一步，执行循环体。

如果结果为false，则循环结束。

3.执行循环体

4.执行循环变化语句

5.执行循环判断语句，其实就是回到了第2步。

while循环：
基本格式：
while(判断语句){
循环体
}
完整格式：
初始化语句;
while(循环判断语句){
循环体
循环变化语句
}

do-while循环：
基本格式：
do{
循环体
}while(循环判断语句);
完整格式：
初始化语句;
do{
循环体
循环变化语句;
}while(循环判断语句);

优先选择for，然后while，最后do-while
如果知道循环次数的循环，选择for
如果不知道循环次数的循环，选择while
如果需要先执行后判断或者需要至少执行一次，则选择do-while

跳转语句

break：结束整个循环。

continue：结束本次循环，进行下次循环。

return：结束整个方法。

——- android培训、java培训、期待与您交流！ ———-