方法(函数)，内存空间，数组

方法(函数)：

格式：

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

详细解释：
修饰符：例如 public static。后面我们再详细的讲解其他的修饰符。
返回值类型：就是功能结果的数据类型。
方法名：符合命名规则即可。方便我们的调用。
参数：
实际参数：就是实际参与运算的。
形式参数；就是方法定义上的，用于接收实际参数的。
参数类型：就是参数的数据类型
参数名：就是变量名
方法体语句：就是完成功能的代码。
return：结束方法的。
返回值：就是功能的结果，由return带给调用者。

调用方法：

public class scanner {
    public  static void main(String[] args){
        int a = 3;
        int b =4;
        //第一种方法：单独调用
        sum(a,b);
        //第二种方法：赋值调用
        int result = sum(a,b);
        //第三种方法：输出调用
        
    }

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

在void类型的返回值的方法调用：(void表示没有返回值)

只能进行单独调用

方法的重载：

java允许方法使用一个名字，用传入的参数识别这些方法：

例如：

//在下面这个例子中，如果我们不写int的sum方法，他会直接调用float的方法进行使用，会根据大小向下找。

    public static void main(String[] args) {
        //jvm会根据不同的参数去调用不同的功能
　　　　　//在下面这个例子中，如果我们不写int的sum方法，他会直接调用float的方法进行使用

        System.out.println(sum(10,20));
        System.out.println(sum(10,20,30));
        System.out.println(sum(10,20,30,40));
        
        System.out.println(sum(10.5f,20f));
    }
    
    //需求1:求两个数的和
    public static int sum(int a,int b) {
        System.out.println("int");
        return a + b;
    }
    
    //需求2:求三数的和
    /*
    public static int sum1(int a,int b,int c) {
        return a + b + c;
    }
    */
    
    public static int sum(int a,int b,int c) {
        return a + b + c;
    }
    
    //需求3:求四个数的和
    /*
    public static int sum2(int a,int b,int c,int d) {
        return a + b + c + d;
    }
    */
    public static int sum(int a,int b,int c,int d) {
        return a + b + c + d;
    }
    
    public static float sum(float a,float b) {
        System.out.println("float");
        return a + b;
    }

java中的内存分配：

java程序为了提高程序的效率，就对数据进行了不同空间的分配。

具体的是划分为了5个内存空间

1.栈：存放的是局部变量

2.堆：存放的是所有new出来的东西

3.方法区：面向对象有关

4本地方法区：和系统相关

5.寄存器：CPU使用

栈的内存特点：

存储的是一个变量名，当有初始化操作的时候，就会将变量名和堆中的内存地址绑定，

并且在栈内存的数据用完就释放掉。

堆的内存特点：

1.每一个new出来的东西都有地址值

2.每个变量都有默认值

　　byte,short,int,long 0

　　float,double 0.0

　　char “u0000” (空值)

　　boolean false

　　引用类型 null

3.使用完毕就变成了垃圾，但是没有立即回收。会在垃圾回收器空闲的时候回收

String的地址比较和内容比较：

==：地址值比较

equals()方法：内容比较

System.out.println(ss.equals(str));//比较的是字符串的内容

数组：

数组是存储多个变量的地方，但是这些变量的数据类型要一致。

当多个变量指向一个数组的时候，任意一个变量的操作，对数组都生效，

有点像python的可变类型的列表，

定义格式：

A:数据类型[] 数组名;
B:数据类型 数组名[];

注意：数组只有初始化之后才能进行使用

两种初始化方式的区别：

a:动态初始化 只指定长度，由系统给出初始化值
b:静态初始化 给出初始化值，由系统决定长度(用的较多)

动态初始化数组：

 public static void main(String[] args){

    //动态数组的定义

    int [] arr_d = new  int[3];
    System.out.println(arr_d);
    System.out.println(arr_d[0]);
    System.out.println(arr_d[1]);
    System.out.println(arr_d[2]);
    /*
    [I@1b6d3586
    0
    0
    0
    */

    }

静态初始化数组：

格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};

简化格式： 数据类型[] 数组名 = {元素1,元素2,…};

public static void main(String[] args) {
        //定义数组
        int[] arr = {1,2,3};
        
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }

数组的逆序

public static void reverse2(int[] arr) {
        for(int start=0,end=arr.length-1; start<=end; start++,end--) {
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }
    }

二维数组：

就是数组中的元素还是数组的形式

动态初始化：

int[][] arr = new int[3][2]

静态初始化：

基本格式：
数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};
简化版格式：
数据类型[][] 数组名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};

例如：

int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
int[][] arr = {{1,2,3},{4,5},{6}};

二维数组的内存绑定：

在堆中将2层数组的地址赋值给第一层数组，

然后栈中的变量在和堆中的一层数组的地址进行绑定

打印杨辉三角练习：

import java.util.Scanner;
public class java_start {
    //打印杨辉三角
    public static void main(String[] args){


        Scanner sc = new Scanner(System.in);

        System.out.println("请输入一个数字(1-9):");
        int n = sc.nextInt(); 
        int [][] sanjiao = new int[n][n];  
        for (int i=0;i<sanjiao.length;i++){
            sanjiao[i][0] =1;
            sanjiao[i][i] = 1;

          
            if (i>1){
                for (int j=1;j<i;j++){
                    sanjiao[i][j] = sanjiao[i-1][j-1]+sanjiao[i-1][j];
                }
            }
            }
        for(int i=0;i<sanjiao.length;i++){
            for (int j=0;j<=i;j++){
                System.out.print(sanjiao[i][j]);
            }
            System.out.println(" ");
        }
        }

    }

Java中的参数传递问题：

基本类型：

类比python的不可变类型

形式参数的改变对实际参数没有影响。

引用类型：

数组，一个位置改变了数组，他就变了，类比python的可变类型

形式参数的改变直接影响实际参数。

可变参数：

public static int connInt(int ...is){//可变长参数，数组的扩容
        int sum=0;
        for (int i = 0; i < is.length; i++) {
            sum+=is[i];
        }
        return sum;
    }
    //Object ：
    public static String connString(Object ...o){ 
        String s="";
        for (int i = 0; i < o.length; i++) {
            s+=o[i];
        }
        return s;
    }