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

r囧r小猫 2022-01-06 13:55 177阅读 0赞

# 方法(函数)： #

#### 格式： ####

修饰符 返回值类型 方法名(参数类型 参数名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;
        }

转载于:https://www.cnblogs.com/taozizainali/p/10603064.html