JAVASE-04：循环、方法和数组

最新推荐文章于 2024-03-08 22:50:01 发布

绝世球王秃光光

最新推荐文章于 2024-03-08 22:50:01 发布

阅读量258

点赞数

分类专栏： JavaSE 文章标签： java

本文链接：https://blog.csdn.net/hannen/article/details/107379940

版权

JavaSE 专栏收录该内容

27 篇文章 0 订阅

订阅专栏

JAVASE-04：循环、方法和数组

1.循环（续）

1.1循环结构while语句的格式和基本使用

int i=1（初始化条件语句）;
while（判断条件语句）{
	循环体语句；
	i++（控制语句）;
}

执行流程：
a:执行初始化条件语句；
b:执行判断条件语句,看其返回值是true还是false，如果是true就继续执行，如果是false就结束循环；
c:执行循环体语句；
d:执行控制条件语句；
e:回到b继续。

与for相比，变量在循环语句之外，可以拿到变量的值
for循环也可以通过下面的方法，将变量写在循环语句之外来获取变量的值：

int j;
for(j=1;j<10;j++){}

1.2循环结构do…while语句的格式和基本使用

初始化条件语句;
do {
	循环体语句;
	控制条件语句;
}while(判断条件语句);

执行流程：先执行一次循环体中的代码，然后再去判断条件是否成立，如果成立继续循环，不成立循环结束，至少会循环一次。

for循环和while循环的选择：如果知道循环次数，可以选择for循环，不知道循环次数可以选择while循环，但是得知道循环结束的条件。

1.3使用循环的技巧

死循环的写法：循环没有结束条件，不停的循环

while(true){…}
for(；；){…}
在{}中加条件if判断然后break

循环嵌套

四行五列星星图：

for(int i=1;i<=4;i++){  //外层循环控制行数
	for(int j=1;j<=5;j++){ //内层循环控制列数
		System.out.print("*"); //删掉ln
}
	System.out.println(); //空换行
}

三角形星星：

for(int i=1;i<=5;i++){  //外层循环控制行数
	for(int j=1;==j<=i==;j++){ //内层循环控制列数
		System.out.print("*"); //删掉ln   println删除ln，在同一行打印，ln可以换行
}
	System.out.println(); //空换行
}

注：
a. 快速生成循环语句 100.fori ：for(i=0;i<100;i++){}
100.forr 反向遍历
b. 快速补全： new Scanner(System.in).var
c. \n ：转意字符表示换行

练习：打印99乘法表（\t空格符号）

package org.westos.XunHuan;
public class XHWhile {
    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 + "=" + j * i+"/t");
            }
            System.out.println();
        }
    }
}

控制循环的关键字：

原定计划循环10次，但是在第五次时想结束循环–

break; //在switch或循环语句中用，离开这两个场景没有意义。

原定计划循环10次，但是想跳过第五次循环–

continue; //略过一次循环，继续下次循环，用在循环语句中，离开循环没有意义。

2.方法

为什么要有方法？
假设有一个游戏程序，程序在运行过程中，要不断地发射炮弹(植物大战僵尸)。发射炮弹的动作需要编写100行的代码，在每次实现发射炮弹的地方都需要重复地编写这100行代码，这样程序会变得很臃肿，可读性也非常差。为了解决代码重复编写的问题，可以将发射炮弹的代码提取出来放在一个{}中，并为这段代码起个名字，这样在每次发射炮弹的地方通过这个名字来调用发射炮弹的代码就可以了。上述过程中，所提取出来的代码可以被看作是程序中定义的一个方法，程序在需要发射炮弹时调用该方法即可。

什么是方法？
完成特定功能的代码块，功能逻辑用方法封装起来（同其他语言中函数）来实现重复的调用。

语法格式：

权限修饰符 状态修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2 ...){
	方法体;
	return 返回值;
}

方法的格式详细说明	作用
修饰符	比较多,后面会详细介绍，目前使用 public static
返回值类型	用于限定返回值的数据类型
方法名	就是一个名称，它的存在是为了方便我们调用方法
参数类型	限定调用方法时传入参数的数据类型
参数名	是一个变量，接收调用方法时传入的参数（这个参数其实有一个专业的名词,被称之为形式参数,它的作用是用来接收实际参数的.）
方法体	完成功能的代码
return	结束方法以及返回方法指定类型的值
返回值	就是功能的结果，由return带回，带回给调用者

注：

1.方法定义在类（class）中；

public class MyTest{
public static void main(String[] args){ //主方法由虚拟机JVM来调用
	send(); //在主方法中调用我们定义的方法，可以重复调用
}

public static void send(){
	//方法体：实现某些功能的代码
	//定义在括号()中的参数叫做形式参数，作用就是接收，调用方法时的实际参数
}

}

2.方法和方法是平级关系，不能嵌套定义；

3.自己写的方法不调用就不执行。

public static void main(String[] args){
	add(x:20,y:90);   //在调用带有参数的方法时，必须传入跟形参类型，形参个数一致的实际参数，实参可以传常量，也可以传变量
	add(x:10,y:20);
    
	int a=21;
	int b=69;
	add(a,b);
}

public static void add(intx,inty){
	int sum=x+y;
	System.out.println(sum);
}

4.形参是int类型，传参时，可以传入byte、short、int；

5.方法可以设计返回值类型：public static void中void的意思是该方法没有明确返回值类型，一旦我们明确了方法返回值类型，那么这个方法必须使用return关键字，返回一个与明确类型一致的值；

public static void main(String[] args){

}

public static int add(intx,inty){
	int sum=x+y;
	System.out.println(sum);
	return sum;
}

6.当我们调用这个方法时，如果这个方法有返回值，我们就可以接收这个返回值

方法可以分为：

a.无参数无返回值的方法

b.有参数无返回值的方法

c.有参数有返回值的方法

d.无参数有返回值的方法

设计方法时考虑：

a.要不要参数要几个参数参数类型是什么;（()小括号里填东西吗？填几个？类型？）
b.要不要返回值返回值类型是什么;（void需不需要改？）

public static int add(intx,inty){
	return x+y; //return意思是结束方法，返回结果
}

c.当方法的返回值类型时void时，那么return意思为结束方法，所以可以不写

例1.获取两个数最大值，设计成一个方法：
两个数–两个参数类型double ，最大值–一个返回值 double

package org.westos.FangFa;
import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数：");
        double a = sc.nextDouble();
        System.out.println("请再输入一个数：");
        double b = sc.nextDouble();

		double max = getMax(a,b);
        System.out.println("最大值是："+max);
    }

	public static double getMax(double a,double b){
		double max=a>b?a:b;
		return max;
	}
}

例2.判断两个数是否相等：
两个数–要两个参数int类型，是否相等–要返回值char

package org.westos.FangFa;
import java.util.Scanner;
public class Test1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数：");
        double v = sc.nextDouble();
        System.out.println("请再输入一个数：");
        double w = sc.nextDouble();
        
        char n = CompNum(v,w);
        System.out.println("这两个数相等吗："+n);
    }
    public static char CompNum(double v, double w) {
        char n = v == w ? '是' : '否';
        return n;
    }
}

例3.根据输入的数打印相应的乘法表：需要一个参数来控制循环，返回值不要

package org.westos.FangFa;
import java.util.Scanner;
public class Test2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你想打印的乘法表数：");
        
        int k = sc.nextInt();
        Biao(k);
    }
    
    public static void Biao(int k) {
        for (int i = 1; i <= k; i++) {
            for (int j = 1; j <= i; j++) { //内层循环控制列数
                System.out.print(j + "*" + i + "=" + j * i + "\t");
            }
            System.out.println();
        }
    }
}

例4.根据输入的行数列数打印星星：输入的行数列数–需要两个参数，不要返回值

package org.westos.FangFa;
import java.util.Scanner;
public class Test3 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你想打印的星星行数：");
        int k = sc.nextInt();
        System.out.println("请输入你想打印的星星列数：");
        int t = sc.nextInt();
        XingXing(k, t);
    }

    public static void XingXing(int k, int t) {
        for (int i = 1; i <= k; i++) {
            for (int j = 1; j <= t; j++) { //内层循环控制列数
                System.out.print("*");
            }
            System.out.println();
        }
    }
    
}

在里层循环结束外层循环 – 给循环起名字别名，去结束

在这里插入图片描述

方法重载：允许一个类中，可以定义多个同名方法，只要他们的参数个数或参数类型不同即可，调用时会去自动匹配哪个方法适合，跟返回值类型无关

例：求多个数相加

3.数组

数组可以看做一个容器可以用来存储多个同一种数据类型的元素。数组既可以存储基本数据类型，也可以存储引用数据类型。

3.1定义数组的语法：

方法一：int[] arr=new int[5];
arr--名字  new--初始化  5--长度 

方法二：int arr[]=new int[5];也可以

3.2 数组的初始化动态初始化

Java中数组必须初始化才能使用，所谓初始化就是需要在内存中为数组开辟空间，并为数组的元素来进行赋值。

初始化方法：动态初始化静态初始化

a. 动态初始化：由我们指定数组长度，由系统为数组元素赋默认值

double[] arr=new double[2];

char[] chars=new char[1];

数组定义完后，每个元素会分配索引（角标），从0开始

double[] arr=new double[2];
double one=arr[0]; //取第一个元素的值

one.sout;
arr[1].sout;

b. 静态初始化

由我们为元素赋值，由系统计算长度，Java中数组的长度是固定的，数组一旦定义好，长度就固定了

int[] arr=new int[]{10,20,30,40,50};

//数组有一个属性叫length，可以获取数组长度
int len=arr.length;

len.sout;

//静态初始化简写方式
double[] arr={3.14,200,300,3.25};

例1. 数组的遍历

最后一个元素的索引=长度减一=arr.length-1

for(int i=0;i<arr.length;i++){
	arr[i].sout;
}

快捷方式：
arr.length.fori 快速遍历
arr.length.forr反向遍历

例2. 获取数组中最大值和最小值用方法操作：
要参数–传入的参数是数组，在方法中对其进行遍历；返回一个最大值或者最小值–需要一个返回值类型int，

package org.westos.shuzu;
public class Test1 {
    public static void main(String[] args) {
		//不调用方法
        int[] arr={13,16,267,897,3245,21,325,35};
        int max=arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(arr[i]>max){
                max=arr[i];
            }
        }
        System.out.println("最大的数是："+max);


		//调用方法
        int[] arr1={13,16,267,897,3245,21,325,35};
        int k=MAX(arr1);
        System.out.println("最大的数是："+k);
    }

    public static int MAX(int[] arr1){
        int k=0;
        for (int j = 0; j < arr1.length; j++) {
            if(arr1[j]>k){
                k=arr1[j];
            }
        }
        return k;
    }


}

例3. 数组元素反转，收尾元素交换值，遍历一半：
局部变量：定义在方法中的变量或者方法声明上的变量（形参）属于方法随着方法的调用而产生，随着方法调用完毕而消失

package org.westos.shuzu;
	import sun.security.util.Length;
public class Test2 {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40, 50, 60};
        int j = 0;
        for (int i = 0; i < (arr.length / 2); i++) {
            j = arr[i];
            arr[i] = arr[arr.length - i - 1];
            arr[arr.length - i - 1] = j;
        }
        for (int k = 0; k < arr.length; k++) {
            System.out.println(arr[k]);
        }
    }
}