慢慢懂的第四篇blog

Java day04

方法的重载

重载就是在一个类中具有相同的函数名称，但形参不同的函数

重载的规则

1. 方法名称必须相同
2. 参数列表不同（个数不同，类型不同或者参数排列不同）
3. 方法的返回类型可以相同也可以不同
4. 仅返回值不同不能组成方法的重载

实现理论

• 方法名称相同时，编译器会根据调研的方法的参数个数，参数类型等逐个匹配以选择对应的方法，如果匹配失败，则编译器报错

public class Main {
    public static void main(String[] args) {
        int max=max(10,10);
        System.out.println(max);
    }
    public static int max(int a,int b)
    {
        if(a>b)return a;
        else if(a<b)return b;
        else {System.out.println("两数相等");return 0;}
    }
    public static double max(double a,double b)
    {
        if(a>b)return a;
        else if(a<b)return b;
        else {System.out.println("两数相等");return 0;}
    }
    }

可变参数

• Java1.5开始，Java支持传递同类型的可变参数给一个方法
• 在方法声明中，在指定参数类型之后加上一个省略号（…）
• 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数，任何普通的参数必须在他之前声明

public class Main {
    public static void main(String[] args) {
        PrintMax(34,3,3,2,56.5);
        PrintMax(new double[]{1,2,3});
    }
    public static void PrintMax(double ...numbers)
    {
        if(numbers.length==0)
        { System.out.println("No arguement passed");
        return;}
        double result  = numbers[0];
        //排序
        for (int i = 0; i < numbers.length; i++) {
            if(numbers[i]>result)result=numbers[i];

        }
        System.out.println("The max value is "+result);
    }
    }

输出结果是

递归

• 递归就是A方法调用A方法，自己调用自己

• 利用递归可以用简单的程序来解决一些复杂的问题。 它通常把一个大型复杂的问题层层转化为-个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。

  ◆递归结构包括两个部分:

  ◆递归头:什么时候不调用自身方法。如果没有头，将陷入死循环。

  ◆递归体:什么时候需要调用自身方法。

import java.util.Scanner;
public class Demon01 {
    //阶乘
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = factory(a);
        System.out.println(b);

    }
    public static int factory(int a)
    {
        if(a==1)return 1;
        else return a*factory(a-1);
    }
    }

输出结果

数组

数组的定义

◆数组是相同类型数据的有序集合.

◆数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。

◆其中,每一个数据称作-个数组元素, 每个数组元素可以通过-个下标来访问它们.

数组的声明

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

  声明语法：

  //变量类型   变量名  = 变量的值
  //数组类型 
        int[] nums1;//首选,定义，声明一个数组
        int nums2[];
  

• Java语言中使用new操作字符来创建数组

nums = new int[10];//创建一个数组

• 数组的元素都是通过索引访问的，数组索引从0开始
• 获取数组长度

nums.length

内存分析

数组越界：java.lang.ArrayIndexOutOfBoundsException

三种初始化

静态初始化

int[] a={1,2,3};

动态初始化

int[] a =new int[2];
a[0]=1;a[1]=2;

数组的默认初始化

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

数组的四个基本特征

◆其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。

◆其元素必须是相同类型,不允许出现混合类型。

◆数组中的元素可以是任何数据类型，包括基本类型和引用类型。

◆数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

数组边界：[0,a.length-1]

数组的使用

For-Each 循环

import java.util.Scanner;
public class Demon01 {
    public static void main(String[] args) {
        int[] num = new int[10];
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < num.length; i++) {
            num[i]=sc.nextInt();
        }
        for (int i : num) {
            System.out.print(+i+" ");
        }
        System.out.println();
        sc.close();
    }

数组作为方法入参&数组作为返回值

public class Demon01 {
    public static void main(String[] args) {
        int[] num = new int[10];
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < num.length; i++) {
            num[i]=sc.nextInt();
        }
        reverse(num);
        sc.close();
    }
      public static int[] reverse(int[] array){
        int[] result = new  int[array.length];
        for (int i = 0,j=array.length-1; i < array.length; i++,j--) {
            result[j]=array[i];//逆序输出数组
        }
        return  result;
    }
    }

好，睡觉