Java基础二

Java基础二

方法

方法的定义

• 是语句的集合，它们在一起执行一个功能，是解决一类问题的步骤的有序组合
• 方法包含于类或对象中
• 方法在程序中被创建，在其它地方被引用
• 补充：一个项目应只存在一个main()方法

方法的结构

修饰符 返回值类型 方法名（参数类型 参数名）{
    方法体;
    return 返回值;
}

• 修饰符：可选项，告诉编辑器如何调用该方法，定义了方法的访问类型
• 返回值类型：方法可能会返回值。如果没有返回值，则其类型为void
• 方法名：方法名和参数表共同构成方法签名
• 参数列表：指方法的参数类型、顺序和个数
• 参数：参数像是一个占位符，当方法被调用时，传递值给参数，这个值被称为实参或变量。参数是可选的，方法可以不包含任何参数。
• 形式参数：在方法被调用时用于接收外界输入的数据，起定义作用
• 实参：调用方法时实际传给方法的数据
• 方法体：包含具体的语句，定义该方法的功能
• return：终止方法，返回值

方法的调用

• 静态方法是和其所在类一起加载的
• 静态方法可以直接拿类名调用方法名，且在本类中可以直接用方法名调用
• 非静态方法在类实例化后才存在的
• 非静态方法需要先实例化这个类，再调用
  1. 对象类型 对象名 = new 对象类型()
  2. 对象名.方法名(实参列表)
• 静态方法是类方法，非静态是成员方法
• 当方法返回一个值时，方法调用通常被当作一个值
• 当方法返回值是void时，方法调用一定是一条语句

方法的重载

• 重载就是在一个类中，有相同的函数名称，但形参不同的函数
• 重载规则：
  • 方法名称必须相同
  • 参数列表必须不同
  • 方法的返回类型可以相同，可以不同
  • 仅仅返回类型不同不足以成为方法的重载

方法的重写

• 重写都是非静态方法的重写，和属性无关
• 子类重写父类的方法，执行的是子类的方法
• 有static,final,private不能重写
• 重写是子类重写父类的方法，要有继承关系；而重载是相对于本类的
• 重写要求：
  1. 方法名、参数列表必须相同
  2. 修饰符：范围可以扩大但不能缩小public>protected>default>private
  3. 抛出的异常：范围可以被缩小但不能扩大

class A {
	public void test() {
		System.out.println("A=>test()");
	}
}

class B extends A {
	public void test() {
		System.out.println("B=>test()");
	}
}

public class Student {
	public static void main(String[] args) {
		A a = new A();
		a.test();
		//子类重写了父类的方法
		A ab = new B();
		ab.test();
		//B ba = new A();是错误的
	}
}
/*输出结果：       若将方法都改为静态方法则结果为：
 * A=>test()			A=>test()
 * B=>test()			A=>test()
 */
//静态方法是类的方法，非静态方法是成员的方法
//静态方法时：方法的调用只和左边(定义的数据类型)有关
//对象能执行哪些方法，主要看对象左边的类型，看该类下有哪些方法
//父类型可以指向子类，但不能调用子类独有的方法

命令行传参

在运行一个程序时再传递给它消息，这要靠传递命令行参数给main()函数实现。

package com.shen.method;
public class Demo{
    public static void main(String[] args){
        //args.length 数组长度
        for(int i=0; i<args.length; i++){
            System.out.println("args["+i+"]:"+args[i]);
        }
    }
}
/*到命令行窗口下,进入相应的目录，执行javac Demo.java，
此时若直接执行java Demo，会出现错误：找不到或无法加载主类
多次使用命令cd .. 退到src目录下，
执行java com.shen.method.Demo this is shen
结果：args[0]:this
	 args[1]:is
	 args[2]:shen
*/

可变参数

• Java支持传递同类型的可变参数给一个方法
• 在方法声明中，在指定参数类型后加一个省略号…
• 可变的是指定参数类型的实参个数，本质是数组
• 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数，任何一个普通的参数必须在它之前声明

//打印最大值
public static void printMax(double… numbers){
    double result = numbers[0];
    for(int i=1; i<numbers.length; i++){
        //排序
        if(numbers[i]>result){
            result = numbers[i];
        }
    }
    System.out.println("The max value is "+result);
}

递归

• 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。
• 递归体：什么时候需要调用自身方法。
• 过程：前阶段——>边界——>返回阶段

//阶乘
public static int fac(int n){
    if (n==1){
        return 1;
    }else{
        return n*fac(n-1);
    }
}

---

数组

数组的定义

• 数组是相同类型数据的有序集合
• 每一个数据称作一个数组元素，通过索引访问，索引从0开始

数组的特点

• 长度确定，一旦创建就不可变。若越界，则报：ArrayIndexOutOfBoundsException
• 其元素必须是相同类型，不允许出现混合类型
• 元素可以是任何数据类型，包括基本类型和引用类型
• 数组变量属于引用类型，数组也是对象，数组元素相当于该对象的成员变量。Java对象是在堆中，数组无论保持原始类型还是其它对象类型，数组对象本身是在堆中。

数组的声明创建

• 声明：首先必须声明数组变量，才能在程序中使用数组

dataType[] arrayRefVar;//首选方式
dataType arrayRefVar[];//效果相同

• 创建：使用new操作符来创建数组，分配了空间

dataType[] arrayRefVar = new dataType[arraySize];

数组的初始化

• 静态初始化：创建+赋值

int[] a = {1,2,3};
Man[] men = {new Man(1,1),new Man(2,2)};

• 动态初始化（包含默认初始化）

int[] a = new int[2];//默认初始化
a[0] = 1;

• 默认初始化

  数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中每个元素也被按照实例变量同样的方式被隐式初始化

数组的使用

//for-each循环遍历打印数组
int[] arrays = {1,2,3,4};
for (int array : arrays){
    System.out.print(array+" ");
}

//for循环打印数组
public static void printArray(int[] arrays){
    for (int i=0; i<arrays.length; i++){
        System.out.print(arrays[i]+" ")
    }
}

//此外也可以使用Arrays.toString()方法直接打印数组，首先需要import java.util.Arrays;

//反转数组
public static int[] reverse(int[] arrays){
    int[] result = new int[arrays.length];
    for (int i=0; i<arrays.length; i++){
        result[i] = int[arrays.length-i-1];
    }
    return result;
}

二维数组

//2行3列的二维数组
int a[][] = new int[2][3];
int[][] b = {{1,2,4},{3,5,7}};

//打印二维数组
for (int i=0; i<array.length; i++){
    for (int j=0; j<array[i].length; j++){
        System.out.print(array[i][j]);
    }
}

Arrays类

• 数组的工具类：java.util.Arrays
• Arrays类中的方法都是static修饰的静态方法，在使用时可以直接使用类名进行调用，而不用使用对象来调用
• 常用方法：
  • 数组赋值：Arrays.fill()
  • 打印数组：Arrays.toString()
  • 数组排序：Arrays.sort()，升序
  • 比较数组元素值：Arrays.equals()
  • 查找数组元素：Arrays.binarySearch()，对排序好的数组进行二分查找法操作

稀疏数组

• 当一个数组中大部分元素为0，或为同一值时，可以使用稀疏数组来保存该数组
• 处理方式：
  • 记录数组一共有几行几列，除0外有多少个不同值
  • 把具有不同值的行、列和值记录在一个小规模的数组中

public class Demo{
    public static void main(String[] args){
        //原二维数组,10行10列，2个不同值
        int[][] arr1 = new int[10][10];
        arr1[1][2] = 1;
        arr1[3][4] = 2;
        
        //打印稀疏数组
        int[][] arr2 = xiShu(arr1);
        System.out.println("稀疏数组：");
        for (int i=0; i<arr2.length; i++) {
            System.out.println(arr2[i][0]+"\t"+arr2[i][1]+"\t"+arr2[i][2]);
        }
        
        //还原数组
        int[][] arr3 = new int[arr2[0][0]][arr2[0][1]];
        for (int i=1; i<arr2.length; i++) {
            arr3[arr2[i][0]][arr2[i][1]] = arr2[i][2];
        }
        
        //打印还原数组
        System.out.println("原数组：");
        for (int[] ints : arr3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
    
    
    //xiShu()方法输入原数组方法返回稀疏数组
    public static int[][] xiShu(int[][] arr1){
        //获取arr1数组不同值的个数
        int dif = 0;
        for (int i=0; i<arr1.length; i++) {
            for (int j=0; j<arr1[i].length; j++){
                if (arr1[i][j]!=0) {
                    dif++;
                }
            }
        }

        //创建稀疏数组
        int[][] arr2 = new int[dif+1][3];
        //稀疏数组的头部
        arr2[0][0] = arr1.length;
        arr2[0][1] = arr1[0].length;
        arr2[0][2] = dif;

        //遍历arr1数组，将非零的值信息存放在稀疏数组
        int count = 0;
        for (int i=0; i<arr1.length; i++) {
            for (int j=0; j<arr1[i].length; j++) {
                if (arr1[i][j]!=0) {
                    count++;
                    arr2[count][0] = i;
                    arr2[count][1] = j;
                    arr2[count][2] = arr1[i][j];
                }
            }
        }
        return arr2;
    }
}