黑马程序员.bobo.DAY.3

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){}没有,这个函数不能够和给定的函数同时在一个类中
*/

 

17.数组(概述内存结构)

17.1数组的定义

概念

同一种类型数据的集合.其实数组就是一个容器.

添加好友

小额赞助

微信	支付宝