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

待我称王封你为后i 2022-03-15 12:35 273阅读 0赞

## 方法 ##

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));
            	}