JAVA基础再回首(三)——方法、重载、数组、堆栈内存分配、数组遍历、获取最值、二维数组

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/m366917/article/details/51627396

JAVA基础再回首(三)——方法、重载、数组(静态和动态初始化)、堆栈内存分配、数组遍历、获取最值、二维数组

继续开始学习我们的java基础,这篇主要学习两个知识点——方法、数组。

一、方法

方法:就是完成特定功能的代码块
注意:在很多语言里面有函数的定义,而在Java中函数被称为方法。

方法格式:

修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
            方法体语句;
            return 返回值; 
        }

我们来详细解释一下方法的格式:

修饰符:目前就用 public static,后面我们再详细的讲解其他的修饰符。
返回值类型:就是功能结果的数据类型。
方法名:符合命名规则即可。方便我们的调用。
参数:

  • 实际参数:就是实际参与运算的。
  • 形式参数;就是方法定义上的,用于接收实际参数的。

参数类型:就是参数的数据类型
参数名:就是变量名
方法体语句:就是完成功能的代码。
return:结束方法的。
返回值:就是功能的结果,由return带给调用者。

要想写好一个方法,就必须明确两个东西:

  1. 返回值类型——结果的数据类型
  2. 参数列表——要传递几个参数,以及每个参数的数据类型

我们一起来写一个Demo吧。

public class FunctionDemo {
    public static void main(String[] args) {
        int x = 10;
        int y = 20;
        //赋值调用
        int result = sum(x,y);
        System.out.println(result);
    }

    /*
     * 明确:返回值类型:int
     * 参数列表:2个,都是int类型
     */
    public static int sum(int a,int b){

        return a + b;
    }
}

输出结果:30

方法注意事项:

1.方法不调用不执行
2.方法与方法是平级关系,不能嵌套定义
3.方法定义的时候参数之间用逗号隔开
4.方法调用的时候不用在传递数据类型
5.如果方法有明确的返回值,一定要有return带回一个值

二、重载

  • 方法重载概述
    • 在同一个类中,允许存在一个以上的同名方法,只要它们的参数个数或者参数类型不同即可。
  • 方法重载特点
    • 与返回值类型无关,只看方法名和参数列表
    • 在调用时,虚拟机通过参数列表的不同来区分同名方法

我们来写一个Demo吧!

public class FunctionTest {
    public static void main(String[] args) {

        System.out.println(sum(20, 30));
        System.out.println(sum(20, 30, 40));
        System.out.println(sum(20, 30, 40, 50));
    }

    // 需求1:求两个数的和
    public static int sum(int a, int b) {
        return a + b;
    }

    // 需求2:求三数的和

    public static int sum(int a, int b, int c) {
        return a + b + c;
    }

    // 需求3:求四个数的和
    public static int sum(int a, int b, int c, int d) {
        return a + b + c + d;
    }
}

三、数组

  • 数组概念
    • 数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
    • 数组既可以存储基本数据类型,也可以存储引用数据类型。
  • 数组格式

    • 格式1:数据类型[] 数组名;
    • 格式2:数据类型 数组名[];
    • 注意:这两种格式中,数组中是没有元素值的。我们要对数组的元素进行初始化。
  • 数组初始化的概述:

    • Java中的数组必须先初始化,然后才能使用。
    • 为数组中的数组元素分配内存空间,并为每个数组元素赋值。
  • 数组初始化的方式:
    • 动态初始化:初始化时只指定数组长度,由系统为数组分配初始值。
    • 静态初始化:初始化时指定每个数组元素的初始值,由系统决定数组长度。

我们先来学习动态初始化
格式:数据类型[] 数组名 = new 数据类型[数组长度];
数组长度其实就是数组中元素的个数。

int[] arr = new int[3];
//解释:定义了一个int类型的数组,这个数组中可以存放3个int类型的值。

静态初始化
格式:数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};

int[] arr = new int[]{1,2,3};
//解释:定义了一个int类型的数组,这个数组中可以存放3个int类型的值,并且值分别是1,2,3。

//现在我们经常用下面这简化写法
int[] arr = {1,2,3};

Java中数组的内存分配

Java 程序在运行时,需要在内存中的分配空间。为了提高运算效率,就对空间进行了不同区域的划分,因为每一片区域都有特定的处理数据方式和内存管理方式。

  • 栈内存——存储局部变量
  • 堆内存——存储new出来的东西
  • 方法区

    • 本地方法区 (和系统相关)
    • 寄存器 (给CPU使用)

    上面提到了局部变量,我们来解释一下
    局部变量:方法定义中或者方法声明上的所有变量,使用完毕,立即消失。

数组遍历

数组的遍历就是依次输出数组中的每一个元素。
数组提供了一个属性length,用于获取数组的长度。
格式:数组名.length

public class ArrayTest {

    public static void main(String[] args) {

        int arr [] = {11,22,33,44,55};

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

输出结果
这里写图片描述

我们把方法和数组结合使用写个Demo

public class ArrayTest {

    public static void main(String[] args) {

        int arr [] = {11,22,33,44,55};

        printArray(arr);
    }

    public static void printArray(int []arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+",");
        }
    }
}

输出结果:
这里写图片描述

我们来对上面的程序进行优化,去掉55后面的逗号。并加上括号。

public class ArrayTest {

    public static void main(String[] args) {

        int arr [] = {11,22,33,44,55};

        printArray(arr);
    }

    public static void printArray(int []arr){
        System.out.print("[");

        for (int i = 0; i < arr.length; i++) {

            if(i==arr.length-1){ //这是最后一个元素
                System.out.print(arr[i]+"]");
            }else{
                System.out.print(arr[i]+",");
            }
        }
    }
}

输出结果
这里写图片描述
这个输出结果是不是比上面的那个好看多了。

获取最值

获取数组中的最大值最小值

public class ArrayTest2 {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {34,98,10,25,67};

        //调用方法
        int max = getMax(arr);
        System.out.println("max:"+max);

        //请获取数组中的最小值
        int min = getMin(arr);
        System.out.println("min:"+min);
    }

    /*
        需求:获取数组中的最大值
        两个明确:
            返回值类型:int
            参数列表:int[] arr
    */
    public static int getMax(int[] arr) {
        //从数组中任意的找一个元素作为参照物
        int max = arr[0];
        //然后遍历其他的元素
        for(int x=1; x<arr.length; x++) {
            //依次获取和参照物进行比较,如果大就留下来,如果小,就离开。
            if(arr[x] > max) {
                max = arr[x];
            }
        }
        //最后参照物里面保存的就是最大值。
        return max;
    }

    public static int getMin(int[] arr) {
        //从数组中任意的找一个元素作为参照物
        int min = arr[0];
        //然后遍历其他的元素
        for(int x=1; x<arr.length; x++) {
            //依次获取和参照物进行比较,如果小就留下来,如果大,就离开。
            if(arr[x] < min) {
                min = arr[x];
            }
        }
        //最后参照物里面保存的就是最小值。
        return min;
    }
}

输出结果
这里写图片描述

二维数组

概述:一个元素为一维数组的数组。

  • 格式

    • 数据类型[][] 变量名 = new 数据类型[m][n];
    • m表示这个二维数组有多少个一维数组
    • n表示每一个一维数组的元素个数
  • 举例:

    • int[][] arr = new int[3][2];
    • 定义了一个二维数组arr
    • 这个二维数组有3个一维数组,名称是arr[0],arr[1],arr[2]
    • 每个一维数组有2个元素,可以通过arr[m][n]来获取
      • 表示获取第m+1个一维数组的第n+1个元素

    二维数组还有两种格式:
    格式2:数据类型[][] 变量名 = new 数据类型[m][];
    格式3:数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
    我们一起来做个练习吧!

/*
//需求:打印杨辉三角形
    1
    1 1 
    1 2 1
    1 3 3 1
    1 4 6 4 1 
    1 5 10 10 5 1
分析:看这种图像的规律
    A:任何一行的第一列和最后一列都是1
    B:从第三行开始,每一个数据是它上一行的前一列和它上一行的本列之和。
步骤:
        A:首先定义一个二维数组。行数如果是n,我们把列数也先定义为n。这个n的数据来自于键盘录入。
        B:给这个二维数组任何一行的第一列和最后一列赋值为1
        C:按照规律给其他元素赋值从第三行开始,每一个数据是它上一行的前一列和它上一行的本列之和。
        D:遍历这个二维数组。
*/
public class Array2Test {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);

        //这个n的数据来自于键盘录入。
        System.out.println("请输入一个数据:");
        int n = sc.nextInt();

        //定义二维数组
        int[][] arr = new int[n][n];

        //给这个二维数组任何一行的第一列和最后一列赋值为1
        for(int x=0; x<arr.length; x++) {
            arr[x][0] = 1; //任何一行第1列
            arr[x][x] = 1; //任何一行的最后1列
        }

        //按照规律给其他元素赋值
        //从第三行开始,每一个数据是它上一行的前一列和它上一行的本列之和。
        for(int x=2; x<arr.length; x++) {
            //这里如果y<=x是有个小问题的,就是最后一列的问题
            //所以这里要减去1
            //并且y也应该从1开始,因为第一列也是有值了
            for(int y=1; y<=x-1; y++) {
                //每一个数据是它上一行的前一列和它上一行的本列之和。
                arr[x][y] = arr[x-1][y-1] + arr[x-1][y];
            }
        }

        //遍历这个二维数组。
        /*
        for(int x=0; x<arr.length; x++) {
            for(int y=0; y<arr[x].length; y++) {
                System.out.print(arr[x][y]+"\t");
            }
            System.out.println();
        }
        */
        //这个时候,要注意了,内循环的变化必须和曾经讲过的九九乘法表类似
        for(int x=0; x<arr.length; x++) {
            for(int y=0; y<=x; y++) {
                System.out.print(arr[x][y]+"\t");
            }
            System.out.println();
        }
    }
}

输出结果
这里写图片描述

关于二维数组我们平时用的地方不是很多,但是数组我们还是会经常用到,所以我们要熟练掌握。


这章java基础再回首三,我们就学到这里,下次我们来一起学习面向对象的思想,它是java的重点,我们要好好学习。

阅读更多
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页