黑马程序员.bobo.DAY.3

【推荐】2019 Java 开发者跳槽指南.pdf(吐血整理) >>>

Day-3

1.语句(while)

1.1循环结构

代表语句: while , do while, for

while语句格式:
while (条件表达式)
{
执行语句;
}

注:当在控制台进入无限循环,按ctrl+c即可停止

do while语句格式:

do
{
执行语句;
}while(条件表达式);

do while 特点是条件无论是否满足,循环体至少被执行一次.

2.语句(do while)

3.语句(for)

4.语句(for和while的区别)

for (int x = 0; x<3;x++)
{
System.out.println("x="+x);//3 6
}

//在这里离开了大括号,x不存在的,注意(条件表达式)
System.out.println("x====="+x);
int y = 0;
while(y<3)
{
System.out.println("y="+y);
y++;
}
System.out.println("y===="+y);
/*
1.变量有自己的作用域,对于for来讲:如果将用于控制循环的增量定义在for语句中,那么该变量只在for语句内有效,
2,for和while 可以进行呼唤,如果需要定义循环增量,用for更合适
总结:
什么时候试用循环结构?
当要对某些语句执行很多次时,就试用循环结构.
*/

5.语句(循环语句的其它特点)

class ForTest
{
public static void main(String[] arg)
{
int x = 1;
for(System.out.println("a");x<3;System.out.println("c"))
{
System.out.println("d");
x++;
}
//abcdc
}
}
///为了检测语句是怎么执行的,先来什么后做什么

6.语句(for语句练习)

/*1,获取1~10的和,并打印.
2,1~100之间的7的倍数的个数,并打印.*/
class ForTest2
{
public static void main(String[] arg)
{
//1,定义变量用于存储不断变化的和.
int sum = 0;
//2,定义变量,记录住不断变化的被加的数.
int x =1;
//3,定义循环,重复加法的过程,
while(x<=10)
{
sum = sum + x;
x++;
}
System.out.println("sum="+sum);
/*
循环注意:
一定要明确哪些语句需要参与循环,哪些不需要.
0+1
 1+2
  3+3
   6+4
   */
}
}

//用for来提现,
int sum = 0;
for(int x=0; x<=10;x++)
{
sum+=x;
}
System.outprintln("for sum = "+sum);

/*
2,1~100之间的7的倍数的个数,并打印.
思路:
1,先对1~100进行循环(遍历)通过循环的形式
2,在遍历的过程中,定义条件,只对7的倍数进行操作.
3,因为7的倍数不确定,只要符合条件,就通过一个变量来记录这个变量的次数
 
步骤:
1,定义循环语句,选择for语句.
2,在循环中定义判断.只要是7的倍数即可,试用if语句.条件: 7的倍数x%7=0
3,定义变量,该变量随着7的倍数的出现而自增.
*/
class ForTest3
{
public static void main(String[] arg)
{
int count = 0;
for(int x=1; x<=100;x++)
{
if(x%7==0)
//System.out.println("x= "+x);
count++;
}
System.out.println("count="+count);
/*
计数器思想.
通过一个变量记录住数据的状态变化.
也需要通过循环完成.
*/
}
}

7.语句(for嵌套)

//语句嵌套,其实就是语句中还有语句.
//循环嵌套.
class ForForDemo
{
public static void main(String[] arg)
{
for(int x = 0; x < 3; x++)
{
for(int y =0; y<4; y++)
{
System.out.print("*");
}
System.out.println();//只有一个功能就是换行.
}
System.out.println("---------------");
/*
*****
****
***
**
*
发现图形有很多行,每一个行有很多列,
要试用嵌套循环,原理:形象说法:大圈套小圈
*/
for(int x=0;x<5;x++)//x<5因为外循环控制行数,一共5行.
{
for(int y=x;y<5;y++)
{
System.out.print("*");
}
System.out.println();
}
}
}
/*
****
****
****
对于打印长方形:外循环控制的行数,内循环控制的是每一行的列数,也就是一行中元素的个数
 
 
 
*
**
***
****
*****
*/

8.语句(for嵌套练习)

class ForForTest
{
public static void main(String[] arg)
{
/*
*
**
***
****
*****
不是规律的规律
尖朝上,可以改变条件,让条件随着外循环变化.
尖朝下,可以初始化值,让初始化随着外循环变化.
*/
for (int x=0; x<=5;x++)
{
for(int y=0;y<=x; y++)
{
System.out.print("*");
}
System.out.println();
}
System.out.println("----------------");
/*
1
12
123
1234
12345
*/
for(int x=1;x<=5;x++)
{
for(int y=1;y<=x;y++)
{
System.out.print(y);
}
System.out.println();
}
}
}

9.语句(for嵌套--九九乘法表)

class ForForTest
{
public static void main(String[] arg)
{
九九乘法表
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
*/
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();
}
}
}

10.语句(break-continue)

10.1其它流程控制语句

break(跳出) continue(继续)

break语句: 应用范围:选择结构和循环结构

continue语句:应用于循环结构

注:

a,这两个语句离开应用范围,存在是没有意义的.

b,这个两个语句单独存在下面都不可以有语句,因为执行不到.

c,continue语句是结束本次循环继续下次循环.

d,标号的出现,可以让这两个语句作用指定的范围

class OtherDemo
{
public static void main(String[] arg)
{
//break
w:for(int x= 0; x<3;x++)
{
q:for(int y=0; y>4; y++)
{
System.out.println("x="+x);
break w;
}
}
//continue:只能作用于循环结构.特点:结束本次循环,继续下一次循环
for(int x=0;x<3;x++)
{
if(x%2==1)
continue;
System.out.println("x="+x);
}
w:for(int x= 0; x<3;x++)
{
q:for(int y=0; y>4; y++)
{
System.out.println("x="+x);
continue  w;
}
}
/*
记住:
1,break和continue语句作用的范围.
2,break和continue单独存在时,下面可以有任何语句,因为都执行不到
*/
}
}

11.语句(练习)

/*
----*
---* *
--* * *
-* * * *
* * * * *
*/
class ForForTest2
{
public static void main(String[] arg)
{
 for(int x=0;x<5;x++)
 {
for(int y=x+1;y<5;y++)
{
System.out.print("-");
}
for(int z=0 ;z<=x ;z++)
{
System.out.print("* ");
}
System.out.println();
 }
}
}

12.函数

12.1函数

函数的定义

函数的特点

函数的应用

函数的重载

12.1.1函数的定义

什么是函数?

函数就是定义在类中的具有特定功能的一段独立小程序.

函数也称为方法

函数的格式:

修饰符返回值类型函数名(参数类型形式参数1,参数类型形式参数2,...)

{

执行语句;

return返回值;

}

返回值类型:函数运行后的结果的数据类型.

参数类型:是形式参数的数据类型.

形式参数:是一个变量,用户存储调用函数时传递给函数的实际参数.

实际参数:传递给形式参数的具体数值.

return:用户结束函数.

返回值:该值会返回给调用者.

12.1.2函数的特点

定义函数可以将功能代码进行封装

便于对该功能进行复用

函数只有被调用才会执行

函数的出现提高了代码的复用性

对于函数没有具体返回值的情况,返回值类型用关键字void表示,那么该函数中的return语句如果在最后一行可以省略不写.

注意:

函数中只能调用函数,不可以在函数内部定义函数.

定义函数时,函数的结果应该返回给调用者,交由调用者处理

class FunctionDemo
{
public static void main(String[] arg)
{
/*
int x= 4;
System.out.println(x*3+5);
x = 6;
System.out.println(x*3+5);
*/
//int y = 4*3+5;
//int z = 6*3+5;
 getResult(4);
 //在这里函数中不能定义函数,只能调用函数
 
}
//发现以上的运算,因为获取不同数据的运算结果,代码出现了重复.
//为了提高代码的复用性,对代码进行抽取.
//将这个部分定义成一个独立的功能.方便与日后使用.
//Java中对功能的定义是通过函数的形式来体现的.
//需要定义功能,完成一个整数的*3+5的运算,并打印结果.
//1.先明确函数定义的格式.
//
/*
修饰符 返回值类型 函数名(参数类型 形式参数1,参数类型 形式参数2,...)
{
执行语句;
return返回值;
}
//当函数运算后,没有具体的返回值时,这是返回值类型用一个特殊的关键字来//标识该关键字就是void, void代表的是函数没有具体返回值的情况
//当函数的返回类型是void时,函数中的return语句可以省略不写
*/
public static void getResult(int num)
{
System.out.println(num * 3 + 5);
return;//可以省略
}
}

13.函数(应用)

13.1函数的应用

两个明确

明确要定义的功能最后的结果是什么?

明确在定义功能的过程中,是否需要未知内容参与预算

14.函数(练习)

class FunctionTest
{
public static void main(String[] arg)
{
draw(5,6);
printHr();
draw(7,9);
printHr();
print99();
}
/*
2,定义一个打印99惩罚表功能的函数
*/
public static void print99()
{
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();
}
}
/*
1.定义一个功能,用户打印矩形
思路:
1,确定结果:没有,因为直接打印,所以返回类型是void
2,有未知内容吗?有,两个,因为矩形的航和列不确定.
*/
public static void draw(int row,int col)
{
for(int x = 0; x<row;x++)
{
for(int y = 0; y<col; y++)
{
System.out.print("*");
}
System.out.println();
}
}
public static void printHr()
{
System.out.println("----");
}
}

15.函数(重载)

15.1函数的重载(overload)

重载的概念

在同一个类中,允许存在一个以上的同名函数,只要他们的参数个数或者参数类型不同即可.

重载的特点

与返回值类型无关,只看参数列表

重载的好处:

方便于阅读,优化了程序设计

重载示例:

//返回两个整数的和

int add(int x, int y){return x+y;}

//返回三个整数的和

int add(int x, int y, int z){return x+y+z;}

//返回两个小数的和

double add(double x,double y){return x+y;}

/*什么时候用重载

当定义的功能相同,但从那与的运算的未知内容不同.

那么,这时就定义一个函数名称以表示起功能,方便阅读,而通过参数列表的不同来区分多个同名函数.

class FunctionOverload
{
public static void main(String[] arg)
{
//add(4,5);
//add(4,5,6);
//System.out.println();
print99();
}
public static void print99(int num)
{
for(int x =1; x<=num; x++)
{
for(int y=1;y<=x; y++)
{
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
}
//打印99乘法表
public static void print99()
{
print99(9);
}
//定义一个加法运算,或许两个整数的和.
public static int add(int x, int y)
{
return x+y;
}
//定义一个加法,获取三个整数的和.
public static int add1(int x, int y, int z)
{
return add(x,y)+z;
}
}

16.函数(重载练习)

/*
void show(int a,char b,double c){}
 
a.
void show(int x,char y,double z){}//没有重载,因为和原函数一样.
 
b.
int show(int a, double c,char b){}//重载,因为参数类型不同.注意,重载和返回值类型不同.
 
c.
void show (int a,double c,char b){}//重载,因为参数类型不同.注意,重载和返回值类型不同.
d.
boolean show (int c,char b){}重载了,因为参数个数不同.
 
e.
void show (double c){}重载了,因为参数个数不同.
 
f.
double  show (int x,char y,double z){}没有,这个函数不可以和给定的函数同时在一个类中
*/