java基础DAY 03

简介: java基础
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。只是针对于返回值为 Truefalse时。
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还是没有返回值

目录
相关文章
|
2月前
|
存储 缓存 Java
最新Java基础系列课程--Day10-IO流文件处理
最新Java基础系列课程--Day10-IO流文件处理
|
2月前
|
存储 Java
最新Java基础系列课程--Day10-IO流文件处理(一)
最新Java基础系列课程--Day10-IO流文件处理
|
1月前
|
Java
【Java基础】输入输出流(IO流)
Java基础、输入输出流、IO流、流的概念、输入输出流的类层次结构图、使用 InputStream 和 OutputStream流类、使用 Reader 和 Writer 流类
107 2
|
28天前
|
安全 Java
|
1月前
|
搜索推荐 算法 Java
【Java基础】 几种简单的算法排序
几种简单的JAVA算法排序
34 4
|
1月前
|
存储 缓存 Java
Java基础17-读懂Java IO流和常见面试题(二)
Java基础17-读懂Java IO流和常见面试题(二)
28 0
|
1月前
|
存储 Java Unix
Java基础17-读懂Java IO流和常见面试题(一)
Java基础16-读懂Java IO流和常见面试题(一)
32 0
|
2月前
|
Java
Java基础教程(12)-Java中的IO流
【4月更文挑战第12天】Java IO涉及输入输出,包括从外部读取数据到内存(如文件、网络)和从内存输出到外部。流是信息传输的抽象,分为字节流和字符流。字节流处理二进制数据,如InputStream和OutputStream,而字符流处理Unicode字符,如Reader和Writer。File对象用于文件和目录操作,Path对象简化了路径处理。ZipInputStream和ZipOutputStream则用于读写zip文件。
|
2月前
|
搜索推荐 Java
Java基础(快速排序算法)
Java基础(快速排序算法)
34 4
|
2月前
|
搜索推荐 算法 Java
Java基础(冒泡排序算法)
Java基础(冒泡排序算法)
26 3