java方法的定义以及数组的使用

• java方法的定义
• java数组的使用

---

java方法的定义

//方法的定义
public class MethodDemo{
      //需求：定义一个方法，专门打印10个@@@@
      //无参数，无返回类型
       static void print(){
        System.out.println("@@@@@@");
}
}
      //有参数无返回值
      //输出整型形参
      static void pValue(int aa){
       System.out.println(aa);
}
     //无参数，有返回值
     static int getAge(){
      return 17;
 }
 //有返回值，有参数
 static int getSum(int a,int b){
   return a+b;
}
//定义方法的区域
//把共同的重复代码抽离到方法中
static void doWork(){
    System.out.println("相同的1行代码");
        System.out.println("相同的2行代码");
        System.out.println("相同的3行代码");
        System.out.println("相同的4行代码");
}
//main方法
//main方法专门有JVM来负责调用，我们只管启动JVM
public static void main(String[] args) {
    System.out.println("代码段A");
    MethodDemo.doWork();
//  System.out.println("相同的代码200行");
    System.out.println("代码段B");
    MethodDemo.doWork();
//  System.out.println("相同的代码200行");
    MethodDemo.print();
    MethodDemo.pValue(22);//传入实参 回调的过程
//  MethodDemo.pValue(aa);
    pValue(22);
    int aa=getAge();
    int aa1=MethodDemo.getAge();
    System.out.println(aa);
    System.out.println(aa1);

    int ss1=getSum(123, 3213);
    int ss=MethodDemo.getSum(2, 4);
    System.out.println(ss);
    System.out.println(ss1);
    System.out.println(getSum(2, 44));
    /**
     * 循环操作（while， do while, for循环）
     * 目的：解决代码重复的问题，重复做某一件事情
     * 缺点：是有规律的，语句格式是相同的
     *不能解决所有的重复问题：
     *针对于某一种功能的重复操作，循环解决不了
     *此时得使用方法：
     *开发遵循的原则之一：DRY 重复意味着维护的成本增大。
     * 
     * 语法结构：
     * 方法的定义：
     * 方法  函数，特定功能的代码块。
     * 在程序中能够独立完成，可以重复使用的一段代码的集合。
     * 定义格式：
     * [修饰符] 返回值的类型 方法的名称（[形式参数...]）{
     *   方法体；
     *   [return 值];
     * }
     * 注意：函数包括（有参无餐 有返无返）
     * (1)方法必须调用才能生效
     * */
}
}

方法的重载设计

//方法的重载设计
/*public class MethodDemo02{
   static void aa(){
    System.out.println("aaaa");
}
    public static void main(String[] args){
       aa();                      
}
}*/

public class MethodDemo02{
//求两个数之和
    static int getSum1(int a,int b){
      return a+b;                 
  }
   static double getSum2(double a,double b){
      return a+b;
 }
  static double getSum3(double a,int b){
           return a+b;
}
  static float getSum(float a,int b){
           return a+b;      
}
  static float getSum(int a,int b,float c){
   return a+b+c;
}
  satic int getSum(int a,int b,int c){
          return a+b+c;        
}
  static void print(int a,String b,double c, boolean){
                System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
}
//方法的重载
static void print(int a){
     System.out.println(a);            
}
static void print(double a ){
System.out.println(a);
}
static void print(String a){
System.out.println(a);
}
static void print(boolean a){
System.out.println(a);
}
  public static void main(String[] args){
    //需求:在同一个类中，分别定义求两个整数，小数之和的方法
    System.out.println(MethodDemo02.getSum1(5, 2)); 
    System.out.println(MethodDemo02.getSum2(25.12, 4.87));
    MethodDemo02.getSum1(2,3);
    double sum=MethodDemo02.getSum2(2.6, 5.5);
    System.out.println(sum);
    MethodDemo02.getSum3(12.33,5);
}
}

#

方法的重载设计：overload
定义：在同一类中，方法允许存在一个以上同名方法，只要它们的方法参数不同就可。
如何判断方法重载
两同：同一个类，方法名相同
不同：方法参数列表不同
注意点：方法重载和方法返回类型无关，只是一般要求返回值类型一致
参数类别和参数的没有关系，方法的重载和形参没有关系

方法的中的术语及如何定义方法

public class MethodDemo03 {   
static int getSum(int a,int b){
    return a+b;
}
public static void main(String[] args) {
    //写求两个数的和
    int sum=MethodDemo03.getSum(3, 4);
    System.out.println(sum);

    sum=MethodDemo03.getSum(1, 2);
    System.out.println(sum);

    /*
     * 方法定义的格式：
     * [修饰符]返回值类型 方法名称（[形参1，形参2。。。]）{
     *   方法体；
     *   [如果方法需要给调用者一个返回值，用return值]；
     * }
     * 方法中的术语：
     * 修饰符：public,static 等。 static 直接使用类名调用。
     * 返回值类型：功能操作完毕之后，是否需要给调用者返回一个结果。不需要就用void
     * 方法名称：遵循标识符的规范，使用动词来表示，并且首字母要小写，如果多个单词
     * 组成，用小驼峰命名 getSumAndProess 小驼峰  GetSumAndProess 大驼峰
     * 形式参数：方法圆括号中的变量，仅仅只是一个占位符而已，参数的名称无所谓，形参可以有多个。
     * 参数列表：==参数类型+个数+顺序 
     * 方法签名：方法名称+方法参数列表
     * 注意：在同一个类中，方法签名是唯一，否则报错
     * 方法体：{}中的代码。具体完成功能的代码。
     * 返回值：在方法内部，使用return关键字。
     * 实际参数：调用者在调用某一个具体的方法的时候，实际传递的参数值。
     * 方法的调用者：在哪里调用某一个方法，那么哪里就是该方法的调用者。
     * 
     * 如何来定义/设计方法：
     * 定义方法：
     * （1）到底需要定义什么功能方法
     * （2）是否需要定义返回值类型
     * （3）是否需要形式参数
     * -------------------------
     * （1）是否需要定义返回值类型
     *  一个方法其实就是在完成某一个功能，完成之后，是否需要给调用者返回一个结果数据，不需要就用void声明。
     *  需要一个返回数据，就把该数据的类型，作为返回值类型。
     *  如：
     *  打印：在乎的是方法的过程，就用void
     *  求和：在乎的是结果的数据，需要有返回值
     * （2）是否需要形式参数
     * 该方法在完成该功能的过程中，是否有未知的因素，如果有请作为参数传递。
     * ------------------------------------------------
     * （1）无参数无返回值
     * （2）有参数无返回值
     * （3）无参数有返回值
     * （4）有参数有返回值
     * （见第一个例子methodDemo01）
     * */

数组和数组定义

静态初始化数组

//数组和数组定义
public class ArrayDemo {
   public static void main(String[] args) {
    /**
     * 数组的概念：一组数据
     * 把相同类型的若干个变量按照有序的形式组织起来的一种数据形式。
     * 数组中的数据称为-->元素
     * 索引：从0开始，步长为1
     * */

//   静态初始化数组
         Object arr[]=new Object[]{6,7,8,4,2,6,2,3,5,6};//索引从0开始
     System.out.println(arr.length);
       System.out.println(arr);//[I@1db9742 编码格式

//     取出arr数组中，索引为3 的元素
      int sel=arr[3];
      System.out.println(sel);
//    把arr数组索引为3的元素，重新设置为77
      arr[3]=77;
      //取出数组中每一个元素
      System.out.println(arr[0]);
      System.out.println(arr[1]);
      System.out.println(arr[2]); 
      。。。。
//或者
      for (int i = 0; i <arr.length; i++) {
        int j = arr[i];
        System.out.println(j);
    }
      System.out.println("--------------");

      String[] bs=null;
//    System.out.println(bs.length);
//    NullPointerException空指针异常
      int[] arr2={};
      System.out.println(arr2.length);//0  
}
}

动态初始化数组

//动态初始化数组
public class ArrayDemo02 { 
public static void main(String[] args) {
    //创建一个长度为5的数组
    int[] nums=new int[5];

    //创建一个长度为3的数组
    int[] nums2=new int[3];

    String[] names=new String[4]; 
    /**数组的定义：
     * 方式1:数组元素的类型[] 数组名：
     * int[] ages; 
     * 可以把int[]看成一种数据类型
     * 方式2：数组元素的类型 数组名[];
     * int ages[];
     * ---------------------
     * 注意：
     * 数组必须先初始化，才能使用，因为初始化表示在内存中分配空间。
     * ---------------------
     * 数组的操作：初始化数组两种操作方式：
     * （1）静态初始化
     * （2）动态初始化
     * 一旦初始化完成，数组的长度就固定了，不能改变，除非重新初始化。也就是说数组是定长的。
     * ------------------------
     * 数组静态初始化的特点：
     * 数组的长度由系统（JVM）决定，但是由我们来为每一个数组元素设置初始化值。
     * 语法格式：
     * 数组元素类型[] 数组名= new 数组元素类型[]{元素.......};
     * 
     * 实例化一个数组
     * 1.声明什么类型的数组
     * int[] nums;
     * 2.初始化数组 
     * new int[]{1,3,5}
     * 3.把初始化的值赋值给nums变量
     * int[] nums= new int[]{1,3,5};
     * */
    int[] numss=new int[]{0,1,1,2};
    int[] numss1={1,2,3,2};
}
}

数组的常用方法

public class ArrayDemo03 {
   public static void main(String[] args) {
       //存放5个奇数
       int[] sum=new int[]{1,3,5,7,9};
       System.out.println(sum.length);
           sum=new int[]{2,4,6}; 
           String[] names={"A","B","C"};
//     int[] arrays=new int[5]{2,4,5,8,8}; 动静结合，不允许
           int[] arrays=new int[]{2,4,5,8,8};
       /**
        * 注意点：
        * 1.当知道需要存储哪些数据的时候就使用静态。
        * 2.当不知道的时候就用动态
        * 3.不能使用动静结合。
        * 语法结构：
        * 数组元素类型[] 数组名= new 数组元素类型[length];
        * 数组元素类型[] 数组名= new 数组元素类型[]{元素1..........};
        * */   
   }
}

数组的操作

public class ArrayDemo04 { 
    //获取数组元素中最大元素
    static int getMax(int[] arr){
        int max=arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]>max) {
                max=arr[i];
            }
        }
        return max;
    }
    static int getMin(int[] arr){
        int min=arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]<min) {
                min=arr[i];
            }
        }
        return min;
    }
    //打印[A,B,C,D]
//  static void print(String[] arr){
    static void print(int[] arr){
        if (arr==null) {
            System.out.println("null");
            return;
        }

        String ret="[";
        for (int i = 0; i <arr.length; i++) {
            ret=ret+arr[i];
            if (i!=arr.length-1) {
                ret=ret+",";
            }
        }
        ret=ret+"]";
        System.out.println(ret);
    }
    static void print(String[] arr){
        String ret="[";
        for (int i = 0; i <arr.length; i++) {
            ret=ret+arr[i];
            if (i!=arr.length-1) {
                ret=ret+",";
            }
        }
        ret=ret+"]";
        System.out.println(ret);
    }

public static void main(String[] args) {

    int[] shuzu=new int[]{1,154,234,342,51};
    int max=getMax(shuzu);
    int min=getMin(shuzu);
    System.out.println(max);
    System.out.println(min);
    String[] hg=new String[]{"a","b","c"};
    ArrayDemo04.print(hg);
    ArrayDemo04.print(shuzu);
}
}
----------------------------
//数组的操作
public class ArrayDemo05 {
    //查询key元素在数组中第一次出现的位置
    /*参数：
     * arr:从哪一个数组中去做查询
     * key:当前查询的元素
     * 返回值:如果key存在于arr数组中，则返回第一出现的索引的位置
     * 如果key不存在，返回-1
     * 线性搜索
     * */
      //key在数组中最先出现的索引
    static int indexOf(int[] arr,int key){
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]==key) {
                return i;
            }
        }
        return -1;
    }
    //key在数组中最后出现的索引
    static int lastOf(int[] arr,int key){
        for (int  i=arr.length-1; i>=0;i--) {
            if (arr[i]==key) {
                return i;
            }
        }
        return -1;
    }
    public static void main(String[] args) {
    int[] shuzu=new int[]{45,32,48,63,42};
    int[] arr=new int[]{2,2,3,4,1,2};
        int i=ArrayDemo05.indexOf(shuzu, 45);
        System.out.println(i);
        int x=ArrayDemo05.lastOf(arr, 2);
        System.out.println(x);
        //索引
        int[] arr3={2,2,3,4,1,2};
        System.out.println(arr3.length);    
}
}
-------------------------------
//逆序打印数组元素
public class ArrayDemo06 {
    /*
     * 原数组：[a,b,c,d]
     * 逆序操作
     * 新数组：[d,c,b,a]
     * */
//  打印[a,b,c]
  static void print(String[] arr){
        String str="[";
        for(int i=arr.length-1;i>=0;i--){
          str=str+arr[i];
          if(!i=0){
              str=str+",";
}else{
   System.out.println("数组为空");
}
str=str+"]";
System.out.println(str);
}
public static void main(String[] args) {
     String[] arr={"A","B","C"};
     ArrayDemo06.print(arr);
}
}

多维数组

public class MoreArrayDemo {
     static void getArray(int[] arr){
         for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"	");
        }
     }
    public static void main(String[] args) {
    /**
     * 数组：用于存放数据，好比是容器。
     * int[] num1={1,2,3,4};
     * int[] num2={4,5,6,7};
     *一维数组:每一个元素都是一个值（基本类型和引用类型的值）
     *二维数组:每一个元素都是一个一维数组
     *三维数组:每一个元素都是一个二维数组
     * */
    int[] arr1={1,2,3,4};   
    int[] arr2={2,3,4,5};
        int[] arr3={3,4,5,6};
    int[][] arr4={arr1,arr2,arr3};
    System.out.println(arr4[2][0]); //3  从0数起，第一个[]表示第几个数组 第二个[]表示第几个元素
    int[][] arr5={arr2,arr3};
    int[][][] arr6={arr4,arr5};
    System.out.println(arr6[0][1][2]);  //三维数组 同理
    int[][] arr7=new int[][]{
        {1,2,3},
        {3,4,5},
        {6,7,8}
    };
    System.out.println("--------------for-each-----------");
    for (int[] is : arr5) {
        System.out.println(is);
    }
    System.out.println("------");
    System.out.println(arr7.length);
    System.out.println(arr7[2][2]);
        for (int i = 0; i < arr7.length; i++) {
            System.out.println(arr7[i]);
            for (int j = 0; j < arr7[i].length; j++) {
                System.out.println(arr7[i][j]);
            }
        }

    //2.java5对数组的支持
        /**
         * 增强for循环--->for-each
         * Java5开始，jdk1.5开始，Java提供了多种新的语法
         * 增强for循环（for-each）
         * for-each语法格式：
         * for（数组元素类型 变量：数组名）{
         *    循环体；
         * }
         * */
        //案例：定义一个数组，使用循环遍历数组中的每一个元素
        int[] arr=new int[]{1,2,354,22,42};
        MoreArrayDemo.getArray(arr);

        int[] arr11=new int[]{1,2,354,22,42};
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        //for-in for-each
        for (int ele : arr) {
            System.out.println(ele);
        }
        /**
         * for-each循环遍历
         * 语法糖：编译器级别的新特性
         * 底层依然是for循环。
         * 什么时候使用？
         * 如果需要取出数组元素的索引，就用for循环。
         * 如果只是需要取出数组的元素，就用for-each简单。
         * 区别：
         * for循环遍历元素+元素的索引
         * for-each只遍历元素
         * */
//      写出一个二维数组，用for-each遍历
           int[][] arr8=new int[][]{
                {1,2,3},
                {3,4,5},
                {6,7,8}
            };
            for (int[] x : arr8) {
                for (int i : x) {
                    System.out.println(i);
                }
            }

    //尝试用动态创建二维数组
    int[][] array9=new int[5][];//null
    int[][] array10=new int[0][3];
    int[][] array11=new int[0][0];
    //int[][] arr123=new int[][123];
    //Cannot specify an array dimension after an empty dimension
    for (int i = 0; i < array9.length; i++) {
        System.out.println(array9[i]);
        for (int j = 0; j <array9[i].length; j++) {
            System.out.println(array9[i][j]);//java.lang.NullPointerException
            }
        }
    }   
}

---

补充

判断：
void doWork(int a, char b,boolean c){}
下列哪个方法是上述方法的重载方法？
1.void doWork(char a , int b,boolean c)
2.int doWork(boolean a, char c,int b)
3.void doWork(int a, char b,double c)
4.void doWork(int x, char b,boolean z)
5.int doWork(int x, double y)
6.int doWork(int a, char y,boolean z)

阅读更多