Java学习第五天 数组和方法

数组

数组的反转

　　数组的反转：数组中的元素颠倒顺序，例如：元始数组为1,2,3,4,5    数组反转之后为5,4,3,2,1

　　思路：本质是考察交换两个变量的值  两种方式

• • • 实现反转，就需要将数组最远端和最近段位置互换
    • 定义两个变量，保存数组的最小索引和数组的最大索引
    • 让两个索引上的元素交换位置
    • 最小的索引变量++ ， 最大的索引变量-- ， 再次交换位置
    • 最小的索引超过了最大索引，数组反转结束

准备一个需要反转的数组 int[] arr = {1,2,3,4,5,6}
定一两个说因变量,一个索引变量指向最小索引,一个索引变量指向最大索引
int min = 0;
int max = arr.length-1;
遍历数组,让两个索引变量产生变化
min++;
max--;
条件 min < max
交换最小索引元素和最大索引元素;需要定义第三变量
int tem = 0;
temp = arr[min];  // 把最小的索引元素赋值给第三方变量temp
arr[min] = arr[max];  // 把最大的索引元素赋值给最小的索引元素
arr[max] = temp;  // 把第三方变量的值赋值给最大索引的元素

public static void main (String[] args){
    int[] arr = {1,2,3,4,5};
//遍历数组for
for(int min = 0,int max = arr.length;min<max;min++,max--){
int temp = 0;
temp = arr[min];
arr[min] = arr[max];
arr[max] = temp;
    }
//查看反转之后的数组  遍历数组
 for (int i = 0; i <= arr.length-1; i++) {
                  System.out.println(arr[i]);
              }
 // 第二种思路：
             int[] arr = {1,2,3,4,5};
             // 遍历数组
             for (int i = 0; i < arr.length / 2 ; i ++) {
                 // 交换变量
                 int temp = 0;
                 temp = arr[i];
                 arr[i] = arr[arr.length-1-i];
                 arr[arr.length-1-i] = temp;
              } 
}        

二维数组

　　　　定义方式: 和一维数组是一样的,也有三种方式

　　方式一

数组的数据类型[ ][ ] 数组名称 = new 数组的数据类型[长度1][长度2];

长度1 不可省略,代表该二维数组里面存储的元素个数

长度2 可以省略, 代表该二位数组里面的元素(数组里面的元素个数) , 而且他里面的数组元素个数一样

如:  int[ ][ ] arr = new int [3][2];

长度3------->该arr数组里面有3个元素(数组)

长度2------->该arr数组里面的每个数组都有两个元素

相当于----->  int [][] arr = {{0,0},{0,0},{0,0}};

　　方式二

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

　　方式三

数组的数据类型[][] 数组名称  = {{元素1,元素2,....},{元素1,元素2,....},{元素1,,元素2,元素3,...},....};

二维数组元素访问方式

　　借助于[索引]

　　格式:

数组名称[索引] ------->访问的是二维数组的元素
//访问二维当中的一维数组里面的元素
数组名称[一维数组的索引值][一维数组里面的元素索引值]
如 int[][] arr {{10,20,50},{30,40,80},{15,100}};
//访问arr数组当中的10元素
arr[0][0]=10;
//访问arr数组的80元素
arr[1][2] = 80;

方法

　　方法:在程序中要去实现的某一个功能,需要包含多条语句,这些语句包含循环语句结构,选择语句结构等来共同处理一件事情

定义方法的格式详解

    public static void main(String[] args) {
          // 方法体内容
          
    }
方法比喻成工厂
        蒙牛工厂    
                   产出物：奶制品
         void      空的，无效的，
         String[] args  参数--->变量

方法定义的完整格式:修饰符  返回值类型  方法名称(参数类型1 参数名称1,参数类型2 参数名称2,...){  }

　　修饰符 : public static 

　　返回值类型: 方法的名字,名字自定义--->标识符,采用小驼峰命名法

　　参数类型: 进入方法当中的数据是一个什么样的类型

　　参数名称: 进入方法当中的数据对应的变量名称

　　方法体: 方法需要执行的功能,有若干行代码组成的.

　　return: 一般认为有两个作用,第一将后面的返回值返回给程序; 第二停止当前正在执行的方法.

　　返回值:就是方法执行最终产生的数据结果.

备注: 1. return 后面的返回值,必须和方法声明上的"返回值类型"保持一致.

2.方法不允许嵌套,不允许定义在类的外面

3.方法只能并列,并且必须定义在类的里面.

方法调用[重点]

　　三种调用格式:

1. 单独调用:方法名称(参数具体值);
2. 打印调用: System.out.println(方法名称(参数具体值));
3. 赋值调用：数据类型 变量名称 = 方法名称(参数具体值);

备注：当返回值类型为void的时候，这种方法只能单独调用，不能进行打印调用或者赋值调用。

返回值类型一般可以理解为数据类型(基本数据类型和引用数据类型)，此外还包含一种类型void类型

当方法执行完毕不需要给程序调用者返回任何的数据结果时，可以指定该方法的返回值类型为void，

此时只能【单独调用】。

注意事项：

1.方法定义的先后顺序无所谓

2.方法定义不能嵌套，不能在一个方法内部定义另外一个方法

3.方法定义之后，自己不会执行；如果希望执行，一定要进行方法的调用。

方法重载

　　对于功能类似的方法来说,因为参数列表不一样,却需要定义不同的方法名称,对于开发者来说,记忆那么多的功能类似的不同方法名,非常麻烦.

public class MethodDemo03 {
            
            public static void main(String[] args) {   
               // 计算一个整数和一个小数的和，整数为第一个参数，小数为第二个参数
               //int number = sum(10,3.14);
               //  计算一个整数和一个小数的和，小数为第一个参数，整数为第二个参数
              // int number02 = sum(3.14,10); 
                
            }
            // 计算两个数的和,得到一个整数
            // 计算两个整数的和
            public static int sum(int a,int b) {
              
                return (a+b);
            }
            // 计算两个小数的和
            public static int sum(double a,double b) {
                
                return (int)(a+b);
            }
            // 计算一个整数和一个小数的和
            public static int sum(int a,double b) {
                
                return (int)(a+b);
            } 
            // 计算一个整数和一个小数的和
            public static int sum(double a,int b) {
                
                return (int)(a+b);
            }
            
            public static double sum(double d1,int integer) {
                
                return (d1+integer);
            }
            
        }
【如果在类中定义方法时，方法的参数列表不一致，虽然方法名称一样，但是程序会认为这是一个新方法。】

方法重载(Ocerload) : 在一个类中,多个方法名一样,但是参数列表不一样

好处:只需记住唯一一个方法名即可,就可以实现类似的多个功能.

方法重载与哪些因素有关:

　　1.参数个数不同

　　2.参数类型不同

　　3.参数的多类型顺序不同

方法重载与哪些因素无关:

　　1.与参数的名称无关

　　2.与方法的返回值类型无关

　　3.与方法的修饰符无关

方法重载练习:在调用输出语句时,不管传入什么类型的数据,都把该数据打印在控制台中.

　　　　　　

　　　　　　模拟输出语句中的println方法效果,传递什么类型的数据就输出什么类型的数据,只允许定义一个方法名peintln.

// 判断以下哪些方法是重载关系
public static void add(){}
public static void add(int a){}
static void add(int a,int b){}
public static void add(double a,int b){}
public static void add(int a,double b){}
public void add(int i,double d){}
public static void ADD() {}
public static void add(int i,int j){}

数组作为方法参数和返回值

　　数组作为方法参数

数组作为引用类型能够当成方法的参数进行传递么? 当然可以

　　　　数组作为方法传递,传递的参数是数组内存地址.

public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        // 调用方法，传递数组
        println(arr);
    }
    /*
         创建方法，方法接收数组类型的参数
         进行数组的遍历
    */
   public static void println(int[] arr) {
       // 数组遍历
       for (int i = 0; i <= arr.length-1;i++) {
           System.out.println(arr[i]);
       }
   }

数组作为方法的返回值

• 数组作为方法的返回值，返回的是数组的内存地址。

• public static void main(String[] args) {
          // 调用方法，接收数组的返回值
          // 接收到的是数组的内存地址
          int[] arr = getArray();
          System.out.println(arr);// 此时是一个内存地址哈希值
      }
      /*
          创建方法，返回值是数组类型
          return 返回数组的内存地址
      */ 
     public static int[] getArray() {
         int[] arr = {1,3,5,9,11};
         // 此时返回数组的内存地址，返回给调用者
         return arr;
     }

  一个方法可以有0,1,多个参数；但是只能有0个或者1个返回值，不能有多个返回值。

  如果我们希望一个方法当中产生的了多个结果数据，这些多个结果数据同时需要返回

  解决方案：使用一个容器(数组)作为方法的返回值类型即可。

• public static void main(String[] args) {
          int a = 10;
          int b = 20;
          change(a,b);
          System.out.println(a);// a = 10
          System.out.println(b);// b = 20    
      }
      public static void change(int a,int b) {
          a = a+ b;//  a = 30
          b = b + a;// b = 50 
      }

   public static void main(String[] args) {
           int[] arr = {10,20};
           changeArray(arr);
           System.out.println(arr[0]);// arr[0] = 10?---->30
           System.out.println(arr[1]);// arr[1] = 20?---->50
       }   
       public static void changeArray(int[] arr) {
           arr[0] = 30;
           arr[1] = 50;
       }