04.10_Java语言基础(循环结构注意事项之死循环)(掌握)
A:一定要注意控制条件语句控制的那个变量的问题，不要弄丢了，否则就容易死循环。
B:两种最简单的死循环格式
while(true){...}
public static void main(String[] args) {
//do while 他是先执行一次，循环体中代码，再去判断循环条件是否成立，如果成立，继续循环，不成立循环结束。
int i=1;
do{
System.out.println("Hello World!");
i++;
}while(true);
/*
(1):do...while循环至少执行一次循环体。
而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句。
while for
如果我知道循环次数，我一般选用for
如果我不知道该循环多少次，我一般选用 while ,但是我要知道循环的结束的条件。
*/
}
for(;;){...}
public static void main(String[] args) {
//循环输出hello Wrold
//对于重复的代码，我们应该考虑使用循环来做。
//for循环语句
// 1.int i=1; 循环的初始值
// 2.i>=1; 循环的条件，i>=1为true时，执行循环
// 3.{System.out.println("Hello World!");}循环体，你要重复执行的代码
// 4. i++ 控制条件的语句，每循环一次 i就自增1
// 5. for语句不断循环执行
public static void main(String[] args) {
for(int i=1;i>=1;i++){
// 3. 循环体
System.out.println("Hello World!");
}
}
04.11_Java语言基础(循环结构循环嵌套输出4行5列的星星)(掌握)
A:案例演示
需求：请输出一个4行5列的星星(*)图案。
如图：
*****
*****
*****
*****
注意：
System.out.println("*");和System.out.print("*");的区别
B:结论：
外循环控制行数，内循环控制列数
public static void main(String[] args){
/*
需求：请输出一个4行5列的星星(*)图案。
如图：
*****
*****
*****
*****
*/
//循环嵌套
for(int i=1;i<=4;i++){
for(int j=1;j<=5;j++){
System.out.print("*"); //打印不换行
}
System.out.println(); //只换行，不输出东西
}
/*
//循环嵌套。
总结：外层循环，控制行数，内层循环控制列数
*/
}
04.12_Java语言基础(循环结构循环嵌套输出正三角形)(掌握)
A:案例演示
需求：请输出下列的形状
*
**
***
****
*****
public static void main(String[] args) {
/*
A:案例演示
需求：请输出下列的形状
*
**
***
****
*****
外层循环控制行数，里层循环控制列数
*/
for(int i=1;i<=5;i++){
for(int j=1;j<=i;j++){
System.out.print("*");
}
System.out.println();
}
}
04.13_Java语言基础(循环结构九九乘法表)(掌握)
A:案例演示
需求：在控制台输出九九乘法表。
B:代码优化
注意：
'\x' x表示任意，这种做法叫转义字符。
'\t' tab键的位置
'\n' 换行
public static void main(String[] args) {
/*
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
*/
for(int i=1;i<=9;i++){
for(int j=1;j<=i;j++){
// \t 转义字符，空一个 table
System.out.print(j+"*"+i+"="+j*i+"\t"); //table
}
// \n 转义字符 换行
System.out.print("\n");
}
}
04.14_Java语言基础(控制跳转语句break语句)(掌握)
A:什么是控制跳转语句
前面我们已经说过了，Java中的goto是保留字，目前不能使用。虽然没有goto语句可以增强程序的安全性，但是也带来很多不便，
比如说，我想在某个循环执行到某一步的时候就结束，现在就做不了这件事情。
为了弥补这个缺陷，Java就提供了break，continue和return来实现控制语句的跳转和中断。
B:控制跳转语句的分类
break 中断
continue 继续
return 返回
break 中断
public static void main(String[] args) {
//输出1---10
for(int i=1;i<=10;i++){
System.out.println(i);
if(i==5){
break; //终止循环，用在循环当中，用来结束循环，离开循环场景没有意义了。
}
}
int j=0;
while(true){
if(++j>10){
break; //终止循环，用在循环当中，用来结束循环，离开循环场景没有意义了。
}
System.out.println(j);
}
}
continue 继续
public static void main(String[] args){
for(int i=1;i<=10;i++){
if(i==5){
continue; //用在循环场景中，跳出一次循环，继续下一次循环。
}
System.out.println(i);
}
System.out.println("------------------------");
for(int i=1;i<=10;i++){
if(i%2==1){
continue; //用在循环场景中，跳出一次循环，继续下一次循环。
}
System.out.println(i);
}
}
return 返回
public static void main(String[] args) {
//定义方法时，要考虑的东西：1.这个方法要不要设计形参，要，要几个，数据类型是什么？
//2. 这个方法，要不要设计返回值，返回值类型，是什么？
//求两个数的最大值，设计一个方法。
//B:案例演示: 需求：比较两个数是否相等
double max=getMax(20,6);
System.out.println("最大值是："+max);
Scanner sc=new Scanner(System.in);
System.out.println("请录入第一个整数");
int a=sc.nextInt();
System.out.println("请录入第二个整数");
int b=sc.nextInt();
boolean flag=isEquals(a,b);
System.out.println("是否相等："+flag);
}
//定义获取最大值的方法
public static double getMax(double a,double b){
double max=a>b?a:b;
return max;
}
//定义 比较两个数是否相等的方法 两个 int类型的参数，返回值 boolean
public static boolean isEquals(int x,int y){
boolean f=x==y?true:false;
return f;
}
C:break的使用场景
(1):在选择结构switch语句中
(2):在循环语句中
注意：离开使用场景的存在是没有意义的
public static void main(String[] args) {
{
int i=8;
switch (i)
{
case 1:System.out.println("是一月份");break;
case 2:System.out.println("是二月份");break;
case 3:System.out.println("是三月份");break;
case 4:System.out.println("是四月份");break;
case 5:System.out.println("是五月份");break;
case 6:System.out.println("是六月份");break;
case 7:System.out.println("是七月份");break;
case 8:System.out.println("是八月份");break;
case 9:System.out.println("是九月份");break;
case 10:System.out.println("是十月份");break;
case 11:System.out.println("是十一月份");break;
case 12:System.out.println("是十二月份");break;
default: System.out.println("fault"); //默认语句
}
}
}
D:作用
a:退出单层循环
b:退出多层循环(几乎不使用)
要想实现这个效果，就必须知道一个东西;带标签的语句；
格式：标签名：语句
public static void main(String[] args) {
//输出1---10
for (int i = 1; i <= 10; i++) {
System.out.println(i);
if (i == 5) {
break; //终止循环，用在循环当中，用来结束循环，离开循环场景没有意义了。
}
}
}
04.15_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基础班“
我想在控制台输出7次:“Java基础班“
我想在控制台输出13次:“Java基础班“
public static void main(String[] args){
for(int i=1;i<=10;i++){
if(i==5){
continue; //用在循环场景中，跳出一次循环，继续下一次循环。
}
System.out.println(i);
}
System.out.println("------------------------");
for(int i=1;i<=10;i++){
if(i%2==1){
continue; //用在循环场景中，跳出一次循环，继续下一次循环。
}
System.out.println(i);
}
}
04.16_Java语言基础(控制跳转语句return语句)(掌握)
A:return的作用
return 就是退出一个方法。
跳转到上层调用的方法。这个在方法的使用那里会在详细的讲解。
B:案例演示
return: 结束当前方法
break: 结束单层循环
continue: 结束当前循环，执行下一次循环
public static void main(String[] args) {
System.out.println("Hello World!");
//定义一个方法，来求两个数的和。
add();
//调用方法时，如果方法，有形参，你必须传入参数，你传入的参数类型和形参保持一致。要几个形参，就传几个
//我们调用方法时，传的参数，叫做实际参数，简称实参。实参可以是常量，可以是变量
add2(5,9);
add2(6,9);
int x=90;
int y=30;
add2(x,y); //120
//调用方法，如果方法有返回值，那么他返回什么类型就用什么类型来收
double r=add3(8,5);
System.out.println("和是："+r);
//输出调用，针对的有返回值的方法。可以打印出，返回的结果
//int x=add3(82,5)
System.out.println(add3(82,5));
}
// 无参无返回值的方法
public static void add(){
int a=20;
int b=25;
int sum=a+b;
System.out.println("和是："+sum);
return; //结束方法，方法的返回值如果是 void return可以省略不写
}
//定义在方法括号中的参数，我们叫做形式参数，简称形参，格式 数据类型 参数名 多个形参，逗号隔开
//形参的作用，使用来接收实参的。
public static void add2(int a,int b){
int sum=a+b;
System.out.println("和是："+sum);
}
//void 表示方法没有明确返回值类型，所以这个方法，不需要返回数据。
//如果你要方法，返回数据，就必须明确返回值类型,一旦我们明确了返回值类型，该方法必须由 return关键字，返回与明确的数据类型一致的结果。
// return 结束方法，并返回结果
public static double add3(int a,int b){
int sum=a+b;
//System.out.println("和是："+sum);
return sum;
}
04.17_Java语言基础(方法概述和格式说明)(理解)
A:为什么要有方法
假设有一个游戏程序，程序在运行过程中，要不断地发射炮弹(植物大战僵尸)。
发射炮弹的动作需要编写100行的代码，在每次实现发射炮弹的地方都需要重复地编写这100行代码，这样程序会变得很臃肿，可读性也非常差。
为了解决代码重复编写的问题，可以将发射炮弹的代码提取出来放在一个{}中，并为这段代码起个名字，
这样在每次发射炮弹的地方通过这个名字来调用发射炮弹的代码就可以了。上述过程中，所提取出来的代码可以被看作是程序中定义的一个方法，
程序在需要发射炮弹时调用该方法即可。
B:什么是方法
方法就是完成特定功能的代码块
在很多语言中都有函数的定义，但是在咱们JAVA语言中，我们将其称之为方法。
C:方法的格式
修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2 ....){
方法体;
return 返回值;
}
D:方法的格式详细说明
(1): 修饰符 比较多,后面会详细介绍。目前使用 public static
(2): 返回值类型 用于限定返回值的数据类型
(3): 方法名 就是一个名称，它的存在是为了方便我们调用方法
(4): 参数类型 限定调用方法时传入参数的数据类型
(5): 参数名 是一个变量，接收调用方法时传入的参数
这个参数其实有一个专业的名词,被称之为形式参数,它的作用是用来接收实际参数的.
(6): 方法体 完成功能的代码
(7): return 结束方法以及返回方法指定类型的值
(8): 返回值 就是功能的结果，由return带回，带回给调用者
04.18_Java语言基础(方法之求和案例及其调用)(掌握)
A:需求：求两个数据之和的案例
B:如何写一个方法
两个明确
(1):返回值类型 明确功能结果的数据类型
(2):参数列表 你要传递几个参数，以及每一个参数的数据类型
C:方法调用(有明确返回值的调用)
a:单独调用,一般来说没有意义，所以不推荐。
b:赋值调用,推荐方案。
c:输出调用,但是不够好。因为我们可能需要针对结果进行进一步的操作。
//主方法 由JVM调用
public static void main(String[] args) {
//方法：对一段功能逻辑代码的封装，以实现重复调用。
//方法的语法格式
/*
权限修饰符 状态修饰（可选）返回值类型 方法名(形参){
//方法体
}
*/
//2.方法定义在类中，二来，方法和方法是平级关系，不能嵌套定义
//3.方法不调用不执行，我们可以在主方法里面调用，我们定义的方法
//4. 通过方法名来调用方法
System.out.println("Hello World!");
//方法的调用，可以重复调用多次。
sendBullets();
sendBullets();
sendBullets();
}
//定义发射子弹的方法
public static void sendBullets(){
System.out.println("发射子弹");
}
04.19_Java语言基础(方法的调用图解)
A:画图演示:把刚才的的推荐调用方式画图解释
04.20_Java语言基础(方法的练习)(掌握)
A:案例演示: 需求：获取两个数中的较大值
B:案例演示: 需求：比较两个数是否相等
使用键盘录入改进
public static void main(String[] args) {
//定义方法时，要考虑的东西：1.这个方法要不要设计形参，要，要几个，数据类型是什么？
//2. 这个方法，要不要设计返回值，返回值类型，是什么？
//求两个数的最大值，设计一个方法。
//B:案例演示: 需求：比较两个数是否相等
double max=getMax(20,6);
System.out.println("最大值是："+max);
Scanner sc=new Scanner(System.in);
System.out.println("请录入第一个整数");
int a=sc.nextInt();
System.out.println("请录入第二个整数");
int b=sc.nextInt();
boolean flag=isEquals(a,b);
System.out.println("是否相等："+flag);
}
//定义获取最大值的方法
public static double getMax(double a,double b){
double max=a>b?a:b;
return max;
}
//定义 比较两个数是否相等的方法 两个 int类型的参数，返回值 boolean
public static boolean isEquals(int x,int y){
boolean f=x==y?true:false;
return f;
}
04.21_Java语言基础(方法的注意事项)(理解)
A: 方法不调用不执行
B: 方法与方法是平级关系，不能嵌套定义
C: 方法定义的时候参数之间用逗号隔开
D: 方法调用的时候不用在传递数据类型
E: 如果方法有明确的返回值，一定要由return带回一个值
04.22_Java语言基础(方法之输出星形及其调用)(掌握)
A:案例演示
需求：根据键盘录入的行数和列数，在控制台输出星形
B:方法调用：(没有明确返回值的调用)
单独调用
输出调用(错误)
赋值调用(错误)
public static void main(String[] args) {
/* A:案例演示
需求：根据键盘录入的行数和列数，在控制台输出星形
两个 int 类型的参数。行数，列数。
根据录入的行数，输出乘法表，比如录入6 那就是 6 6 乘法表
*/
Scanner sc=new Scanner(System.in);
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();
}
}
04.23_Java语言基础(方法的练习)(掌握)
A:案例演示: 需求：根据键盘录入的数据输出对应的乘法表
public static void main(String[] args) {
//根据录入的行数，输出乘法表，比如录入6 那就是 6 6 乘法表
Scanner sc=new Scanner(System.in);
System.out.println("请输入行数");
int num=sc.nextInt();
//调用方法
showMultiplication(num);
}
//定义方法
public static void showMultiplication(int x){
for(int i=1;i<=x;i++){
for(int j=1;j<=i;j++){
System.out.print(j+"*"+i+"="+j*i+"\t");
}
System.out.println();
}
}
04.24_Java语言基础(方法重载概述和基本使用)(掌握)
A:案例演示
求和案例
2个整数
3个整数
4个整数
public static void main(String[] args) {
System.out.println("Hello World!");
//定义一个方法，来求两个数的和。
add();
//调用方法时，如果方法，有形参，你必须传入参数，你传入的参数类型和形参保持一致。要几个形参，就传几个
//我们调用方法时，传的参数，叫做实际参数，简称实参。实参可以是常量，可以是变量
add2(5,9);
add2(6,9);
int x=90;
int y=30;
add2(x,y); //120
//调用方法，如果方法有返回值，那么他返回什么类型就用什么类型来收
double r=add3(8,5);
System.out.println("和是："+r);
//输出调用，针对的有返回值的方法。可以打印出，返回的结果
//int x=add3(82,5)
System.out.println(add3(82,5));
}
// 无参无返回值的方法
public static void add(){
int a=20;
int b=25;
int sum=a+b;
System.out.println("和是："+sum);
return; //结束方法，方法的返回值如果是 void return可以省略不写
}
//定义在方法括号中的参数，我们叫做形式参数，简称形参，格式 数据类型 参数名 多个形参，逗号隔开
//形参的作用，使用来接收实参的。
public static void add2(int a,int b){
int sum=a+b;
System.out.println("和是："+sum);
}
//void 表示方法没有明确返回值类型，所以这个方法，不需要返回数据。
//如果你要方法，返回数据，就必须明确返回值类型,一旦我们明确了返回值类型，该方法必须由 return关键字，返回与明确的数据类型一致的结果。
// return 结束方法，并返回结果
public static double add3(int a,int b){
int sum=a+b;
//System.out.println("和是："+sum);
return sum;
}
B:方法重载概述
在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同，与返回值无关。
参数列表不同：
A:参数个数不同
B:参数类型不同
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;
}
、
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
