Java基础-02

Java基础-02

小小的引入

假如现在教务处的老师有个需求，需要让你设计一个程序

教师输入若干个学生的成绩，让你计算平均分并输出

解决方法：

上节课已经学习了Scanner类循环了，所以我们这道题的基本思路就是：

先让教师输入学生个数，我们用int类型的变量cnt保存

Scanner in=new Scanner(System.in);
System.out.println("请输入学生数量");
int cnt=in.nextInt();

然后再让教师循环输入学生的成绩，用一个float型变量score接收，并初始化一个float型变量sum=0，用于保存所有学生的分数总和。

float sum=0;
float score;
float avg;
System.out.println("请输入学生分数");
for (int i=1;i<=cnt;i++){
	score=in.nextFloat();
	sum+=score;
}

最后输出float类型的平均值avg=sum/cnt

avg=sum/cnt;
System.out.printf("平均分为:%.2f",avg);

现在教务处老师又有个需求

输出平均分之后，再输出高于平均分的学生个数

这个需求要求我们得到各个学生成绩的同时，还需要将他们保存到一个地方，等到我们将平均数计算出来之后呢，再从那个地方一个一个取出学生成绩的信息，和平均数进行比对。因此，我们引入数组的概念。

数组

数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。

Java 语言中提供的数组是用来存储固定大小的同类型元素。

你可以声明一个数组变量，如 numbers[100] 来代替直接声明 100 个独立变量 number0，number1，…，number99。

声明数组：

dataType[] arrayRefVar;   // 首选的方法
dataType arrayRefVar[];  // 效果相同，但不是首选方法

double[] myList;         // 首选的方法
double myList[];         //  效果相同，但不是首选方法

创建数组：

arrayRefVar = new dataType[arraySize];
//上面的语法语句做了两件事：
//一、使用 dataType[arraySize] 创建了一个数组。
//二、把新创建的数组的引用赋值给变量 arrayRefVar。

//另外，你还可以使用如下的方式创建数组。
dataType[] arrayRefVar = {value0, value1, ..., valuek};

//数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到 arrayRefVar.length-1。

实例：

下面的语句首先声明了一个数组变量 myList，接着创建了一个包含 10 个 double 类型元素的数组，并且把它的引用赋值给 myList 变量。

public class TestArray {
   public static void main(String[] args) {
      // 数组大小
      int size = 10;
      // 定义数组
      double[] myList = new double[size];
      myList[0] = 5.6;
      myList[1] = 4.5;
      myList[2] = 3.3;
      myList[3] = 13.2;
      myList[4] = 4.0;
      myList[5] = 34.33;
      myList[6] = 34.0;
      myList[7] = 45.45;
      myList[8] = 99.993;
      myList[9] = 11123;
      // 计算所有元素的总和
      double total = 0;
      for (int i = 0; i < size; i++) {
         total += myList[i];
      }
      System.out.println("总和为：" + total);
   }
}

输出结果：
总和为： 11367.373

处理数组：

数组的元素类型和数组的大小都是确定的，所以当处理数组元素时候，我们通常使用循环。

实例：

public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};
      // 打印所有数组元素
      for (int i = 0; i < myList.length; i++) {
         System.out.println(myList[i] + " ");
      }
      // 计算所有元素的总和
      double total = 0;
      for (int i = 0; i < myList.length; i++) {
         total += myList[i];
      }
      System.out.println("Total is " + total);
      // 查找最大元素
      double max = myList[0];
      for (int i = 1; i < myList.length; i++) {
         if (myList[i] > max) max = myList[i];
      }
      System.out.println("Max is " + max);
   }
}

以上实例编译运行结果如下：
1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5

数组是对象变量

数组变量与基本类型变量是有一些区别的，它属于对象变量，对象变量的意思就是，它是一遍数据区域的管理者而不是所有者，具体可以通过下面这个例子来理解：

对于基本类型的变量而言，变量中存储的就是“值”，
而对于对象变量来讲，变量中存在的并不直接是数据，而是“引用”，
这里的“引用”可以理解为对一片数据区域的遥控器，所以我们常说对象变量是对象的管理者而不是所有者

//基本数据类型的变量
int a=10;
//将a中的“值”传递给b
int b=a;
b++;
System.out.println(a+"  "+b);
//输出：10  11


//对象变量
int[] a={1,2,3,4,5};
//将a的“引用”传递给b
int[] b=a;
b[0]=10;
System.out.println(a[0]);
System.out.println(b[0]);
//输出10  10

解决了上面这个问题之后我们还要面临另外一个问题，假如上述的这代码的使用需求较强，你需要在程序的很多其他地方用到这段代码，那需要用的时候你会怎么办呢，最蠢的办法当然是复制粘贴，但是显然这种办法太笨了，会让代码飞速膨胀，所以我们需要用下面这种方式将这代码保存起来，需要的时候再用。因此，我们引出方法的概念。

方法（函数）

Java语言中的“方法”（Method）也可被称为“函数”（Function）。

什么是方法？

Java方法是语句的集合，它们在一起执行一个功能。

• 方法是解决一类问题的步骤的有序组合
• 方法包含于类或对象中
• 方法在程序中被创建，在其他地方被引用

方法的定义

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

…

方法体

…

return 返回值;

}

方法包含一个方法头和一个方法体。下面是一个方法的所有部分：

• **修饰符：**修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。

• 返回值类型 ：方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType 是关键字void。

• 方法名：是方法的实际名称。方法名和参数表共同构成方法签名。

• 参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。

• 方法体：方法体包含具体的语句，定义该方法的功能。

  

实例:

public static int age(int birthday){...}
//多个参数
static float interest(float principal, int year){...}


/** 返回两个整型变量数据的较大值 */
public static int max(int num1, int num2) {
   int result;
   if (num1 > num2)
      result = num1;
   else
      result = num2;
 
   return result; 
}

//简略写法
public static int max(int num1, int num2) {
  return num1 > num2 ? num1 : num2;
}

方法调用

Java 支持两种调用方法的方式，根据方法是否返回值来选择。

当程序调用一个方法时，程序的控制权交给了被调用的方法。当被调用方法的返回语句执行或者到达方法体闭括号时候交还控制权给程序。

当方法返回一个值的时候，方法调用通常被当做一个值。例如：

int larger = max(30, 40);

实例：

public class TestMax {
   /** 主方法 */
   public static void main(String[] args) {
      int i = 5;
      int j = 2;
      int k = max(i, j);
      System.out.println( i + " 和 " + j + " 比较，最大值是：" + k);
   }
 
   /** 返回两个整数变量较大的值 */
   public static int max(int num1, int num2) {
      int result;
      if (num1 > num2)
         result = num1;
      else
         result = num2;
 
      return result; 
   }
}

5 和 2 比较，最大值是：5

返回到我们的教务问题，这里就需要写一个函数，将学生的人数作为传入的参数，取名为getAvg，暂且我们只需要在里面直接输出信息，所以可以把返回类型设置为void

static void getAvg(int cnt){
        int num=0;
        float sum=0;
        float[] score=new float[cnt];
        float avg;
        Scanner in=new Scanner(System.in);
        System.out.println("请输入学生分数");
        //这里注意length成员，最好不要用cnt
        for (int i=0;i<score.length;i++){
            score[i]=in.nextFloat();
            sum+=score[i];
        }
        avg=sum/cnt;
        for (float s:score){
            if (s>=avg) num++;
        }
        System.out.printf("平均分为:%.2f,共有%d人超过平均分",avg,num);
}

上述方法看来是蛮不错的，但是我们现在还需要另外一个功能，在我们输入学生信息之前，我们要先输入这是哪一门的成绩，最后再将科目名称和平均分一同输出，并且保留原来的方法，那么我们就需要对原来的方法进行一个重载操作

方法重载

就是在类中可以创建多个方法，它们可以有相同的名字，但必须具有不同的参数，即或者是参数的个数不同，或者是参数的类型不同，但方法的返回类型、修饰符可以相同，也可不同。调用方法时通过传递给它们的不同个数和类型的参数，以及传入参数的顺序来决定具体使用哪个方法.

static void getAvg(int cnt,String subject){
    int num=0;
    float sum=0;
    float[] score=new float[cnt];
    float avg;
    Scanner in=new Scanner(System.in);
    System.out.println("请输入学生分数");
    //这里注意length成员，最好不要用cnt
    for (int i=0;i<score.length;i++){
        score[i]=in.nextFloat();
        sum+=score[i];
    }
    avg=sum/cnt;
    for (float s:score){
        if (s>=avg) num++;
    }
    System.out.printf(subject+"的平均分为:%.2f,共有%d人超过平均分",avg,num);
}

public class MethodOverloading{
    public void show(String str){
            ... ...
    }
    public void show(int i){
           ... ...
    }
    public void show(double d){
        ... ...
    }
    public void show(int i,double d){
        ... ...
    }
}

//具体例子
public class TestDemo {
    public static void main(String[] args) {
        //此时将根据参数的类型和个数的不同执行不同的方法体
        System.out.println(add(10, 20));
        System.out.println(add(30, 40, 50));
        System.out.println(add(1.1, 2.1));
    }
    public static int add(int x, int y) {
        return x + y;
    }
    //此时方法名称相同，参数的个数不同
    public static int add(int x, int y, int z) {
        return x + y + z;
    }
    public static double add(double x, double y) {
        return x + y;
    }
}