Java基础03——数组、类和对象

1.数组

数组用一个标识符和下标来表示，下标可以区分数组中不同的元素。如果一个数组只有一个下标，则称为一维数组。有两个下标，则为二维数组。一般只用到三维数组，而一维和二维数组较常用。

数组是一种引用类型，在内存中数组元素和数组变量是分开存放的，其中引用变量存储在栈内存中（stack），数组元素则是在堆内存（heap）中。

数组是一种基本数据结构，用来存储同一类型值的集合。

数组的声明：

int a[]=new int[10];

（初始化）int a[]={1,3,5,7,9};

对于多维数组（二维为例）：int a[][]=new int[3][4];

如果二维数组各行的元素个数不一样，则需要为每一行单独分配内存空间。如int a[][]=new int[3][];

a[0]=new int[3];//第0行有3个元素

a[1]=new int[5];//第1行有5个元素

a[2]=new int[8];//第2行有8个元素

数组的排序：

（1）选择排序：如果有n个数需要排序，则需要进行n-1趟的排序。第i趟的排序需要进行n-i次比较。

import java.util.Scanner;
public class 选择排序 {
    static void sort(int n,int a[]){
        for(int i=0;i<n;i++){
            for(int j=i+1;j<n;j++){
                if(a[i]>a[j]){
                    int temp=a[i];
                    a[i]=a[j];
                    a[j]=temp;
                }
            }
        }
    }
    public static void main(String[] args) {
        Scanner cin=new Scanner(System.in);
        while (cin.hasNext()){
            int n=cin.nextInt();
            int a[]=new int[n];
            for(int i=0;i<n;i++){
                a[i]=cin.nextInt();
            }
            sort(n,a);
            for(int i:a){ //for-each循环
                System.out.println(i);
            }
        }
    }
}

（2）冒泡排序：对于一组包含n个数据的一组记录，最坏的情况要进行n-1个排序。

import java.util.Scanner;
public class 冒泡排序 {
    public static void bubbleSort(int []data,int len)
    {
        for(int i=0;i<len-1;i++)
        {
            boolean flag=false;
            for(int j=0;j<len-i-1;j++)
            {
                if(data[j]>data[j+1])
                {
                    int temp=data[j];
                    data[j]=data[j+1];
                    data[j+1]=temp;
                    flag=true;
                }
            }
            if(!flag)//如果未发生交换，意为已经有序了
                break;
        }
    }
    public static void main(String[] args) {
        Scanner cin=new Scanner(System.in);
        while (cin.hasNext()) {
            int n = cin.nextInt();
            int a[] = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = cin.nextInt();
            }
            bubbleSort(a,n);
            for(int i:a){ //for-each循环
                System.out.println(i);
            }
        }
    }
}

（3）快速排序：二分的思想，在一组数据中取一个数据（如第一个）作为分界值，所有比分界值小的数放到左边，比分界值大的放在右边，得到两个子序列，两个子序列分别再进行排序，直到左右只剩一个数为止。

import java.util.Scanner;
public class 快速排序 {
    public static void quickSort(int[] data,int start,int end)
    {
        int i=start;int j=end;
        if(i>=j)//退出条件
            return;
        boolean flag=true;//true表示从右至左搜索，false表示从左至右搜索
        while (i!=j)//直到相遇停止，意味这一轮交换完成
        {
            if(data[i]>data[j])
            {
                int temp=data[i];
                data[i]=data[j];
                data[j]=temp;
                flag=!flag;//有交换则改变flag，这决定下一次ij改改变谁（搜索往哪个方向走）
            }
            if(flag)
                j--;
            else
                i++;
        }
        i--;j++;//递归，二分思想，分别对ij左右两侧再次重复
        quickSort(data,start,i);
        quickSort(data,j,end);
    }
    public static void main(String[] args) {
        Scanner cin=new Scanner(System.in);
        while (cin.hasNext()) {
            int n = cin.nextInt();
            int a[] = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = cin.nextInt();
            }
            quickSort(a,0,n-1);
            for(int i:a){ //for-each循环
                System.out.println(i);
            }
        }
    }
}

2.类和对象

（1）对象的概念

Everything is Object.

客观世界中的任何事物都是对象，不管是有生命的还是无生命的、具体的还是抽象的都可以看作对象。

面向对象就是从对象的角度观察、了解、认识世界。

每一个对象都有两个特征，一个是属性，一个是行为。

有些对象的行为比较明显，有些对象的行为则不太明显。

（2）面向对象三大特征——封装 继承 多态

封装 Encapsulation 继承 Inheritance 多态 Polymorphism

（3）类和对象

类是对一类事物的描述、是抽象的、概念上的定义，对象是实际存在的该类事物的每个个体，因而也称实例（instance）。

（4）类（Class）

用来描述一个对象（Object）。包括属性（Attribute/Property）、方法（Method）。举例如下：

学生信息格式化

Time Limit: 1000 MS Memory Limit: 32768 K

Description

要求单独定义一个学生类，有学号以及高数、英语、Java语言三科成绩，共四个属性。另外还有格式化输出方法，用来按照 学号-高数-英语-Java语言 这种格式输出。

Input

有不定组数的学生信息，都是整数类型的，中间用空格分隔

Output

按照要求的格式输出的串

Sample Input

1 90 80 70 2 78 68 90

Sample Output

1-90-80-70 2-78-68-90

参考代码：

import java.util.Scanner;
class Student{
    private int Number;
    private double Math;
    private double English;
    private double Java;
    Student(){}
    public Student(int number, double math, double english, double java) {
        Number = number;
        Math = math;
        English = english;
        Java = java;
    }

    public int getNumber() {
        return Number;
    }

    public double getMath() {
        return Math;
    }

    public double getEnglish() {
        return English;
    }

    public double getJava() {
        return Java;
    }
}
public class 学生类 {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        while (in.hasNext()){
            int number=in.nextInt();
            double math=in.nextDouble();
            double english=in.nextDouble();
            double java=in.nextDouble();
            Student student=new Student(number,math,english,java);
            System.out.println(student.getNumber()+"-"+student.getMath()+"-"+student.getEnglish()+"-"+student.getJava());
        }
    }
}