JavaOOP编程思想-方法

1.什么是方法？

方法是若干个"代码语句片段"的集合，它们完成一个"具体的功能"，并且设置一个"直观易懂"的名字，方便后期在程序中去"使用（调用）"。

2.使用方法的优点

• 使程序变得更简短而清晰
• 有利于程序维护
• 可以提高程序开发的效率
• 提升 了代码的重用性

3.方法的定义

语法格式：?

修饰符 （static） 返回值类型 方法名（参数类型 参数名）{

? ? ? ? 语句1；

? ? ? ? 语句2；

? ? ? ? 语句3；

? ? ? ? return 返回值；

}

• 修饰符:修饰符,可选部分,定义了该方法的访问范围。
• static关键字:该方法通过类名调用(如果是在当前类内，可以直接调用，类名省略
• 返回值类型:调用方法后返回的数据值的类型;但有些方法执行后没有返回的数据值,在这种情况下,返回值类型部分使用关键字void,
• 方法名:按照该方法的作用，为方法命名。
• 参数:参数像是一个占位符。当方法被调用时,传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的,方法可以不包含任何参数。按照该方法的作用，为方法设计参数的个数和类型。
• 方法体:方法体包含具体的语句,定义该方法的功能。
  ?

示例：

    //查找3个int类型整数中的最大值
	public static int max(int a, int b, int c) {
		int ret = (a > b) ? (a > c ? a : c) : (b > c ? b : c);
		return ret;
	}

?4.方法的调用

查找3个int类型整数中的最大值

在mian函数中调用自定义的max（方法）函数。

（在当前类中，可以直接调用方法；在其他类中，需要通过"类名.方法名"调用）

    //查找3个int类型整数中的最大值
	public static int max(int a, int b, int c) {
		int ret = (a > b) ? (a > c ? a : c) : (b > c ? b : c);
		return ret;

	}

	public static void main(String[] args) {

        //在当前类中，可以直接调用方法。        

		int val1 = max(15, 27, 11);
		System.out.println("结果1：" + val1);

		int val2 = max(17, 14, 27);
		System.out.println("结果2：" + val2);

	}

?5.方法的返回值

将方法执行的最终结果,通过return关键字,返回至方法调用处。

例如:随机抽奖的方法,需要通过返回值将中奖的结果返回
确认订单的方法,需要通过返回值将订单是否生成的结果返回

• 方法的返回值必须与方法声明时的返回值类型保持一致
• 如果一个方法无需返回值,则需要使用void关键字进行声明。

6.动态参数

• 一个方法中只能有一个参数的动态参数
• 动态参数必须是方法的最后一个参数
• 动态参数在方法中，可做为一个数组使用

示例1：?查找N个int类型整数中的最大值。

public class Text05 {
	private static int maxN(int... ns) {
		//动态参数
		//查找N个int类 型整数中的最大值
		int ret = ns[0];//默认值
		for(int i = 1;i<ns.length;i++) {
			if(ns[i]>ret) {
				ret = ns[i];
			}
		}
		return ret;
	}
	
	public static void main(String[] args) {
		//可以传入N个参数
		int max = maxN(4,89,33,25,66,96,43);
		System.out.println(max);
		
	}

}

示例2：求两数之和。

public class Text06 {
    
    //主函数
	public static void main(String[] args) {
        //调用自定义方法twoSum(),求两数之和
		String ret = twoSum(5,0,2,3,5,6,7,8,9);
		System.out.println(ret);
		
	}
	
	//两数之和
	//参数target :需要查找的目标值
	//参数numbers:需要查找的一组整数(动态参数)
	//注意:动态参数必须是整个参数列表的最后1部分
	public static String twoSum(int target,int... numbers) {
		String result = "";
		
//		outer:
		for(int i = 0;i<numbers.length-1;i++) {
			for(int k = i+1;k<numbers.length;k++) {
				if(numbers[i]+numbers[k]==target) {
					// String.format():格式化拼接
					result = String.format("%d+%d=%d", numbers[i],numbers[k],numbers[i]+numbers[k]);
					//方式1：
//					break outer;
					//方式2：
					return result;
				}
			}
		}
		
		return result;
		
	}

}

示例3：字符串的逆序

public class Text07 {
	public static void main(String[] args) {

		//方法的调用
		String ret = reverse("忽如一夜春风来");
		System.out.println(ret);
		
	}

	//方法的定义
	//字符串逆序
	//参数s:原始字符串
	public static String reverse(String s) {
		
		String ret = "";
		for(int i = 0;i<s.length();i++) {
			char c = s.charAt(i);
			ret = c+ret;		
		}
		return ret;
	}

}

?示例4：获取任意整数的位数

public class Text08 {
	public static void main(String[] args) {

		int n1 = 123456;
		int len1 = numberLength(n1);
		System.out.println(n1+"的长度是"+len1+"位！");
		
		int n2 = 78945612;
		int len2 = numberLength(n2);
		System.out.println(n2+"的长度是"+len2+"位！");
		
	}
    
    //获取任意整数的位数
	public static int numberLength(int numbers) {
		
		//方式1：计算该整数以10为底的对数
		int ret = (int)(Math.log10(numbers)+1);
		return ret;
		
        //方式2：通过循环
//		int ret = 0;
//		while(numbers != 0) {
//			System.out.println("个位数值："+numbers%10);
//			ret++;//记录位数
//			numbers = numbers/10;
//		}
//		
//		return ret;
	}

}

?7.方法的传参

• 基本数据类型的参数：传递"值"
• 引用数据类型的参数：传递"内存地址"

示例1：基本数据类型的传参

public class Text11 {
	public static void main(String[] args) {
		//方法的传参
		//基本数据类型的参数：传递"值"
		//引用数据类型的参数：传递"内存地址"
		int n1 = 3,n2 = 5;
		System.out.printf("改变前，数字：%d,数字：%d\n",n1,n2);
		grow1(n1,n2);
		System.out.printf("改变后，数字：%d,数字：%d\n",n1,n2);
	}
	public static void grow1(int a,int b) {
		a = a<<1;
		b = b<<1;
		System.out.printf("改变中，数字：%d,数字：%d\n",a,b);
	}
	

}

输出结果：

改变前，数字：3,数字：5
改变中，数字：6,数字：10
改变后，数字：3,数字：5

示例2：引用数据类型的传参

public class Text09 {

	public static void main(String[] args) {

		//定义数组，保存一组"需要进行扩容的整数"

		int[] array = {1,2,3,4,5};
		System.out.println("改变前："+Arrays.toString(array));
		System.out.println("数组array的内存地址："+array);
		
		//引用数据类型的传参
		//array传递的是"内存地址"
		grow2(array);
		
		System.out.println("改变后："+Arrays.toString(array));
		
	}
	
	//引用数据类型的传参
	//参数numbers接收的是"内存地址"

	public static void grow2(int[] numbers) {

		System.out.println("数组numbers的内存地址："+numbers);

		for(int i = 0;i<numbers.length;i++) {

			numbers[i] = numbers[i]<<1;
		}
		
		System.out.println("改变中");
		
		for(int n:numbers) {

			System.out.println(n+"\t");
		}
		System.out.println();
	}

}

输出结果：

改变前：[1, 2, 3, 4, 5]
数组array的内存地址：[I@15db9742
数组numbers的内存地址：[I@15db9742
改变中
2	4	6	8	10	
改变后：[2, 4, 6, 8, 10]

8.课堂练习题：

1.数组的排序，并查找的目标值在数组的下标位置。

public class Text10 {

	public static void main(String[] args) {

		int[] arr = { 4, 3, 2, 8, 1, 9, 4, 7, 12, 5 };

//		System.out.println("排序前：" + Arrays.toString(arr));
//		sort(arr);
//		System.out.println("排序后" + Arrays.toString(arr));
		
		//查找
		int ret = binarySearch(arr,2);
		System.out.println("查找的目标值在数组的下标="+ret);

	}

	// 冒泡排序方法
	public static void sort(int[] ns) {
		for (int i = 0; i < ns.length - 1; i++) {
			boolean isSort = true;
			for (int k = 0; k < ns.length - 1 - i; k++) {
				
				if (ns[k] > ns[k + 1]) {
					ns[k] = ns[k] ^ ns[k + 1];
					ns[k + 1] = ns[k] ^ ns[k + 1];
					ns[k] = ns[k] ^ ns[k + 1];
					isSort = false;
				}			
			}
			if (isSort) {
				break;
			}
		}
	}

	// 二分查找方法
	public static int binarySearch(int[] ns, int target) {
		// 先排序
		sort(ns); //直接调用上面的sort()方法
		// 再二分查找
		int low = 0, high = ns.length - 1;
		while (low <= high) {
			int mid = (low + high) / 2;
			if (ns[mid] == target) {
				return mid;
			} else if (ns[mid] > target) {
				high = mid - 1;
			} else if (ns[mid] < target) {
				low = mid + 1;
			}
		}
		return -1;
	}

}

2.数组的旋转

public class Text12 {
	public static void main(String[] args) {

		int[] numbers = {1,2,3,4,5,6,7};
		System.out.println("原始数组："+Arrays.toString(numbers));

		//向右旋转3位
		right(numbers,3);
		System.out.println("右旋3位"+Arrays.toString(numbers));

		//向左旋转2位
		left(numbers,2);
		System.out.println("左旋3位"+Arrays.toString(numbers));
		
	}

	//向右旋转：把尾元素，通过不断交换，移动到数组的"头部"
	public static void right(int[] ns,int n) {

		//向右旋转几次
		for(int i = 1;i<=n;i++) {

			//每次向右旋转1位
			for(int k = ns.length-1;k>0;k--) {
				ns[k] = ns[k]^ns[k-1];
				ns[k-1] = ns[k]^ns[k-1];
				ns[k] = ns[k]^ns[k-1];		
			}

		}	
	
	}
	//向左旋转：把头元素，通过不断交换，移动到数组的"尾部"
		public static void left(int[] ns,int n) {

			for(int i = 1;i<=n;i++) {

				for(int k = 0;k<ns.length-1;k++) {
					ns[k] = ns[k]^ns[k+1];
					ns[k+1] = ns[k]^ns[k+1];
					ns[k] = ns[k]^ns[k+1];
				}

			}	

		}

}

输出结果为：

原始数组：[1, 2, 3, 4, 5, 6, 7]
右旋3位[5, 6, 7, 1, 2, 3, 4]
左旋2位[7, 1, 2, 3, 4, 5, 6]

3.求两数之和等于目标数的下标位置

public class Text13 {
	public static void main(String[] args) {
		int[] retArr = twoSum(5,1,4,2,3,4,5,6,7,8,9);
		System.out.println(Arrays.toString(retArr));
		
	}
	
	//使用数组,返回查找到的两个下标值
	public static int[] twoSum(int target,int... numbers){
		int[] rets = {-1,-1};
		
		outter:
		for(int i = 0;i<numbers.length-1;i++) {
			for(int k = i+1;k<numbers.length;k++) {
				if(numbers[i]+numbers[k]==target) {
					rets[0] = i;
					rets[1] = k;
					break outter;
				}
			}
		}
		
		
		return rets;
	}

}

输出结果为：

[0, 1]