2021-10-24

最新推荐文章于 2024-01-30 18:16:20 发布

簽約小芐﹃跕

最新推荐文章于 2024-01-30 18:16:20 发布

阅读量242

点赞数

文章标签： java 后端

本文链接：https://blog.csdn.net/qq_45063362/article/details/120937341

版权

04.01—Java（循环结构概述和for语句的格式及其使用）

案例：在控制台输出10次"hello world";

A:什么是循环结构
循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。
B:循环结构的分类
for循环
while循环
C.循环结构for语句格式：
for（初始化表达式语句；判断条件语句；控制条件语句）{
循环语句体；
}
D.执行流程：
a.执行初始化表达式语句
b.执行判断条件语句，看其返回值是true还是false
如果是true，继续执行
如果是false，结束循环
c.执行循环体语句；
d.执行控制条件语句
e.回到B继续
E.注意事项：
初始化表达式语句只执行一次
把刚才需求使用for循环进行改进

04.02—java（循环结构for语句的练习之获取数据）

A.案例演示
需求：请在控制台输出数据1-10；
需求：请在控制台输出数据10-1；

										class ForDemo1{
											public static void main(String [] args){
												for(int x=1;x<=10;x++){
												System.out.println(x);
												}
												System.out.println("****************************");
												for(int x=10;x>=0;x--){
												System.out.println(x);
												}
											}
										}

B.注意事项
a:判断条件语句无论简单还是复杂结果是boolean类型。
b:循环体语句如果是一条语句，大括号可以省略；如果是多条语句，大括号不能省略。建议永远不要省略。
c:一般来说：有左大括号就没有分号，有分号就没有左大括号
C.练习，求出1-10之间;的数据和
class ForDmeo2{
public static void main(String[] args){
int sum=0;
for(int i=1;i<10;i++){
sum+=i;
}
System.out.println(i);
}
}
练习2.求出1-100之间的奇数和，偶数和

												class ForDemo3{
							public static void main(String[] args){
						
								int  odd=0;
								int  even=0;
						
							for(int i=1;i<=100;i++){
								if(i%2==0){
								even+=i;
								}else if{
								
								odd+=i;
								}
							}
							System.out.println("奇数和是："+odd);
							System.out.println("偶数和是："+even);
							}
						}
练习3.在控制台输出是所有的水仙花数
										class ForDemo4
					{
						public static void main(String[] args) 
						{
							int count=0;
							for(int i=1;i<=999;i++){
							int ge=i/1%10;
							int shi=i/10%10;
							int bai=i/100%10;
							int flowerNum=ge*ge*ge+shi*shi*shi+bai*bai*bai;
							if (flowerNum==i){
							System.out.println("水仙花数是："+i);
							count++;
							}
							}	
							System.out.println("水仙花数有："+count+"个");							
						}
					}

04.03—java（循环结构while语句的格式和基本使用）

A.循环结构while语句的格式：
while循环的基本格式：
while(判断语句){
循环语句体；
}
完整格式：
初始化条件语句;
while(判断条件语句) {
循环体语句;
控制条件语句;
}
B.执行流程：
a.执行初始化条件语句；
b.执行判断条件语句，看起返回值是true还是false
如果是true继续执行
如果是false结束循环
c.执行循环体语句；
d.执行控制条件语句；
e.回到b继续。
C.案例演示
1.在控制台输出10次"hello world";
2.在控制台输出数据1-10；
例1：
class WhileDemo{
public static void main(String [] args){
int i=1;
while(i<=10){
System.out.println(“hello worid”);
i++;
}
}
}
例2：
class WhileDemo2{
public static void main(String [] args){
int i=1;
while(i<=10){
System.out.println(i);
i++;
}
}
}
例3：求1-100的和
class WhileDemo3
{
public static void main(String[] args)
{
int sum=0;
int i=1;
while(i<=100){
i++;
sum+=i
}

							System.out.println("1-100的总和是："+sum);
}

}
例4.统计"水仙花数"共有多少个
class WhileDemo4
{
public static void main(String[] args)
{
int count=0;
int i=100;
while(i<=1000){
int ge=i/1%10;
int shi=i/10%10;
int bai=i/100%10;
int flowerNumer=gegege+shishishi+baibaibai;
if(flowerNumer==i){
System.out.println(“水仙花数是：”+i)
count++;

}
i++;
}
System.out.println(“水仙花数有：”+count);
}
}

04.03—java（循环结构do…while语句的格式和基本使用）

A.循环结构do...while语句格式：
		do{
				循环体语句
			}while(判断条件语句);
	完整格式：
			初始化条件语句;
			do{
					循环体语句；
					控制条件语句；
			}while(判断条件语句)；
	B.执行流程
		a.执行初始化条件语句；
		b.执行循环体语句；
		c.执行控制条件语句；
		d.执行判断条件语句，看其返回值是true，还是false
											如果是true，就继续执行；
											如果是false，就结束循环。
		e.回到b继续执行。
	C.案例演示
				需求1：在控制台输出10次"hello world"
				需求2：请在控制台输出数据1-10
				例1.
	class ForDemo7

{
public static void main(String[] args)
{
int i=1;
do{
System.out.println(“hello world”);
i++;
}while(i<=10);

}.
例2.
class ForDemo8
{
public static void main(String[] args)
{
int i=1;
do{
System.out.println(i);
i++;
}while(i<=10);

}

04.04—java（循环结构三种循环语句的区别）

三种循环语句的区别：
		（1）：do...while循环至少执行一次循环体。
					而for，while循环必须先判断条件是否成立，然后决定是否执行循环体语句。
		（2）：A.如果你想在循环结束后，继续使用控制条件的那个变量，用while循环，否则用for循环。
					不知道用for循环，因为变量及早的冲内存中消失，可以提高内存的使用效率。
					B.建议优先考虑for循环，然后是while循环，最后是do...while循环。

04.05—java（循环结构注意事项之死循环）

A.一定要注意控制条件语句控制的那个变量的问题，不要丢弃了，否则容易死循环。
B.俩种简单的的死循环格式
		while(true){...}
		for(;;){...}

04.06—java(循环结构循环嵌套输出4行5列的星星)

A.案例演示
请输入一个4行5列的星星（）图案。
class test1{
public static void main(String[] args)
{
for(int i=1;i<=4;i++){
for(int j=1;j<=5;j++){
System.out.print("");
}
System.out.println();//只换行，不输出东西
}
}
} //外循环控制行数，内循环控制列数

04.07—java（循环结构循环嵌套输出正三角形）

A:案例演示
需求：请输出下列的形状
*
**
***
****
*****
如下：
class test2
{
public static void main(String[] args)
{
for(int i=1;i<=5;i++){
for(int j=1;j<=i;j++){
System.out.print("*");
}
System.out.println();
}
}
}

04.08—java（循环结构九九乘法表）

class test3
{
public static void main(String[] args)
{
for(int i=1;i<=9;i++){
for(int j=1;j<=i;j++){
System.out.print(j+""+i+"="+ji+" ");
}
System.out.println();
}
}
} // \t:一个空格 \n:换行

04.10—java(控制跳转语句break语句)

A:什么是控制跳转语句
前面我们已经说过了，Java中的goto是保留字，目前不能使用。虽然没有goto语句可以增强程序的安全性，但是也带来很多不便，
比如说，我想在某个循环执行到某一步的时候就结束，现在就做不了这件事情。
为了弥补这个缺陷，Java就提供了break，continue和return来实现控制语句的跳转和中断。
B:控制跳转语句的分类
break 中断
continue 继续
return 返回
C:break的使用场景
(1):在选择结构switch语句中
(2):在循环语句中
注意：离开使用场景的存在是没有意义的
D:作用
a:退出单层循环
b:退出多层循环(几乎不使用)
要想实现这个效果，就必须知道一个东西;带标签的语句；
格式：标签名：语句

04.11—java(控制跳转语句continue语句）

A:continue的使用场景
(1):在循环语句中
(2):离开使用场景的存在是没有意义的
B:作用
a:跳出一次循环，执行下一步操作
C:练习题
for(int x=1; x<=10; x++) {
if(x%3==0) {
//在此处填写代码
}
System.out.println(“Java基础班”);
}

//我想在控制台输出2次:“Java基础班“
class  demo1

{
public static void main(String[] args)
{
for(int i=1;i<=10;i++){
if(i%3==0){
break;
}
System.out.println(“java基础班”);
}

}

//我想在控制台输出7次:“Java基础班“

class pll
{
public static void main(String[] args)
{
for(int i=1;i<=10;i++){
if(i%3==0){
continue;
}
System.out.println(“java基础班”);
}

}

//我想在控制台输出13次:“Java基础班

class pll
{
public static void main(String[] args)
{
for(int i=1;i<=10;i++){
if(i%3==0){
System.out.println(“java基础班”);
}
System.out.println(“java基础班”);
}

}

04.12—java(控制跳转语句return语句)

A:return的作用
return 就是退出一个方法。
跳转到上层调用的方法。这个在方法的使用那里会在详细的讲解。
B:案例演示
return: 结束当前方法
break: 结束单层循环
continue: 结束当前循环，执行下一次循环

04.13—java(方法概述和格式说明)

A:为什么要有方法
假设有一个游戏程序，程序在运行过程中，要不断地发射炮弹(植物大战僵尸)。
发射炮弹的动作需要编写100行的代码，在每次实现发射炮弹的地方都需要重复地编写这100行代码，这样程序会变得很臃肿，可读性也非常差。
为了解决代码重复编写的问题，可以将发射炮弹的代码提取出来放在一个{}中，并为这段代码起个名字，
这样在每次发射炮弹的地方通过这个名字来调用发射炮弹的代码就可以了。上述过程中，所提取出来的代码可以被看作是程序中定义的一个方法，
程序在需要发射炮弹时调用该方法即可。
B:什么是方法
方法就是完成特定功能的代码块
在很多语言中都有函数的定义，但是在咱们JAVA语言中，我们将其称之为方法。
C:方法的格式
修饰符返回值类型方法名(参数类型参数名1，参数类型参数名2 …){
方法体;
return 返回值;
}
D:方法的格式详细说明
(1): 修饰符比较多,后面会详细介绍。目前使用 public static
(2): 返回值类型用于限定返回值的数据类型
(3): 方法名就是一个名称，它的存在是为了方便我们调用方法
(4): 参数类型限定调用方法时传入参数的数据类型
(5): 参数名是一个变量，接收调用方法时传入的参数
这个参数其实有一个专业的名词,被称之为形式参数,它的作用是用来接收实际参数的.
(6): 方法体完成功能的代码
(7): return 结束方法以及返回方法指定类型的值
(8): 返回值就是功能的结果，由return带回，带回给调用者

04.14—java(方法之求和案例及其调用)

A:i练习：求两个数据之和的案例
int num=add(15,56);
System.out.printil(num);
public static int add(int a,int b){
//System.out.println(“两个int类型的参数方法”);
return a+b;
}
ii.练习：获取两个数中的较大值
int max=biJiao(56,98);
System.out.printil(max);
poblic static int biJiao(int x,int y){
int t=x>y?x:y;
return t;
}
iii.练习：比较两个数是否相等
double a=num(20,50);
System.out.printil(a);
public static boolean num(double x,double y){
boolean t=x==y?true:false;
return t;
}
B:如何写一个方法
两个明确
(1):返回值类型明确功能结果的数据类型
(2):参数列表你要传递几个参数，以及每一个参数的数据类型
C:方法调用(有明确返回值的调用)
a:单独调用,一般来说没有意义，所以不推荐。
b:赋值调用,推荐方案。
c:输出调用,但是不够好。因为我们可能需要针对结果进行进一步的操作。

04.15—java(方法的注意事项)

A: 方法不调用不执行
B: 方法与方法是平级关系，不能嵌套定义
C: 方法定义的时候参数之间用逗号隔开
D: 方法调用的时候不用在传递数据类型
E: 如果方法有明确的返回值，一定要由return带回一个值

04.16—java(方法之输出星形及其调用)

A:案例演示
需求：根据键盘录入的行数和列数，在控制台输出星形
import java.util.Scanner;
class MyTest {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in); //util方法的调用
System.out.println(“请输入行数”);
int x=sc.nextInt();
System.out.println(“请输入列数”);
int y=sc.nextInt();
showStar(x,y);
}
public static void showStar(int hang,int lie){
for(int i=1;i<=hang;i++){
for(int j=1;j<=lie;j++){
System.out.print("*");
}
System.out.println();
}
}
}

B:方法调用：(没有明确返回值的调用)
单独调用
输出调用(错误)
赋值调用(错误)

04.17—java(方法重载概述和基本使用)

A:案例演示
求和案例
2个整数
3个整数
4个整数
class MyTest1{
public static void main(String[] args) {
//求两个数之和
//求三个数之和
//求4个数之和
double sum1=add(1,2.0);
int sum2=add(1,2,3);
int sum3=add(1,2,3,4);
System.out.println(“和是：”+sum1);
System.out.println(“和是：”+sum2);
System.out.println(“和是：”+sum3);
}
/*
方法重载：允许一个类中，可以定义多个同名方法，只要他们的形参个数，或形参类型不一样即可，不要拿返回值类型来区分。
*/
public static int add(int a,int b){
System.out.println(“两个int类型的参数方法”);
return a+b;
}
public static double add(int a,double b){
System.out.println(“一个int类型的一个double参数方法”);
return a+b;
}
public static int add(int a,int b,int c){
return a+b+c;
}
public static int add(int a,int b,int c,int d){
return a+b+c+d;
}
}
B:方法重载概述
在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同，与返回值无关。
参数列表不同：
A:参数个数不同
B:参数类型不同