Java方法详解

Java方法详解

方法

1. System.out.println(); System是一个系统的类 out是一个对象 println是一个方法

2. Java方法是语句的集合，它们在一起执行一个功能

   • 方法是解决一类问题的步骤的有序集合
   • 方法包含于类或对象中
   • 方法在程序中被创建，在其它地方被引用

3. 设计方法的原则

   • 方法的本意是功能块，就是实现某个功能的语句块的集合。设计方法的时候，最好保持方法的原子性，就是一个方法只完成1个功能，这样利于我们后期的扩展

4. 方法的命名规则

   • 首字母小写，驼峰规则

5. public class Demo01 {
       //main方法
       public static void main(String[] args) {
           int sum = add(1,2);
           System.out.println(sum);
           test();
       }
       public static int add(int a,int b){
           return a+b;
       }
       public static void test(){
           int i = 1;
           int s= 0;  //被5整除的数的数目
           for(i=1;i<=1000;i++){
               if(i%5==0){
                   System.out.print(i+" ");
                   s++;
                   if(s%3==0){
                       System.out.println();
                   }
               }
           }
       }
   }
   public class Demo01 {
       //main方法
       public static void main(String[] args) {
           int sum = add(1,2);
           System.out.println(sum);
       }
       public static int add(int a,int b){
           return a+b;
       }
   }
   

方法的定义

1. Java的方法类似于其它语言的函数，是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法：

2. 方法包含一个方法头和一个方法体，下面是方法的所有的部分：

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

   • 返回值类型：方法可能会有返回值。returnValueType是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。这种情况下，returnValueType是关键字void

   • 方法名：是方法的实际名称。方法名和参数表共同构成方法签名

   • 参数类型：参数像一个占位符，参数是可选择的，方法可以不包含任何参数

     形式参数：在方法被调用时用于接收外界输入的数据 实参：调用方法时实际传给方法的数据

   • 方法体：包含具体的语句，定义该方法的功能

   • 修饰符 返回值类型  方法名(参数类型 参数名){
         ......
             方法体
             .....
             return 返回值；
     }
     

3. //方法的定义
   public class Demo02 {
       public static void main(String[] args) {
           int max = max(2,3);
           System.out.println(max);
       }
       //比大小
       public static int max(int num1,int num2){
           int result = 0;
           if(num1>num2){
               result =  num1;
           }else if(num1<num2){
              result = num2;
           }else{
               System.out.println("num1==num2");
               return 0;
           }
           return result; //return终止方法
       }
   }
   
   

方法的调用

1. 调用方法：对象名.方法名(实参列表)

2. Java支持两种调用方法的方式，根据方法是否返回值来选择。

3. 当方法返回一个值的时候，方法调用通常被当作一个值，例如：

4. int larger = max(30,40);
   

5. 如果方法返回值是void，方法调用一定是一条语句，例如：

6. System.out.println("Hello,ss!");
   

7. 值传递：（Java是值传递）在调用函数时，将实际参数复制一份传递到函数中，这样在函数中对参数进行修改，就不会影响到原来的实际参数 即值传递传递对象的一个副本

   • public static void main(String[] args) {
         int i = 10;
         it(i);
         System.out.println(i);
     }
     
     public static void it(int i) {
         i = 15;
     }
     //运行结果  10
     

8. 引用传递：在调用函数时，将实际参数的地址直接传递到函数中。这样在函数中对参数进行的修改，就会影响到实际参数

方法的重载

1. 在一个类中，有相同函数名称，形参不同的函数

2. 方法的重载的规则：

   • 方法的名称必须相同
   • 参数列表必须不同(个数不同、或类型不同、参数排列顺序不同等)
   • 方法的返回类型可以相同也可以不相同
   • 仅仅返回类型不同不足以成为方法的重载

3. 实现理论

   • 方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错

4. //方法的重载
   public class Demo03 {
       public static void main(String[] args) {
           double max = max(2.0,3.0);
           System.out.println(max);
       }
       //比大小
       public static int max(int num1,int num2){
           int result = 0;
           if(num1>num2){
               result =  num1;
           }else if(num1<num2){
               result = num2;
           }else{
               System.out.println("num1==num2");
               return 0;
           }
           return result; //return终止方法
       }
       //比大小
       public static double max(double num1,double num2){
           double result = 0;
           if(num1>num2){
               result =  num1;
           }else if(num1<num2){
               result = num2;
           }else{
               System.out.println("num1==num2");
               return 0;
           }
           return result; //return终止方法
       }
   }
   

命令行传参

1. 运行程序时候再传递给它消息，要靠传递命令行参数给main函数实现

2. 运行的时候一定要找到包的路径，否则是运行不了的

3. 

可变参数（不定项参数）

1. JDK1.5时，Java支持传递同类型的可变参数给一个方法

2. 在方法声明中，在指定参数后面加一个省略号(...)

3. 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明

4. //可变参数
   public class Demo05 {
       public static void main(String[] args) {
           //对象调用方法，不需要static
           Demo05 demo05 = new Demo05();
           demo05.test(1,23,45,3,43);
       }
       public void test(int...i){
           System.out.println(i[0]);
           System.out.println(i[1]);
           System.out.println(i[2]);
           System.out.println(i[3]);
           System.out.println(i[4]);
       }
   }
   

5. //可变参数   实现排序算法
   public class Demo06 {
       public static void main(String[] args) {
           //调用可变参数的方法
           printMax(44,25,64,25,32,53,74,85);
           printMax(new double[]{1,2,3});
       }
       public static void printMax(double...numbers){
           if(numbers.length==0){
               System.out.println("No argument passed");
               return;
           }
           double result = numbers[0];
   
           //排序
           for (int i = 1; i < numbers.length; i++) {
               if(numbers[i]>result){
                   result = numbers[i];
               }
           }
           System.out.println("The max value is"+result);
       }
   }
   

递归 （能不用就不用）

1. 自己调用自己，给自己一个出口

2. 只适用于小的计算

3. 递归包含两个部分：

   • 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环

   • 递归体：什么时候需要调用自身方法

4. //递归  阶乘
   public class Demo07 {
       public static void main(String[] args) {
           System.out.println(f(5));
       }
       //5!
       public static int f(int n){
           if(n==1){
               return 1;
           }else{
               return n*f(n-1);
           }
       }
   }
   

作业

1. 写一个计算机，要求实现加减乘除功能，并且能够循环接收新的数据，通过用户交互来实现

2. 思路：

   • 写四个方法：加减乘除
   • 利用循环+switch进行用户交互
   • 传递需要操作的两个数
   • 输出结果

3. 代码

   • import java.util.Scanner;
     
     //写一个计算机，要求实现加减乘除功能，并且能够循环接收新的数据，通过用户交互来实现
     public class Demo08 {
         public static void main(String[] args) {
             int a=0;
             int b=0;
             char s='\u0000';
             Demo08 demo08 = new Demo08();
             Scanner scanner1 = new Scanner(System.in);
             System.out.println("请输入第一个操作数：");
             if(scanner1.hasNextInt()){
                 a = scanner1.nextInt();
             }
             Scanner scanner2 = new Scanner(System.in);
             System.out.println("请输入第二个操作数：");
             if(scanner2.hasNextInt()){
                 b = scanner2.nextInt();
             }
             Scanner scanner3 = new Scanner(System.in);
             System.out.println("请输入操作符：");
             if(scanner3.hasNextLine()){
                 s = scanner3.next().charAt(0);
                 demo08.cal(a,b,s);
             }
             scanner1.close();
             scanner2.close();
             scanner3.close();
         }
         int a;
         int b;
         //计算
         public void cal(int a,int b,char s){
             switch(s){
                 case '+':
                     System.out.println(plus(a,b));
                     break;
                 case '-':
                     System.out.println(sub(a,b));
                     break;
                 case '*':
                     System.out.println(mul(a,b));
                     break;
                 case '/':
                     System.out.println(exc(a,b));
                     break;
             }
         }
         //加
         public int plus(int a,int b){
             return a+b;
         }
         //减
         public int sub(int a, int b){
             if(a>=b){
                 return a-b;
             }else{
                 return b-a;
             }
         }
         //乘
         public int mul(int a,int b){
             return a*b;
         }
         //除
         public int exc(int a,int b){
             if(b==0){
                 System.out.println("除数不能为0");
                 return -1;
             }else{
                 return a/b;
             }
         }
     }
     

数组

1. 数组的定义

   • 相同类型数据的有序集合
   • 相同类型的若干个数据，按照一定的先后次序排列组合而成
   • 每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们

2. 数组声明创建

   • 必须声明数组变量，才能在程序中使用数组。下面时声明数组变量的语法： 声明的时候数组不存在

   • dataType[] arrayRefVar;     //首选的方法
     或
     dataType arrayRefVar[];    //效果相同，但不是首选方法
     

   • 使用new操作符来创建数组：

   • dataType[] arrayRefVar = new dataType[arraySize];
     

   • 数组的元素是通过索引访问的，数组索引从0开始

   • 获取数组长度：arrays.length；

   • //变量的类型  变量的名字    =   变量的值
         //数组类型
         public static void main(String[] args) {
             int[] nums;  //声明一个数组
     
             nums = new int[10]; //创建一个数组
             //给数组元素中赋值
             nums[0]=1;
             nums[1]=2;
             nums[2]=3;
             nums[3]=4;
             nums[4]=5;
             nums[5]=6;
             nums[6]=7;
             nums[7]=8;
             nums[8]=9;
             nums[9]=10;
             System.out.println(nums[9]);
             //计算所有元素的和
             int sum=0;
             //获取数组长度：arrays.length
             for (int i = 0; i < nums.length; i++) {
                 sum+=nums[i];
             }
             System.out.println("总和为："+sum);
         }
     }
     

3. Java内存分析

   • 
   • 堆：存放new的对象和数组，可以被所有的线程共享，不会存放别的对象引用
   • 栈：存放基本变量类型（会包含这个基本数值的数据类型的具体数值），引用对象的变量（会存放这个引用在堆里面的具体地址）
   • 方法区：可以被所有的线程共享，包含了所有的class和static变量

4. 三种初始化

   • 静态初始化：

   • int[] a = {1,2,3};
     Man[] mans = {new Man(1,1),new Man(2,2)};
     

   • 动态初始化：

   • int[] a = new int[2];
     a[0] = 1;
     a[1] = 2;
     

   • 数组的默认初始化：数组是引用类型，它的元素相当于实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化

   • //数组三种初始化
     public class ArrayDemo02 {
         public static void main(String[] args) {
             //静态初始化：创建+初始化
             int[] a = {1,2,3,4,5,6,7,8};
             System.out.println(a[3]);
     
             //Man[] mans = {new Man(),new Man()};  引用类型
     
             //动态初始化：包含默认初始化
             int[] b = new int[10];
             b[0] = 10;
             System.out.println(b[0]);
             System.out.println(b[1]);//默认初始化
         }
     }
     

5. 数组的四个基本特点

   • 长度确定。一经创建，大小不可改变
   • 元素是相同类型，不允许出现混合类型
   • 数组中的元素可以是任何数据类型，包括基本类型和引用类型
   • 数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其它对象类型，数组对象本身就是在堆中

6. 数组的边界问题

   • 下标的合法区间：[0，length-1]，如果越界就会报错：

   • public static void main(String[] args){
         int[] a = new int[2];
         System.out.println(a[2]);//java.lang.ArrayIndexOutOfBoundsException
     }
     

   • ArrayIndexOutOfboundsException：数组下标越界异常！

   • 小结 (1)数组是相同数据类型(数据类型可以为任意类型) 的有序集合 (2)数组也是对象。数组元素相当于对象的成员变量 (3)数组长度是确定的，不可改变的。如果越界，则报：ArrayIndexOutOfbounds

7. 数组使用

   • 普通的For循环

   • //数组
     public class ArrayDemo03 {
         public static void main(String[] args) {
             int[] arrays = {1,2,3,4,5};
             //打印全部的数组元素
             for (int i = 0; i < arrays.length; i++) {
                 System.out.println(arrays[i]);
             }
             System.out.println("=======================");
             //计算所有元素的和
             int sum = 0;
             for (int i = 0; i < arrays.length; i++) {
                 sum+=arrays[i];
             }
             System.out.println("sum="+sum);
             System.out.println("==========================");
             //查找最大元素
             int max = arrays[0];
             for (int i = 0; i < arrays.length; i++) {
                 if(arrays[i]>max){
                     max = arrays[i];
                 }
             }
             System.out.println("max="+max);
         }
     }
     

   • For-Each循环

   • //数组  for-each循环
     public class ArrayDemo04 {
         public static void main(String[] args) {
             int[] arrays = {1,2,3,4,5};
             //JDK1.5，没有下标
             for (int array : arrays) {
                 System.out.println(array);
             }
         }
     }
     

   • 数组作方法入参

   • //数组  数组做方法入参
     public class ArrayDemo04 {
         public static void main(String[] args) {
             int[] arrays = {1,2,3,4,5};
             printArray(arrays);
         }
         //打印数组元素
         public static void printArray(int[] arrays){
             for (int i = 0; i < arrays.length; i++) {
                 System.out.print(arrays[i]+" ");
             }
         }
     }
     

   • 数组作返回值

   • //数组  反转数组
     public class ArrayDemo04 {
         public static void main(String[] args) {
             int[] arrays = {1,2,3,4,5};
             /*//JDK1.5，没有下标
             for (int array : arrays) {
                 System.out.println(array);
             }*/
             printArray(arrays);
             int[] reverse = reverse(arrays);
             printArray(reverse);
         }
         //打印数组元素
         public static void printArray(int[] arrays){
             for (int i = 0; i < arrays.length; i++) {
                 System.out.print(arrays[i]+" ");
             }
         }
         //反转数组
         public static int[] reverse(int[] arrays){
             int[] result = new int[arrays.length];
             //反转操作
             for (int i = 0,j=result.length-1; i < arrays.length; i++,j--) {
                 result[j] = arrays[i];
             }
             return result;
         }
     }
     

8. 多维数组

   • 多维数组可以看成是数组的数组,比如二维数组就是一个特殊的一维数组

   • 二维数组

   • int a[][] = new int[2][5];
     

   • 解析：以上二维数组a可以看成一个两行五列的数组

   • 

   • //二维数组
     public class ArrayDemo05 {
         public static void main(String[] args) {
             //[4][2]
             /*
                 1,2  array[0]
                 2,3  array[1]
                 3,4  array[2]
                 4,5  array[3]
             */
             int[][] array = {{1,2},{2,3},{3,4},{4,5}};
             System.out.println(array[0]);   //打印出来的是对象  [I@1b6d3586
             printArray(array[0]);   //打印出来的是数     1 2
             System.out.println(array[0][0]);
             System.out.println(array[0][1]);
             System.out.println(array.length);
             System.out.println(array[0].length);
         }
         //打印数组元素
         public static void printArray(int[] arrays){
             for (int i = 0; i < arrays.length; i++) {
                 System.out.print(arrays[i]+" ");
             }
         }
     }
     

9. Arrays类

   • 数组的工具类java.util.Arrays

   • 由于数组对象本身并没有什么方法可以供我们调用，但API中提供一个工具类Arrays供我们使用，从而可以对一些数组对象进行一些基本的操作

   • 查看JDK帮助文档：

   • Arrays类的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用

   • 具有以下常用功能：

     ​ （1）给数组赋值：通过fill方法

     ​ （2）给数组排序：通过sort方法，按升序

     ​ （3）比较数组：通过equals方法比较数组中元素值是否相等

     ​ （4）查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法查找

   • import java.util.Arrays;
     
     //Arrays
     public class ArrayDemo06 {
         public static void main(String[] args) {
             int[] a = {1,2,3,4,5343,5333,453,234,2343,434253,45434};
             System.out.println(a);//[I@1b6d3586
             //打印数组元素  Arrays.toString()
             System.out.println(Arrays.toString(a));
             printArray(a);
             //数组进行排序：升序排序
             System.out.println("\n"+"排序后的数组为：");
             Arrays.sort(a);
             System.out.println(Arrays.toString(a));
             //填充
             Arrays.fill(a,2,4,0);
             System.out.println(Arrays.toString(a));
         }
     
         public static void printArray(int[] a){
             for (int i = 0; i < a.length; i++) {
                 if(i==0){
                     System.out.print("[");
                 }
                 if(i==a.length-1){
                     System.out.print(a[i]+"]");
                 }else{
                     System.out.print(a[i]+", ");
                 }
     
             }
         }
     }