数组的使用、eclipse调试程序、练习小demo以及方法的定义和重载

编程练习优化

package com.imooc;
import java.util.Scanner;
/*
 * 功能：为指定的成绩加分，直至分数大于等于60分为止
 *          输出加分前后的成绩，并且统计加分次数
 * 步骤：
 * 1、定义一个变量，用来保存加分的次数
 * 2、使用循环为成绩加分
 * 3、每次执行循环加分操作，加1分，并且统计加分的次数
 * 使用Scanner工具类来获取用户输入的成绩信息
 * Scanner类位于java.util包中，使用时需要导入此包
 * 步骤：
 * 1、导入java.util.Scanner
 * 2、创建Scanner对象
 * 3、接收并保存用户输入的值
 */
public class HelloWorld{
    public static void main(String[] args){
        Scanner input=new Scanner(System.in);//创建Scanner对象
        System.out.println("请输入考试成绩信息：");
        int score=input.nextInt();//获取用户输入的成绩并保存在变量score中
        int count=0;
        System.out.println("加分前的成绩："+score);
        while(score<60){//只要成绩小于60分，就循环进行加分操作
            score++;
            count++;
        }
        System.out.println("加分后的成绩："+score);
        System.out.println("共加了"+count+"次");
    }
}

使用eclipse调试程序

在需要开始调试的代码行前双击，

添加断点（双击后会出现一个实心圆点）

点击eclipse工具栏“甲壳虫”图形（debug）开始执行调试程序

执行到断点时，按F6从断点处一行一行的执行代码，并从中找出程序中的错误

编程练习进阶

package com.imooc;
import java.util.Scanner;
/*
 * 功能：实现接收3个班级的各4名学员的成绩信息，然后计算每个班级学员的平均分
 * 知识点：二重循环、外层循环控制班级的数量，内层循环控制每个班级学员的数量
 */
public class HelloWorld{
    public static void main(String[] args){
        int classNum=3;//班级数量
        int stuNum=4;//学生数量
        double sum=0;//成绩总和
        double avg=0;//成绩平均分
        Scanner input=new Scanner(System.in);//创建Scanner对象
        for(int i=1;i<=classNum;i++){
            sum=0;//计算前成绩总和归0
            System.out.println("***请输入第"+i+"个班级的成绩***");
            for(int j=1;j<=stuNum;j++){
                System.out.println("请输入第"+j+"个学员的成绩：");
                int score=input.nextInt();
                sum+=score;
            }
            avg=sum/stuNum;//计算平均分
            System.out.println("第"+ i +"个班级学生第平均分为："+avg);
        }
    }
}

What is 数组 ?

1、声明数组

语法：数据类型[] 数组名;  or  数据类型 数组名[];

2、分配空间——就是指定数组中可以存储多少个元素

int[] scores=new int[5]   为数组分配空间，长度为5 //必须指定长度

3、赋值 scores[0]=89;

在java中还提供了另外一种直接创建数组的方式，它将声明、分配空间、赋值合并完成

int[] scores={89,42,53,39} 创建一个长度为4的数组

它等价于：

int[] scores=new int[]{89,42,53} 第2个int[]里必须为空，不能指定长度

数组名.length 用于获取数组的长度

public static void main(String[] args){
        int nums[]=new int[]{61,23,4,74,13,148,20};
        int max=nums[0];
        int min=nums[0];
        int sum=0;
        double avg;
        for(int i=0;i<nums.length;i++){
            if(nums[i]>max){
                max=nums[i];
            }
            if(nums[i]<min){
                min=nums[i];
            }
            sum+=nums[i];
        }
        avg=sum/nums.length;
        System.out.println(max);
        System.out.println(min);
        System.out.println(sum);
        System.out.println(avg);
    }

使用Arrays类操作java中的数组&foreach

Arrays.sort(数组名) 对数组进行排序（按升序排列）

Arrays.toString(数组名) 将数组转化成字符串

import java.util.Arrays;

String[] hobbies={"sports","game","mobie"};

Arrays.sort(hobbies);

System.out.println(Arrays.toString(hobbies));

结果：[game, mobie, sports]

使用foreach操作数组

语法：for(元素类型 变量名 ：遍历对象) {

执行的代码}

foreach是for语句的特殊简化版本，在遍历数组、集合时，foreach更简单便捷！

int[] scores={89,72,64,58,93};

Arrays.sort(scores);

for(int score:scores){

System.out.println(score); }

java中的二维数组

1、声明数组并分配空间

数据类型[][] 数组名=new 数据类型[行的个数][列的个数]

又或者简单点：

//定义一个2行3列的二维数组

int[][] num=new int[2][3]

2、赋值：

a、数组名[行的索引][列的索引]=值

也可以在声明数组的同时为其赋值

b、数据类型[][] 数组名={{value1,value2,...},{value1,value2,...},{value1,value2,...}}

在定义二维数组时也可以只指定行的个数，然后再为每一行分别指定列的个数。如果每行的列数不同，则创建的是不规则的二维数组，例如：

int[][] num=new int[3][];定义一个3行的二维数组

num[0]=new int[2]; 为第1行分配2列

num[1]=new int[3]; 为第2行分配3列

num[2]=new int[4]; 为第3行分配4列

public static void main(String[] args){
    String names[][]={{"tom","jack","mike"},{"zhangsan","lisi","wangwu"}};
        for(int i=0;i<names.length;i++){
            for(int j=0;j<names[i].length;j++){
                System.out.println(names[i][j]);
            }
        System.out.println();
        }
    }

如何定义java中的方法

所谓方法，就是用来解决一类问题的代码的有序组合，是一个功能模块。

定义一个方法的语法是：

访问修饰符 返回值类型 方法名(参数列表){

方法体

}

访问修饰符：方法允许被访问的权限范围，public  protected  private  也可省略访问修饰符，其中 public 表示该方法可以被其他任何代码调用

返回值类型：如果方法不返回任何值就用void

1、如果方法的返回类型为 void ，则方法中不能使用 return 返回值！

2、方法的返回值最多只能有一个，不能返回多个值

3、方法返回值的类型必须兼容，例如，如果返回值类型为 int ，则不能返回 String 型值

public int maxAge(){
        int[] ages={18,23,21,19,25,29,17};
        int max=ages[0];
        for(int i=0;i<ages.length;i++){
            if(ages[i]>max){
                max=ages[i];
            }
        }
        return max;
    }
    public static void main(String[] args){
        HelloWorld test=new HelloWorld();
        System.out.println("最大年龄为："+test.maxAge());
    }

Java中带参的方法

很多时候，我们把定义方法时的参数称为形参，目的是用来定义方法需要传入的参数的个数和类型；把调用方法时的参数称为实参，是传递给方法真正被处理的值。

一定不可忽视的问题：

调用带参方法时，必须保证实参的数量、类型、顺序与形参一一对应

public void calcAvg(double score1,double score2){
        System.out.println((score1+score2)/2);
    }

    public int sort(int[] scores){
        Arrays.sort(scores);
        System.out.println(Arrays.toString(scores));
        int count=scores.length;
        return count;
    }

    public static void main(String[] args){
        HelloWorld hello=new HelloWorld();
        hello.calcAvg(94, 81);
        int[] scores={79,52,98,81};
        int count=hello.sort(scores);
        System.out.println(count);
    }

什么是方法的重载呢？

如果同一个类中包含了两个或两个以上方法名相同、方法参数的个数、顺序或类型不同的方法，则称为方法的重载，也可称该方法被重载了。

如何区分调用的是哪个重载方法呢？

当调用被重载的方法时， Java 会根据参数的个数和类型来判断应该调用哪个重载方法，参数完全匹配的方法将被执行。

判断方法重载的依据：

1、 必须是在同一个类中

2、 方法名相同

3、 方法参数的个数、顺序或类型不同

4、 与方法的修饰符或返回值没有关系

通过 (int)(Math.random() * 100) 生成 100 以内的随机数

注：Math 类是用于进行算术操作的类，Math.random() 生成 0--1 的浮点数。 关于该类的其他应用在后面章节会有详细介绍，先熟悉随机数方法的使用~~

public static void main(String[] args){
        HelloWorld hello=new HelloWorld();
        int nums[]=hello.getArray(3);
        System.out.println(Arrays.toString(nums));
    }
    public int[] getArray(int length){
        int[] nums=new int[length];
        for(int i=0;i<length;i++){
            nums[i]=(int)(Math.random()*100);
        }
        return nums;
    }

实现输出考试成绩的前3名

public static void main(String[] args){
        HelloWorld hello=new HelloWorld();
        int[] scores={89,-23,64,91,119,52,73};
        hello.printNO3(scores);
    }
    public void printNO3(int[] scores){
        Arrays.sort(scores);
        int count=0;
        System.out.println("考试成绩的前3名为：");
        for(int i=scores.length-1;i>=0;i--){
            if(scores[i]<0||scores[i]>100){
                continue;
            }
            if(count>=3){
                break;
            }
            System.out.println(scores[i]);
            count++;
        }
    }

*** END

原文地址：https://www.cnblogs.com/liuyun66535309/p/8878631.html