Java学习笔记——Java语言基础（四）（方法、一维数组的简单使用以及Java中的内存分配）

一：方法的使用

1.1 方法的概述以及格式说明

1.方法的概述：方法就是完成特定功能的代码块。
2.方法的格式：

      修饰符   返回值类型   方法名（参数类型 参数名1，参数类型 参数名2......）{
      								方法体；
      								return 返回值
      }

格式的详细说明：

 1. 修饰符      public static（目前所接触到的）还有其他的修饰符以后会学到
 2. 返回值类型       用于限定返回值的数据类型
 3. 方法名     就是一个名称，方便调用方法
 4. 参数类型    限定调用方法时传入参数的数据类型
 5. 参数名     是一个变量，接受调用方法时传入的参数，这个参数称为形式参数，用来接受实际参数。
 6. 方法体    完成功能的代码
 7. return    结束方法以及返回方法指定类型的值
 8. 返回值    方法体执行的结果，由return带回给调用者

1.2方法的调用案例

1. 写方法的是应该确定两个因素，一是方法的返回值类型，明确功能结果的数据类型。二是参数列表，即时你要传递几个参数以及每一个参数的数据类型
2. 案例：比较获取的两个数中的较大值

import java.util.Scanner;
public class max {
    public static void main(String[] args) {
        //键盘获取两个输入的数字
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入比较的第一个数字：");
        int num1 = sc.nextInt();
        System.out.println("请输入比较的第二个数字：");
        int num2 = sc.nextInt();
        //调用方法，传递实际参数num1和num2
        int max = caontrast(num1, num2);
        System.out.println("两个数的最大值为"+max);
    }
       //1.明确返回值类型，根据问题要求可知返回值类型为Int
       //2.参数列表为int类型的两个形式参数
    private static int caontrast(int x,int y) {
        int max=x>y?x:y;
        return max;
    }
}

运行结果：

案例二：输出星行的*

import java.util.Scanner;
public class star {
    //根据键盘录入的行数和列数，在控制台输出星形
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入行数：");
        int x = sc.nextInt();
        System.out.println("请输入列数：");
        int y = sc.nextInt();
        show(x,y);
    }
        //明确有无返回值
       //根据题意可知无返回值，参数列表为两个int参数，分别代表行和列
       //第一个参数为行数，第二个为列数
    private static void show(int x,int y) {
        for (int i = 0; i < x; i++) {
            for (int j = 0; j < y; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

运行结果：

1.3方法的注意事项

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

1.4方法的重载

1.在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同，与返回值无关。
2.参数列表不同指的是参数的个数和参数类型不同。
方法的重载案例：

public class overload {
    public static void main(String[] args) {
        int sum1 = sum(10, 20);
        final int sum2 = sum(10, 20, 30);
        double sum3 = sum(10, 20, 30.0);
        System.out.println("10+20="+sum1);
        System.out.println("10+20+30="+sum2);
        System.out.println("10+20+30.0="+sum3);
    }
    //参数列表为int，int，double
    private static double sum(int x,int y,double z) {
        return x+y+z;
    }
    //参数列表为int，int，int
    private static int  sum(int x,int y,int z) {
        return x+y+z;
    }
    //参数列表为int，int
    private static int  sum(int x,int y) {
        return x+y;
    }
}

运行结果：

二：数组的简单使用

2.1 数组的概述以及定义格式

1.数组的概述：数组是存储同一种数据类型多个元素的集合，也可以看成是一个容器。数组既可以存储基本数据类型，也可以存储引用数据类型
2.数组的定义格式
（1）格式1：数据类型 [ ] 数组名；
（2）格式2：数据类型 数组名 [ ]；

2.2数组的初始化

1.Java中的数组必须先初始化，然后才能使用，所谓初始化，就是为数组中的数组元素分配内存空间，并为每个数组元素赋值
2.初始化的分类：

1. 动态初始化：只指定长度，由系统给出初始化值
2. 静态初始化：给出初始化值，由系统决定长度

• 注意：初始化的两种方式，只能使用一种，不能同时使用。

2.3 数组的动态初始化

1.格式：
数据类型[ ] 数组名=new 数组类型 [ 数组长度 ]；
其中数组长度就是数组中元素的个数。
举例：int [ ] arr = new int [ 5 ];代表着定义了一个int类型的数组arr，这个数组可以存放5个int类型的值。

public class shuzu {
    public static void main(String[] args) {
        //数组的动态初始化，定义了一个长度为5的int数组
        int[] arr=new int[5];
        arr[0]=1;
        arr[1]=2;
        arr[2]=3;
        arr[3]=4;
        arr[4]=5;
        //使用for循环对数组进行输出
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

2.4 数组的静态初始化

1.格式：
数据类型 [ ] 数组名=new 数据类型 [ ] {元素1，元素2，元素3…}
简化格式： 数据类型 [ ] 数组名={元素1，元素2，元素3…}

public class shuzu2 {
    public static void main(String[] args) {
        int[] arr={10,20,30,40,50,60};
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

三：Java中的内存分配

3.1 内存的分配

1.栈：存放的是局部变量。局部变量是在方法定义中或者方法声明上的变量，
2.堆：存在的所有new出来的东西
特点：

1. 每一个new出来的东西都会为其分配一个地址值
2. 每一个变量都有其默认的值
3. 一旦使用完毕就会等待垃圾回收器对其回收

3.方法区：面向对象是详细说明
4.本地方法区：与系统有关
5.寄存器：cpu使用

3.2 数组创建过程的内存分配

public class Demo01 {
    public static void main(String[] args) {
        int [] arr=new int[4];
        System.out.println(arr);
        arr[0]=1;
        arr[1]=2;
        arr[2]=3;
        arr[3]=4;
        System.out.println(arr[3]);
    }
}

1.以上述代码为例，程序首先对java文件进行编译得到.class文件，进入方法区
2.程序从main方法开始进行，（main方法是程序运行的入口）main方法会被加载到栈中执行。（进栈）
3.执行方法的第一行代码，int[] arr =new int [ 4];
4.new的东西都在堆中，这时会在堆中开辟一块空间，此时根据数组的数据类型设置默认值。上述代码为int类型，所以默认值为0。
5.将数组的地址值赋值给arr变量，arr变量指向堆中的地址值
6.执行赋值语句，通过地址值找到堆中的空间，根据数组中[]的索引值，找到该索引的元素位置，将值赋值到该索引处。
7.输出arr[3]，通过地址值在堆中找到内存空间，按索引值找到对应的元素。

四：数组的案例

1.获取数组中的最值：

public class Test01 {
    public static void main(String[] args) {
        //静态初始化数组
        int[] arr={10,20,30,40,45,80,60,85};
        int max=arr[0];
        //获取数组中的最大值
        for (int i = 1; i <arr.length; i++) {
            max=max>arr[i]?max:arr[i];
        }
        System.out.println("数组中最大值为"+max);//85
    }
}

2.反转数组：

public class Test02 {
    public static void main(String[] args) {
        //反转数组,将[10,20,30,40,50,60]----->[60,50,40,30,20,10]
        int[] arr={10,20,30,40,50,60};
        for (int i = 0; i < arr.length; i++) {
            if (i==0){
                System.out.println("反转前：");
                System.out.print("["+arr[i]+",");
            }else if (i==arr.length-1){
                System.out.print(arr[i]+"]");
            }else{
                System.out.print(arr[i]+",");
            }
        }
        int temp;
        System.out.println();
        for (int i = 0; i < arr.length/2; i++) {
            temp=arr[i];
            arr[i]=arr[arr.length-i-1];
            arr[arr.length-1-i]=temp;
        }
        for (int i = 0; i < arr.length; i++) {
            if (i==0){
                System.out.println("反转后：");
                System.out.print("["+arr[i]+",");
            }else if (i==arr.length-1){
                System.out.print(arr[i]+"]");
            }else{
                System.out.print(arr[i]+",");
            }
        }
    }
}

运行结果：