5. 方法与数组

1:方法(掌握)

       (1)方法：就是完成特定功能的代码块。

              注意：在很多语言里面有函数的定义，而在Java中，函数被称为方法。

       (2)格式：

              修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {

                     方法体语句;

                     return 返回值;

              }

详细解释：

              修饰符：目前就用 public static。后面再详细讲解其他修饰符

              返回值类型：就是功能结果的数据类型

              方法名：就是起了一个名字，方便我们调用该方法。

              参数类型：就是参数的数据类型

              参数名：就是变量

              参数分类：

                     实参：实际参与运算的数据

                     形参：方法上定义的，用于接收实际参数的变量

              方法体语句：就是完成功能的代码块

              return：结束方法以及返回方法指定类型的值

              返回值：程序被return带回的结果，返回给调用者。

       (3)两个明确：

              返回值类型：结果的数据类型

              参数列表：你要传递几个参数，以及每个参数的数据类型

       (4)方法调用

              A:有明确返回值的方法

                     a:单独调用，没有意义

                     b:输出调用，不是很好，因为我可能需要不结果进行进一步的操作。但是讲课一般我就用了。

                     c:赋值调用，推荐方案

class FunctionDemo {   publicstatic void main(String[] args) {          int x = 10;          int y = 20;          //方式1：单独调用          //sum(x,y);          //方式2：输出调用          //System.out.println(sum(x,y));          //System.out.println(30);          //方式3：赋值调用          int result = sum(x,y);          //result在这里可以进行操作          System.out.println(result);   }   /*          需求：求两个数据之和的案例          两个明确：                 返回值类型：int                 参数列表：2个，都是int类型。   */   publicstatic int sum(int a,int b) {                 //如何实现呢?                 //intc = a + b;                 //returnc;                 //c就是a+b,所以，我可以直接返回a+b                 returna + b;   }

              B:void类型修饰的方法

                     a:单独调用

class FunctionDemo3 {       publicstatic void main(String[] args) {              //单独调用              pringXing(3,4);              System.out.println("--------------");              pringXing(6,7);              System.out.println("--------------");              pringXing(8,9);              //输出调用(错误)              //此处不允许使用 '空' 类型              //System.out.println(pringXing(3,4));              //赋值调用(错误)              //非法的表达式开始              //void v = pringXing(3,4);       }   /*          写一个什么样子的方法呢?写一个m行n列的代码          两个明确：                 返回值类型：这个时候没有明确的返回值，不写东西还不行，所以，这里记住是void                 参数列表：int m,int n   */       publicstatic void pringXing(int m,int n) {              for(int x=0; x<m; x++) {                     for(inty=0; y<n; y++) {                            System.out.print("*");                     }                     System.out.println();              }       }}

       (5)案例有(用方法调用改进)：

              A:求和方案

              B:获取两个数中的较大值

              C:比较两个数据是否相同

              D:获取三个数中的最大值

              E:输出m行n列的星形

              F:输出nn乘法表

       (6)方法的注意事项

              A:方法不调用不执行

              B:方法之间是平级关系，不能嵌套定义

              C:方法定义的时候，参数是用，隔开的

              D:方法在调用的时候，不用在传递数据类型

              E:如果方法有明确的返回值类型，就必须有return语句返回。

class FunctionDemo2 {   publicstatic void main(String[] args) {          /*          错误的          public static int sum(int a,int b){                 returna + b;          }          */          //sum(10,20);          //int x = 10;          //int y = 20;          //错误          //sum(int x,int y);   }   publicstatic int sum(int a,int b){          return a + b;   }}

       (7)方法重载

              小知识：在同一个类中，方法名相同，参数列表不同。与返回值无关。

                     参数列表不同：

                     参数的个数不同。

                     参数的对应的数据类型不同。

       (8)方法重载案例

              不同的类型的多个同名方法的比较。

 

class FunctionTest6 {    publicstatic void main(String[] args) {           //测试           byte b1 = 3;           byte b2 = 4;           System.out.println("byte:"+compare(b1,b2));           //测试           short s1 = 5;           short s2 = 5;           System.out.println("short:"+compare(s1,s2));           //后面的两个自己测试    }    //byte类型    publicstatic boolean compare(byte a,byte b) {           System.out.println("byte");           return a == b;    }    //short类型    publicstatic boolean compare(short a,short b) {           System.out.println("short");           return a == b;    }    //int类型    publicstatic boolean compare(int a,int b) {           System.out.println("int");           return a == b;    }    //long类型    publicstatic boolean compare(long a,long b) {           System.out.println("long");           return a == b;    }}

2:数组(掌握)

       (1)数组：存储同一种数据类型的多个元素的容器。

       (2)特点：每一个元素都有编号，从0开始，最大编号是长度-1。

               编号的专业叫法：索引

       (3)定义格式

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

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

              推荐是用A方式，B方法就忘了吧。

              但是要能看懂

注意：数组操作常见的两个小问题

l 数组索引越界

•   ArrayIndexOutOfBoundsException

•   访问到了数组中的不存在的索引时发生。

l 空指针异常

•   NullPointerException

•   数组引用没有指向实体，却在操作实体中的元素时

       (4)数组的初始化

              A:动态初始化

                     只给长度，系统给出默认值

                     举例：int[]arr = new int[3];

              B:静态初始化

                     给出值，系统决定长度

                     举例：int[]arr = new int[]{1,2,3};

                     简化版：int[]arr = {1,2,3};

       (5)Java的内存分配

              A:栈 存储局部变量

              B:堆 存储所有new出来的

              C:方法区(面向对象部分详细讲解)

              D:本地方法区(系统相关)

              E:寄存器(CPU使用)

              注意：

                     a:局部变量在方法定义中或者方法声明上定义的变量。

                     b:栈内存和堆内存的区别

                            栈：数据使用完毕，就消失。

                            堆：每一个new出来的东西都有地址

                               每一个变量都有默认值

                                                 数据类型                           默认值

    Byte        Short      Int          Long              0

                            Float       Double                                       0.0

                            Char                                                       '\u0000'

                            Boolean                                                    false

                            引用类型                                                null

                            数据使用完毕后，在垃圾回收器空闲的时候回收。

       (6)数组内存图

              A:一个数组

              B:二个数组

              C:三个数组(两个栈变量指向同一个堆内存)

       (7)数组的常见操作

数组的属性：length（专门用于获取数组的长度）

              A:遍历

                     方式1：                            publicstatic void printArray(int[] arr) {                                   for(int x=0; x<arr.length; x++) {                                          System.out.println(arr[x]);                                   }                            }                     方式2：                            publicstatic void printArray(int[] arr) {                                   System.out.print("[");                                   for(int x=0; x<arr.length; x++) {                                          if(x== arr.length-1) {                                                 System.out.println(arr[x]+"]");                                          }else {                                                 System.out.println(arr[x]+",");                                          }     }     }

              B:最值

                     最大值：                            publicstatic int getMax(int[] arr) {                                   int max = arr[0];                                   for(int x=1; x<arr.length; x++) {                                          if(arr[x]> max) {                                                 max = arr[x];                                          }                                   }                                   return max;                            }                     最小值：                            publicstatic int getMin(int[] arr) {                                   int min = arr[0];                                                                     for(intx=1; x<arr.length; x++) {                                          if(arr[x] < min) {                                                 min= arr[x];                                          }                                   }                                   return min;                            }

              C:逆序

                     方式1：                            publicstatic void reverse(int[] arr) {                                   for(int x=0; x<arr.length/2; x++) {                                          inttemp = arr[x];                                          arr[x]= arr[arr.length-1-x];                                          arr[arr.length-1-x]= temp;                                   }                            }                     方式2：                            publicstatic void reverse(int[] arr) {                                   for(int start=0,end=arr.length-1;start<=end; start++,end--) {                                          inttemp = arr[start];                                          arr[start]= arr[end];                                          arr[end]= temp;                                   }                            }

              D:查表

                            publicstatic String getString(String[] strArray,int index) {                                   return strArray[index];                            }

              E:基本查找

                     方式1：                            publicstatic int getIndex(int[] arr,int value) {                                   for(int x=0; x<arr.length; x++) {                                          if(arr[x]== value) {                                                 return x;                                          }                                   }                                   return -1;                            }                     方式2：                            publicstatic int getIndex(int[] arr,int value) {                                   int index = -1;                                                              for(int x=0; x<arr.length; x++) {                                          if(arr[x]== value) {                                                 index = x;                                                 break;                                          }                                   }                                   return index;                        }