Java面向对象------方法

方法

1. 什么是方法

   1. 方法用于封装一个计算过程（算法）
   2. 定义方法的目的是便于复用算法
   3. 通过复用可以减少编码量，提高开发效率

2. 定义一个方法

   1. 语法：

      	修饰词 返回值类型 方法名(参数类型 参数名，参数类型 参数名...){
      		方法体
      	}
      

      1. 方法体：就是算法的计算步骤。
      2. 方法名：是方法标识，根据方法名找到需要调用的方法。一般情况下，按照方法功能进行命名
      3. 参数列表：计算时候的输入数据作为方法的参数。有些方法可以没有参数
      4. 返回值类型：计算结果作为返回值，有些方法没有返回值。如果没有返回值，必须使用void 声明返回值值。
      5. 修饰词： 修饰方法的可见范围。
      6. 方法必须声明在类中，和main方法等方法同一个层次。不能在方法中声明方法！

   2. 案例： 用方法封装两个数相加的过程。

      	public class Demo{		
      		public static int add(int a, int b, int c){
      			return a+b+c;
      		}
      		
      		public static void main(String[] args){
      			int n = add(5,8);
      			System.out.println(n);//13
      			int m = add(7,8);
      			System.out.println(m);//15
      		}
      
      		public static int add(int a, int b){
      			int c = a + b;
      			return c; //return 返回
      		}
      	}
      

   3. return 语句：

      1. return 计算结果，用于在方法中返回计算结果
         1. 如果方法中声明的返回值，就必须使用return语句返回结果。
      2. return , 用于提前结束方法。
         1. return 语句可以用于提前结束语句
            1. 原理：
            2. 代码：

               	public static void main(String[] args) {
               		/*
               		 * 顺序查找算法
               		 * 利用return 语句提前结束方法 
               		 */
               		int[] arr = {3,1,23,43,4,6};
               		int index = indexOf(arr, 4);
               		System.out.println(index);
               		index = indexOf(arr, 8);
               		System.out.println(index); 
               	}
               
               	public static int indexOf(int[] arr, int key) {
               		for (int i = 0; i < arr.length; i++) {
               			if(key == arr[i]) {
               				return i;
               			}
               		}
               		return -1;
               	}
               
               

      3. 无返回值方法中可以使用return提前结束方法
         1. 原理：
         2. 代码：

         	public static void main(String[] args) {
         		int[] arr = {4,1,4,6,7,87};
         		print(arr);
         		int[] arr2 = {};
         		print(arr2);
         	}
         
         	public static void print(int[] arr) {
         		if (arr.length == 0) {
         			System.out.println("[]");
         			return;// 提前结束方法
         		}
         		System.out.print("[" + arr[0]);
         		for (int i = 1; i < arr.length; i++) {
         			System.out.print(", " + arr[i]);
         		}
         		System.out.println("]");
         	}
         

3. 使用一个方法

   1. 返回值 = 方法名(参数);
   2. 案例，将冒泡排序封装成方法：

      	public static void main(String[] args){
      			/*
      			 * 方法的定义与调用
      			 */					
      			int[] arr = {7,8,1,2,9,0,2};
      			int[] arr2 = {889,43,22,55,89,12};
      			//复用 sort 方法
      			sort(arr);
      			sort(arr2);
      			System.out.println(Arrays.toString(arr));
      			System.out.println(Arrays.toString(arr2));
      		}
      		//将冒泡排序封装成方法
      		public static void sort(int[] arr) {
      			for(int i=0;i<arr.length-1; i++) {
      				for(int j=0; j<arr.length-1-i; j++) {
      					if(arr[j]>arr[j+1]) {
      						int t = arr[j];
      						arr[j]=arr[j+1];
      						arr[j+1]=t;
      					}
      				}
      			}
      		}
      

   3. 方法可以跨类访问：

      	public static void main(String[] args) {
      		/*
      		 * 跨类调用方法：
      		 * 
      		 * 在Demo 类中使用Demo1 类定义的sort方法
      		 * 使用:类名.方法名()
      		 */
      		int[] arr = {3,7,9,2,4,5,2};
      		Demo1.sort(arr);
      		System.out.println(Arrays.toString(arr));
      	}