Java 方法(方法重载)与数组

待我称王封你为后i 2021-12-19 00:53 347阅读 0赞

### 一、方法(Method) ###

**1、方法的定义**

**1）方法定义与格式：**

方法(Method)，有人称之为函数(function)，其实就指一个特定的功能操作，程序中能完成独立功能，可重复使用的一段代码的集合。

[修饰符] 返回值的类型  方法名字([类型 变量1,类型 变量2 ,...])
    {
        方法体
        [return 值];
    }

注意点：

（1）方法必须声明在类（class）当中。

（2）创建的方法要定义在其它方法之外（跟其他的方法是兄弟关系）

（3）定义方法不分先后顺序。

（4）如果有一个方法前面有static，那么在该方法中调用其它的方法前面也应该有static。

（5）void 返回值为空，什么都不返回；如果有返回值，必须要有return。

（6）两个方法的名称不能相同。

（7）方法必须要先定义，再执行。方法只有被调用才会执行，可以被重复调用。

**2）方法术语:**

**  修饰符:**

方法的访问权限如,public，static等，static修饰的方法属于类，直接使用类名调用即可。

**返回值类型:**

该功能操作完毕之后，是否需要给调用者返回一个结果。

如果方法定义了返回类型,则方法体必须使用return返回该类型的一个值.

如果方法使用void来表示返回值类型,此时在方法体中不需要使用return.

**   方法名字: **

遵循标识符的规范，使用动词表示，首字母小写，若是多个单词组成，使用驼峰表示法，以后的每一个单词首字母都大写，如:sendMsg(发生信息)。

**   形式参数:**

方法圆括号中的变量，仅仅只是占位而已，参数的名称其实无所谓没有实质的意义，形式参数可以有多个。

**  方法签名: **

方法签名 = 方法名称 + 方法参数列表;   在同一个类中，方法签名是唯一的，否则编译报错。

**   实际参数:**

调用者在调用某一个具体方法的时候，实际传递的参数值。

**2、方法重载(overload)**

**1）方法重载定义与作用：**

重载方法的定义是在同一个类中，某方法允许存在一个以上的同名方法，只要它们的参数列表不同即可。

方法重载作用是解决了同一功能的多个方法，由于参数列表不同所造成的方法名称不同的问题.

**2）方法重载的判断原则：“两同一不同”**

两同：方法必须在同一个类中，且方法的名称相同；

一不同：方法参数列表不同（参数类型、参数个数、参数顺序）；

注意：

（1）只要参数类型，参数个数，参数顺序有一个不同，参数列表就不同。

（2）方法重载与方法的返回值类型无关，只是一般要求返回值类型一致。

（3）方法重载与参数列表的参数名称没关系。

public class HelloWorld {
        public static void main(String[] args) {
            //方法重载
            int res1 = add(2, 2);
            double res2 = add(2.0, 2);
            System.out.println("res1=" + res1 + "  res2=" + res2); //res1=4  res2=4.0
        }
    
        public static int add(int a, int b) {
            return a + b;
        }
        public static double add(double a, int b) {
            return a + b;
        }
    }

**3、方法参数的传递机制**

若是基本数据类型，就直接传递实参值的副本，即值传递，实际参数本身不受影响。

若是引用数据类型，就传递实际参数的16进制地址值(引用地址)，即引用传递，实际参数本身受影响。

## ##

### 二、数组 ###

**1、数组的定义与格式**

所谓数组，是在程序设计中，为了处理方便，把**具有相同类型的若干变量按有序的形式**组织起来的一种数据形式，这些**按一定顺序排列的同类型数据的集合**称为**数组**。而数组中的每一个数据称之为**数组元素**，数组中的元素以**索引**来表示其存放的位置，索引从0开始，步长是1，逐行递增。

数组的定义格式
    方式1： 数组元素的类型[] 数组名; 如: int[] ages; 推荐使用
    方式2： 数组元素的类型 数组名[]; 如: int ages[];

**2、数组的初始化**

Java中数组必须先初始化后才能使用。所谓初始化就是给数组元素分配内存，并为每个元素赋初始值；一旦数组初始化完成，数组的长度就固定了，不能更改，除非重新初始化。也就是说数组是定长的

**1）静态初始化:**

特点：由程序员自己为每一个数组元素设置初始化值，而数组的长度由系统(JVM)决定。

语法:
        元素类型[] 数组名称 = new 元素类型[]{元素1,元素2,元素3,...};

如：int\[\] nums = new int\[\]\{1,3,5,7,9\};

更简单的语法：int\[\] nums = \{1,3,5,7,9\};

简单写法，必须声明之后，立刻初始化，不能先声明后初始化，以下写法是错误的

int\[\] nums;

nums = \{1,3,5,7,9\};

**2）动态初始化:**

特点：由程序员来设置指定数组的长度（数组的元素个数），而每一个数组元素的初始值（默认值）有系统(JVM)决定。

语法:
        元素类型[] 数组名称 = new 元素类型[length];

![20190701224145801.png][]

注意：不能同时使用静态和动态初始化。如：int\[\] nums = new int\[5\]\{1,3,5,7,9\}; 错误的

**3、数组的基本操作**

<table> 
 <thead> 
  <tr> 
   <th>基本操作</th> 
   <th>操作说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>获取元素</td> 
   <td>元素类型 变量 = 数组名[index];</td> 
  </tr> 
  <tr> 
   <td>设置元素</td> 
   <td>数组名[index] = 值;</td> 
  </tr> 
  <tr> 
   <td>遍历数组元素</td> 
   <td>建议使用for循环，事先知道循环的次数。</td> 
  </tr> 
  <tr> 
   <td>数组长度</td> 
   <td>int len = 数组名.length; length是属性，不是方法。</td> 
  </tr> 
  <tr> 
   <td>索引范围</td> 
   <td>从0开始,逐一递增. [0,数组名.length-1]</td> 
  </tr> 
 </tbody> 
</table>

**  4、操作数组常见异常:  
 **     ArrayIndexOutOfBoundsException：数组的索引越界,不在索引范围之内.  
      NullPointerException：空引用异常,操作了一个为null的数组变量.

**5、多维数组**

一维数组：就是数组，数组中的每一个元素都是一个值。

二维数组：数组中的数组，数组中的每一个元素都是一个数组。(可以表示二维空间(行/竖))

三维数组：数组中的每一个元素都是一个二维数组。

例如：二维数组

int[][] arr = new int[][] { 
        { 1, 2, 3 }, 
        { 4, 5 }, 
        { 6 } 
    };

### 三、Java5对数组的支持 ###

**1、增强for循环(for-each)**

从 JAVA5 开始出现了增强for循环，可用来方便的迭代数组中的元素，而不涉及其下标，也可以遍历集合等。

for(元素类型 元素变量 :遍历对象){
        遍历元素变量
    }

String[] strs = { "aa", "bb", "cc"};
            for (String str : strs) {
                System.out.println(str);
            }

代码反编译后：

final String[] array2 = { "aa", "bb", "cc" };
            for (int length = array2.length, i = 0; i < length; ++i) {
                System.out.println(array2[i]);
            }

**增加for循环本质**

增强for循环,其实是一个语法糖(编译器级别的新特性),但是在字节码中/底层依然是for循环.

**使用for循环还是使用增强for循环?**

若需要取出数组元素，则使用for-each更简单。

但是若需要操作数组索引，就只能使用普通的循环。

**2、方法的可变参数**

方法的可变参数，说的是参数的个数可变，也是一个语法糖，其**底层就是一个数组类型**。

注意：为了避免歧义，语法规定，可变参数必须作为方法的最后一个参数。

public static void main(String[] args) {
            int sum = add(2, 5, 10, 10);
            System.out.println(sum);
        }
    
        public static int add(int x, int ... arr) {
            int sum = 0;
            for (int i : arr) {
                sum += i;
            }
            return sum * x;
        }

代码反编译后：

public static void main(String args[])
    	{
    		int i = add(2, new int[] {
    			5, 10, 10
    		});
    		System.out.println(i);
    	}
    
    	public static transient int add(int i, int ai[])
    	{
    		int j = 0;
    		int ai1[] = ai;
    		int k = ai1.length;
    		for (int l = 0; l < k; l++)
    		{
    			int i1 = ai1[l];
    			j += i1;
    		}
    
    		return j * i;
    	}

### 四、语法糖 ###

**1、什么是语法糖**

语法糖（**Syntactic Sugar**），也称糖衣语法，是由英国计算机学家 Peter.J.Landin 发明的一个术语，指在计算机语言中添加的某种语法。

这种语法对语言的功能并没有影响，但是更方便程序员使用。简而言之，语法糖让程序更加简洁，有更高的可读性。

**2、解语法糖**

语法糖的存在主要是方便开发人员使用。但其实，Java 虚拟机并不支持这些语法糖，这些语法糖在编译阶段就会被还原成简单的基础语法结构，这个过程就是解语法糖。

说到编译，大家肯定都知道，Java 语言中，javac命令可以将后缀名为.java的源文件编译为后缀名为.class的可以运行于 Java 虚拟机的字节码。

如果你去看com.sun.tools.javac.main.JavaCompiler的源码，你会发现在compile()中有一个步骤就是调用desugar()，这个方法就是负责解语法糖的实现的。

ends~

[20190701224145801.png]: /images/20211219/6c501f619dd045e096755b5429cb8353.png