Java 04

1、funaction 方法

1、定义：

语句定义格式：
    修饰符 返回值类型 方法名(参数类型 参数名,...){
        方法实现逻辑代码;
        return 返回值;
    }

2、名词解释：

修饰符：public static 前几天只需要记住这一个固定写法就行，后面的学习过程中会改变这个修饰符
返回值类型：将来调用者调用完方法后所得到的内容
方法名：符合标识符的命名规则，将来通过方法名来确定调用的方法类型
参数：
	形式参数【形参】：指的是在方法定义的小括号中的参数名
	实际参数【实参】：指的是将来实际调用方法时所传入的具体的值
方法实现逻辑代码：调用方法要干的事情
return：用于结束整个方法，将结果返回给调用者。
返回值：将来方法调用完，需要返回给调用者的值。

3、注意：

1、方法和方法之间是平级关系，方法不能嵌套定义
2、方法不调用不执行
3、方法调用的时候，只需要传值就行，不需要写数据类型
4、若方法有返回值，需要用变量接收该返回值，或直接使用
5、如果方法有明确返回值，一定有return带回一个值， 且类型和定义时返回值类型保持一致【或父子关系】

代码示例

//需求：定义一个求两个int类型的数之和的方法
public class FunctionDemo1 {
    public static void main(String[] args) {
        int a = 3;
        int b = 4;
        System.out.println(sum(a,b));
    }

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

2、数组

1、数组的概念

是一块连续固定大小的内存空间，有着索引的概念

数组长度固定：数组一但被创建，他的大小是固定的（数组的长度，元素的数量），不能动态调整。

数组类型一致：数组中的所有元素必须是相同的数据类型。

2、定义数组语句格式

数据类型[] 数组名--更推荐
数据类型 数组名[];

如果只是定义一个数组的话，没有给初始化值，相当于一个变量没有值，是不能狗直接使用的

3、如何对一个数组初始化

1、动态初始化

我们给定数组的大小，数组中默认值由jvm来赋值

定义格式：

数据类型[] 数组名 = new 数据类型[元素的个数]          

我们自己给元素值，由jvm根据我们给定值的数量来设置数据大小

引用数据类型

填了第二天的坑

//定义一个存储int类型元素的数组

pubilc class Aarraydemo1{new*
	public static void main(String[] args){ 
	//数据类型 变量名 =初始化值	
	int[] arr= new int[3];//引用数据类型
/*
左边：
	int：表示该数组中元素的数据类型，需要一致
	[]：表示一个一维数组
	arr:是数组名，符合标识符变量的命名规则
右边：
	new：将来看到new，表示在堆内存中开辟一个空间
	int：表示该数组中元素的数据类型，需要一致
 	[]：表示一个一维数组
	3:表示该数组最大只能储存3个int类型的元素


*/

System.out.println(arr);//I@4554617c地址值【16进制】——只要引用数据类型才有地址值
//数组有索引概念，从左向右，索引下标从0开始编号，我们可以通过这个索引下标来定位到具体位置的元素
//语法格式：数组名[索引]
//获取数组中的第一个元素
int i = arr[0];
System.out.println(i);
//获取数组中的第二,三个元素
System.out.println(arr[1]);
SYstem.out.println(arr[2]);
//结果都是0，这个和数据类型有关系，如果说double的话，结果就不一样了
}

我们以后使用数组的时候，肯定是希望将我们自己的元素放在数组中

将数据第一个元素值进行修改

arr[0] = 100;
System.out.println(arr[1]);
//这样打印下来的就是100而不是0了

4、Java中的内存分配

1、栈 存储局部变量——基本上所有方法的调用都在栈中进行的

先将main方法加载到栈中执行
特点：先进先出
局部变量：在方法定义上或者方法内部定义的变量都称之为局部变量

2、堆 存储new出来的东西

默认值

在堆内存中的变量，系统会赋予默认值，不同的数据类型，会有不同的默认值。

整数的默认值：byte，short，int，long：0

小数的默认值：float，double：0

boolean默认值：false

char默认值：'\u0000'

引用数据类型：null

3、方法区（面对对象部分讲解）

4、本地方法区（和系统相关）

5、寄存器（给CPU使用）

pubilc class Aarraydemo1{new*
	public static void main(String[] args){ 
		int[]arr1 = new int[3];
		arr1[0]=11;
		arr1[1]=22;
		arr1[2]=33;
		System.out.println(arr1);
		System.out.println(arr1[0]);
		System.out.println(arr1[1]);
		System.out.println(arr1[2]);
		System.out.println("------------------------");
		int[] arr2=arr2;
		arr2[1]=100;
		System.out.println(arr2);
		System.out.println(arr2[0]);
		System.out.println(arr2[1]);
		System.out.println(arr2[2]);

5、静态初始化

我们上一个案例中，学习了数组的定义以及数组的动态初始化，
但是有一个地方不太方便，如果我们想要赋值自己的元素在数组中的话，动态初始化需要我们先将数组创建出来
然后再一个一个复制，其实很麻烦，能不能在初始化是将元素赋值进去？

1、数组的静态初始化

数据类型[] 数组名 = new 数据类型[]{元素1…元素n}；

int[] arr1 = new int[]{11,22,33,44,55};
//arrayIndexOutOfNoundaEXception 	—— 数组越界异常

简化写法：
数据类型[] 数组名 = {元素1….元素2…..}；

6、案例

数组的遍历

pubilc class Aarraydemo1{
	public static void main(String[] args){ 
	//定义一个数组并初始化
	int[] arr = {1,2,3,4,5,6,7,8,};
	//使用for循环
//	for(int i = 0;i<8;i++){
//		System.out.println(arr[i]);
//}
//虽然用for循环，范围是人为数出来的，元素多是，就很难写对
//java的数组有一个属性，length属性，我们可以直接获取数组的该属性得到数组的长度【元素的个数】
//语句格式：数组名.length	
//System.out.ptintln("数组长度为："arr.length)

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


	}
}

获取数组的最值

public class ArrayDemo1 {
    public static void main(String[] args) {
        int[] arr = {23, 44, 66, 73, 78, 45, 34, 3, 33};

        // 初始化最大值和最小值为数组的第一个元素
        int maxNumber = arr[0];
        int minNumber = arr[0];

        // 从第二个元素开始循环，比较每个元素
        for (int i = 1; i < arr.length; i++) {
            // 如果当前元素比maxNumber大，则更新maxNumber
            if (arr[i] > maxNumber) {
                maxNumber = arr[i];
            }
            // 如果当前元素比minNumber小，则更新minNumber
            if (arr[i] < minNumber) {
                minNumber = arr[i];
            }
        }

        // 输出最大值和最小值
        System.out.println("最大值是: " + maxNumber);
        System.out.println("最小值是: " + minNumber);
    }
}

数组元素逆序

/*
分析 
	1.交换的次数少长度/2的整除
	2.交换时，需要使用到临时变量
*/
pubilc class Aarraydemo1{
	public static void main(String[] args){ 
		int[] arr ={1,2,3,4,5,6,7};
        for(int front = 0,end = arr.length;front < end;front++,end--){
            int tmp = arr[front];
            arr[front]=arr[end];
            arr[end]=tmp;                
		}

3、二维数组

元素是一维数组的数组是二维数组

public class Array2Demo4 {
    public static void main(String[] args) {
        int[][] arr = new int[2][3];
        System.out.println(arr); // 二维数组的地址值
        System.out.println(arr[0]); // 二维数组中第一个一维数组的地址值
        System.out.println(arr[1]); // 二维数组中第二个一维数组的地址值
        System.out.println(arr[0][0]); // 二维数组中第一个一维数组的第1个元素值
    }
}

1、语句定义格式1：

	数据类型[][] 数组名 = new 数据类型[m][n];
	举例：int[][] arr = new int[2][3];
        表示创建了一个元素是int类型的二维数组，其中二维数组中有两个一维数组，每一个一维数组中的元素个数是3。

2、语句定义格式2：

数据类型[][] 数组名 = new 数据类型[m][n];
举例：int[][] arr = new int[2][];
arr[0] = new int[]{11,22,33,44};
arr[1] = new int[]{100,200};

3、定义语句格局3：

	数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2,...},{元素1,...},...};
    举例：int[][] arr = new int[][]{{11,22,33,44},{100,200}};
    简化写法：数据类型[][] 数组名 = {{元素1,元素2,...},{元素1,...},...};
           举例：int[][] arr = {{11,22,33,44},{100,200}};

今后可能会遇到的写法

int[] arr[] = {{11,22,33,44},{100,200}};//√
int arr[][] = {{11,22,33,44},{100,200}};//√
int [] [] arr = {{11,22,33,44},{100,200}};//√
int[][] arr = new int[][]{{11,22,33,44},{100,200}};//√【规范写法】
int[][] arr = new int[2][]{{11,22,33,44},{100,200}};//×

二维数组的遍历

public class Array2Test1 {
    public static void main(String[] args) {
        //创建一个二维数组
        int[][] arr = {{11, 22, 33, 44}, {100, 200}};


        for (int i = 0; i < arr.length; i++) { // 外层循环遍历到每一个一维数组
            for (int j = 0; j < arr[i].length; j++) { //内层循环遍历的是每一个一维数组的元素
                System.out.println(arr[i][j]);
            }
        }
    }
}

补充：

1.当基本数据类型当作参数传递的时候，传递到具体的数值，不会对原本对变量进行修改影响
2.当引用数据类型当作参数传递的时候，传递到具体数值