Java作业

数组(Array)是有序数据的集合，数组中的每个元素具有相同的数据类型，可以用一个统一的数组名和不同的下标来唯一确定数组中的元素。根据数组的维度，可以将其分为一维数组、二维数组和多维数组等。

一维数组：

数组中每个元素都只带有一个下标，是数组中最简单的一种数组。

 二维数组：

由数组元素组成一个数组，这样的数组被称为数组的数组或二维数组。

一维数组的举例：

输入学生的个数，输入相应的成绩，根据的学生的成绩输出相应的等级。

　//1.使用Scanner，读入学生的个数
        Scanner scan=new Scanner(System.in);
        System.out.println("请输入学生个数:");
        int num=scan.nextInt();
        
        //2.创建数组，存储学生的成绩
        int[] arr= new int[num];
        System.out.println("请输入"+num+"学生成绩：");
        for(int i=0;i<arr.length;i++) {
            arr[i]=scan.nextInt();
        }
        
        //3.获取学生中成绩的最高分
        int max=0;
        for(int i=0;i<arr.length;i++) {
            if(arr[i]>max) {
                max=arr[i];
            }
        }
        
        //4.根据每个学生的成绩与最高分的差值，
        //得到每个学生的等级，并输出等级和成绩
        char level;
        for(int i=0;i<arr.length;i++) {
            int differ=max-arr[i];
            if(differ<=10) {
                level='A';
            }else if(differ<=20) {
                level='B';
            }else if(differ<=30) {
                level='C';
            }else {
                level='D';
            }
            System.out.println("第"+(i+1)+"学生的成绩是"+arr[i]+"\n"+"level是"+level);
        }

输出结果：

 二维数组举例：

定义一个二维数组 int[ ][ ]  arr = {{5,7,9},{12,14,16,18},{23,25,36,47},{22,54,65,15},{22,34}};求数组元素的和。

class Demo1
{
    public static void main(String[] args)
    {
        //定义二维数组
        int[][]  arr = {{5,7,9},{12,14,16,18},{23,25,36,47},{22,54,65,15},{22,34}}; 
        int sum=add(arr);//调用求和函数
        System.out.println("sum="+sum);//输出和
    }
    public static int add(int[][] arr)//求和子函数
    {
        int sum=0;
        for(int i=0;i<arr.length;i++)
        {
            for(int j=0;j<arr[i].length;j++)//利用嵌套for循环来遍历二维数组
            {
                sum+=arr[i][j];//每遍历出一个元素则叠加一次
            }
        }
        return sum;//返回二维数组中个元素的和
    }
}

输出结果：

 面向对象：

面向对象就是把构成问题的事物分解成一个个对象，建立对象不是为了实现一个步骤，而是为了描述某个事物在解决问题中的行为。

类是面向对象中的一个很重要的概念，因为类是很多个具有相同属性和行为特征的对象所抽象出来的，对象是类的一个实例。

类具有三个特性：封装、继承和多态。

封装：核心思想就是“隐藏细节”、“数据安全”，将对象不需要让外界访问的成员变量和方法私有化，只提供符合开发者意愿的公有方法来访问这些数据和逻辑，保证了数据的安全和程序的稳定。所有的内容对外部不可见。

继承：子类可以继承父类的属性和方法，并对其进行拓展。将其他的功能继承下来继续发展 。

多态：同一种类型的对象执行同一个方法时可以表现出不同的行为特征。通过继承的上下转型、接口的回调以及方法的重写和重载可以实现多态。方法的重载本身就是一个多态性的体现。

重载：

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

每个重载的方法(或者构造函数)都必须有一个独一无二的参数类型列表。

最常用的地方就是构造器的重载。

重载举例：

public class OverLoadTest {
    public static void main(String[] args) {
        
        OverLoadTest test = new OverLoadTest();
        test.getSum(1,2);
        
        
    }
    
    //如下的4个方法构成了重载
    public void getSum(int i,int j){
        System.out.println("1");
    }
    
    public void getSum(double d1,double d2){
        System.out.println("2");
    }
    
    public void getSum(String s ,int i){
        System.out.println("3");
    }
    
    public void getSum(int i,String s){
        System.out.println("4");
    }
    
    //如下的3个方法不能与上述4个方法构成重载
//    public int getSum(int i,int j){
//        return 0;
//    }
    
//    public void getSum(int m,int n){
//        
//    }
    
//    private void getSum(int i,int j){
//        
//    }
    
    
}
重写：

重写是子类对（父类已经编写好的实现方法过程）再次进行一次方法的编写；编写可以改变操作或过程，但是其返回值和形参不能改变；该重写的好处在于子类可以根据自身的需要，定义特定的行为，根据需要实现父类的方法；

重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。

重写举例：

public class Demo{
    public static void main(String[] args){
        Student student=new Student();
        student.say();
    }
}
class Person{
    public void say(){
        System.out.println("锄禾日当午，汗滴禾下土。");
    }
}
class Student extends Person{
    public void say(){
        System.out.println("锄禾日当午，玻璃好上霜。要不及时擦，整不好得脏。");
    }
}
//结果为：
//锄禾日当午，玻璃好上霜。要不及时擦，整不好得脏。
 

重写与重载的区别：

• 重写方法名返回值相同参数相同；

• 重载方法名相同返回值相同参数可以不同，个数可以不同；

• 重写发生在父子类中，重载发生在一个类中；

• 重载与访问权限无关 ；

• 异常处理：重载与异常无关 ； 重写异常范围可以更小，但是不能抛出新的异常