Java 函数与数组的概念

函数的概念

函数就是定义在类中的具有特定功能的一段独立小程序，并能被多次使用

使用函数的原因：由于在主函数中存在很多重复的代码，造成代码的重复性很多，所以提出把这些重复的代码封装起来，提高效率

**定义格式 **
修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2，…){
执行语句;
return 返回值;
}

return关键字是用于结束该功能。并将后面的具体结果返回给调用者。必须有return语句（若是void，则可不用写）

执行过程

import java.util.Scanner;
class class25{
    public static void main(String[] ager){
        Scanner scanner=new Scanner(System.in);
        System.out.print("请输入一个数；");
        long num=scanner.nextInt();
        long sum=sumDigits(Math.abs(num));
        System.out.println(sum);
    }
    public static int sumDigits(long num){
        int sel=0;
        while(true){
            sel=sel+(int)(num%10);
            num/=10;
            if(num==0){
                break;
            }
        }
        return sel;
    }
}

在执行主函数时，为了避免没有必要的函数重复，将重复的函数进行封装，重组，变成一个函数，在需要时，仅仅只需调用主函数即可。
该主函数在执行到 long sum=sumDigits(Math.abs(num)); 时，调用同名函数，执行该函数结束后将sumDigits()函数的返回值赋给sum，然后再次进行主函数。

函数的重载

1. 概念 ：在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同 即可，这时就形成了重载。重载和返回值类型无关

public class examplee
{
	public int add(int a,int b)
	{
		return a+b;
	}
	public float add(float a,float b)
	{
		return a+b;
	}
	public int add(int a,int b,int c)
	{
		return a+b+c;
	}
	
	
	public static void main(String[] args)
	{
		int result;
		float result_f;
		examplee text=new examplee();
		result=text.add(1, 2);
		
		System.out.println(result);
		result_f=text.add(1.2f, 1.3f);
		System.out.println(result_f);
	}
 
}

如图，add即为重载，但是由于返回值的类型不同，由于调用函数时所传的参数类型不同，所以他们并没有重复，这样称之为重载函数

a.int show(int x,float y,char z)
//没有重载，这个函数不允许和给定函数存在于 同一个类中。因为会产生调用的不确定性。
b.void show(float b,int a,char c)
//重载了，参数类型不同。
c.void show(int c,float a,char b)
//没有重载，和给定函数一样。不允许存在。
d.void show(int a,int b,int c)
//重载了，因为类型不同。
e.double show()
//重载了，因为个数不同

数组的定义

1. 概念：数组是同一种类型数据的集合；即能够存放多个相同类型的数据的容器。
2. 定义方式：
   元素类型[] 数组名 = new 元素类型[元素个数或数组长度]; int[] arr = new int[3];
   //通过new关键字创建了一个长度为3，元素类型是int的数组实 体。

import java.util.Scanner;
class class29{
    public static void main(String[] agre){
        int[] num=new int[101];
        Scanner scanner=new Scanner(System.in);
        System.out.println("Enter the integers between 1 and 100:");
        while(true){
            int temp=scanner.nextInt();
            if(temp==0)
            break;
            num[temp]++;
        }
        for(int i=0;i<num.length;i++){
            if(num[i]==1){
                System.out.println(i+" occurs "+num[i]+" time");
            }else if(num[i]>1)
            System.out.println(i+" occurs "+num[i]+" times");
        }
    }
}

这里的int[] num=new int[101]; 即为定义一个数组，在后续计算中进行调用

数组的内存分配

Java对内存空间的划分：五部分：栈，堆，方法区，本地方法区，寄存器。
栈内存：存储都是局部变量。只要是在方法中定义的变量都是局部变量。一旦变量的生 命周期结束该变量就被释放。

堆内存：存储都是实体(对象)，每一个实体都有一个首地址值。堆内存的变量都有默认 初始化值。不同类型不一样。int-0 double-0.0 boolean-false char-’\u0000’。当实体不 在使用时，就会被垃圾回收机制处理。

二维数组

1. 定义：
   int[][] arr = new int[3][2];
   int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};

二维数组本质上是一个其数组元素是一维数组的数组

//杨辉三角问题

import java.util.*;
class home32{
    public static void main(String[] agre){
        int line=5;
        int[][] a=new int[5][];
        //创建一个初始数组，边角为1
        for(int i=0;i<a.length;i++){
            a[i]=new int [i+1];
            a[i][0]=0;
            a[i][i]=1;
            
        }
        //根据杨辉三角的性质，进行填数字
            for(int i=2;i<a.length-1;i++){
                for(int j=1;j<a[i].length;j++){
                    a[i][j]=a[i-1][j]+a[i-1][j-1];
                   
                }
                
            }
            for(int i=0;i<a.length-1;i++){
                 System.out.print(a[i][]);
            }
            
    }
}

运用二维数组——进行建立和赋值