Java中的方法与数组

小灰灰 2023-10-09 16:28 6阅读 0赞

**目录**

1.Java中的方法

1.1方法的创建与格式

1.2方法的调用格式

2.数组

2.1数组的基本概念

2.2数组的声明

2.3数组的创建

2.4数组的长度

3.数组的访问与迭代

3.1数组元素的访问

3.2数组元素的迭代

4.数组的排序

4.1冒泡排序

4.2选择排序

5.二维数组

5.1二维数组的创建

5.2二维数组的赋值

5.3二维数组的遍历

--------------------

## 1.Java中的方法 ##

### 1.1方法的创建与格式 ###

[访问权限修饰符 修饰符][返回值类型]方法名（形式参数类型 参数名）{
            Java语句;
            [return 返回值;]
    }

**修饰符：**  是可选的，是为了告诉编译器如何调用该方法。定义了该方法的访问类型。

**形式参数**： 在方法被调用时用于接收外界输入的数据。

**实参：** 调用方法时实际传给方法的数据。

**返回值：** 方法在执行完毕后返还给调用它的环境的数据。

**返回值类型：**事先约定的返回值的数据类型，如无返回值，必须给出返回值类型 void 。

eg：
    // 调用时候直接调用方法名
    // void:表示无返回值
    public static void hello(){
          System.out.println("Hello！");
    }

定义一个无参,无返回值的方法  
public static是固定写法  
void表示此方法没有返回值  
hello方法名  
()参数列表 可以为空

方法: 用来解决某一个问题的代码集合,可以被多次调用.

定义一个有参,有返回值的方法

public static int max(int a,int b){
    //        比较大小
            int max=(a>b)?a:b;
            return max;
        }

在调用这个方法的时候，还要输入参数，但要注意的是，输入的参数格式需要与方法中定义的数据类型相同。

例如：在这个代码中，定义的a，b的数据类型为整数型，你在给参数的时候，就不可以给大于int类型的或者浮点型或者是字符型等等，这样系统就会报错。

### 1.2方法的调用格式 ###

在调用方法时候：用方法所在的类名+.+方法名。

eg：调用上边代码所创建的方法，设类为FangFa，

Fangfa.max（）；

这时候执行代码，就会调用自己创建的方法。

public class FangFa {
        public static void main(String[] args) {
            int a=FangFa.max(8,5);//调用比较大小的方法，将方法中返回的值赋给变量a。
            System.out.println(a);
        }
    }
    public static int max(int a,int b ){
            int max = (a>b)?a:b;
            return max; 
    }

return max: 通过return关键字返回方法处理后的结果. 一个是终止方法,一个是返回结果。

在没有返回的方法中,也可以使用return关键字,但是return的后面不能有其他的表达式.作用就是用来终止方法。

eg：

public  static void hello(String name){
              if(name==null){
                  return;
    }

在这里，调用方法时候，你需要在控制台里输入name，如果你没有输入，就会进入if语句，这时候的return就起到了终止方法的作用。

## 2.数组 ##

### 2.1数组的基本概念 ###

*  数组就是相同数据类型元素的一个集合。
 *  数组本身是引用数据类型，也就是对象。
 *  数组既可以存储基本数据类型，也可以存储引用数据类型。

### 2.2数组的声明 ###

数组的声明有两种形式：

1.  数据类型 \[ \] 数组名 eg：int \[ \] a;
2.  数据类型 数组名 \[ \] eg: int a \[ \];

注意：这两种形式其实没啥区别，但Java中为了避免混淆a的数据类型，尽可能的使用第一种。

eg：int a \[ \] b; //这里的a表示的数组，b表示的是整数型变量。

### 2.3数组的创建 ###

数组的创建有三种形式：

1.  声明数组的同时，根据数组内元素的长度分配内存，但数组中元素值都为默认的初始化值eg：int \[ \] a = new int \[10\];
2.  声明数组并分配内存，同时将其初始化。eg：int \[ \] a = new int \[ \]\{1,2,3\};
3.  与前一种方式相同，语法相对简略。 eg：int \[ \] a = \{1,2,3\};

注意：java中的数组,一旦在创建时容量确定了,就不能进行容量修改。

数组的创建还可以分为动态和静态两种形式：

1.  动态创建数组（没有给定数组元素） eg：int \[ \] a = new int \[3\];当你没有给数组进行赋值的时候，数组中默认的元素就是0。
2.  静态创建数组（在创建的时候就给数组进行了赋值）

### 2.4数组的长度 ###

length属性：

int a \[ \] = \{1,2,3,4,5,6\};

System.out.println(a.length);//输出的就是数组a的长度。

输出：6

## **3.数组的访问与迭代** ##

### 3.1数组元素的访问 ###

数组名字\[索引\]； eg：a\[0\],a\[1\];

注意：

*  数组的索引从0开始。 
 *  索引的数据类型是整型 
 *  索引最大值和数组长度始终差1

### 3.2数组元素的迭代 ###

第一种：for循环

int [] a = {1,2,3,4};
    for(int i=0;i<a.length;i++){
         System.out.println(Arrays.toString(a[i]));
    }

第二种：增强for循环

int [] a = {1,2,3,4};
    for(int t:a){
         System.out.println(t);
    }

## 4.数组的排序 ##

### 4.1冒泡排序 ###

原理：每次去出两个相邻的元素进行对比，将大的放在后边，小的放在前面，每次排序，得到最大的元素。  
思想：

\{5,4,3,2,1\}

4,3,2,1,5

3,2,1,4,5

2,1,3,4,5

1,2,3,4,5

代码如下：

int [] a = {5,4,3,2,1};
    for(int i = 0;i < a.length-1;i++){   //外循环，表示循环次数
        for(int j = 0；j < a.length-1-i；j++){   //内循环，外循环一次取出当前最大值，在内循环时候就少判断一次
           if(a[j]>a[j+1]){
               int t = a[j];
               a[j] = a[j+1];
               a[j+1] = t; 
          }
       }
    System.out.println(Arrays.toString(a));
    }

### 4.2选择排序 ###

原理：选择排序就是把两个相邻的元素进行比较，把较小的元素放在前面，然后用较小的元素与下一个元素进行排序，一次选出当前最小的元素。

思想：

\[3 ,1 ,2 ,5 ,4\]  
1 ,3 ,2 ,5 ,4  
1 ,2 ,3 ,5 ,4  
1 ,2 ,3 ,5 ,4  
1 ,2 ,3 ,4 ,5

代码如下：

int [] a = {3,1,2,5,4};
                for (int i = 0; i < a.length-1; i++) {
                    for (int j = i+1; j <a.length; j++) {
                        if(a[i]>a[j]){
                            int t = a[i];
                            a[i] = a[j];
                            a[j] = t;
                        }
                    }
                    System.out.println(Arrays.toString(a));
                }

## 5.二维数组 ##

### 5.1二维数组的创建 ###

二维数组的创建和一维数组类似：

数据类型 \[ \] \[ \] 数组名 = new 数据类型 \[一维数组的容量\] \[每个一维数组内元素的个数 \]；

eg：

int \[ \] \[ \] a = new int \[3\]\[5\]; //容量一旦确定就不可以改变

### 5.2二维数组的赋值 ###

有两种:

1.  int \[\] \[\] a = \{ \{1,2.3\}，\{1,2,3\}，\{1,2,3\}\};
2.  int \[\] \[\] a = new int \[\] \[\]\{ \{1,2,3\}，\{1,2,3\}，\{1,2,3\}\}；

### 5.3二维数组的遍历 ###

二维数组的遍历同样可以采用for循环，只不过需要双层嵌套：

public static void main(String[] args) {
                int [][] a = {
         {1,2,3},{4,5,6},{7,8,9}};
                for (int i = 0; i < a.length; i++) {        //a.length就是二维数组中一维数组的长度
                    for (int j = 0; j <a[i].length; j++) {
                        System.out.print(a[i][j]+" ");
                        }
                    System.out.println();
                    }
                }

--------------------

注意：

Java的学习要多练习,加油！