首页 > > 程序设计 > Java技术 >

关于方法的一些浅见和对象的一些理解

2018-08-10 11:15:09来源：博客园阅读 ()

在代码执行的过程中，我们为了使完成相同功能的代码合在一起，避免代码的冗余，今天，就来谈谈关于方法的一些理解吧！

1.方法

（当在程序中需要重复使用某段逻辑或者功能，将这段逻辑提取出来形成一种新的形式 --- 方法）

1.1 定义格式

修饰符返回值类型方法名(参数列表){

方法体;

return 返回值;

}

练习：

1.哥德巴赫猜想：任何一个大于 6 的偶数都可以分解成两个质数之和。

16 = 3 + 13

16 = 5 + 11

输入大于等于 6 的偶数，然后输入它所有的分解形式

20 = 3 + 17

20 = 7 +13

思路：在这个过程中要重复执行的代码是判断质数

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

}

//判断一个数字 n 是否是一个质数
	public static boolean isPrime(int n){
		//判断是否符合范围
		if(n < 2)
			return false;
		if(n == 2)
			return true;
		if(n % 2 == 0)
			return false;
		for(int i = 3; i <= n/2; i++){
			if(n % i == 0)
				return false;
		}
		return true;
	}

public static void print(int n){
		if(n % 2 != 0 || n < 6){
			System.out.println("输入不合法");
		}else{
			for(int i = 3; i <= n/2; i++){
				if(isPrime(i) && isPrime(n - i)){
					System.out.println(n + "=" + i + "+" + (n - i));
				}
		}
		}
	}

2.亲密数：如果 A 的所有因子（含 1 而不含本身）之和等于 B，而且 B 的所有因子（含 1 而不含本身）之和等于 A ,A 和 B 就是一对亲密数

16：1+2+4+8 = 15

15：1+3+5 = 9

打印 5000 以内所有的亲密数

思路：需要重复执行的逻辑是获取一个数的所有因子之和

/**亲密数：如果 A 的所有因子（含 1 而不含本身）之和等于 B，而且 B 的所有因子（含 1 而不含本身）之和等于 A ,A 和 B 就是一对亲密数
16：1+2+4+8 = 15
15：1+3+5 = 9
打印 5000 以内所有的亲密数
思路：需要重复执行的逻辑是获取一个数的所有因子之和
*/
public class MethodDemo2{
	public static void main(String[] args){
		for(int a = 1; a <= 5000; a++){
			int b = sumAllFact(a);
			int i = sumAllFact(b);
			if(i == a && a < b){
				System.out.println(a+","+b);
			}
		}
        }

        //一个数的所有因子之和
	public static int sumAllFact(int n){
		int sum = 0;
		for(int i = 1; i <= n/2; i++){
			if(n % i == 0){
				sum += i;
			}
		}
		return sum;
	}
}

　　1.2方法的重载

在同一个类中，存在了方法名一致而参数列表不同（参数个数不同或者是对应位置上的参数类型不同）的方法 --- 方法的重载 --- 依靠参数列表来区分调用的方法

方法在调用的时候会进行模糊匹配 --- 参数类型在没有最符合的情况下会自动提升，就会导致提升之后可能会有多个匹配

main(String[] args) args 可以换成任何的一个字符串

System.out.println();

Arrays.toString();

Arrays.sort();

　　1.3方法的传值

主函数在栈中占用一片空间，另一个方法也会再开辟一片空间（里面的参数在里面再占用一片空间，在里面进行值的改变）。但栈的特点是用完就释放，所以在主函数中打印值还是那个。

但是像传入一个地址的情况，值就会发生改变，因为传的是一个地址，改变的过程是在堆中，所以即便栈中的那个方法用完就释放了，但是值已经在堆中改变了。

注意：

1.方法是在栈内存中执行

2.方法在传值的时候，基本类型传的实际值，数组传递的是地址

3.传递地址之后，如果地址没有发生改变，则代码执行影响原来的数组；如果地址发生了改变，则代码执行不影响原来的数组。

1.4方法的递归

展现形式：方法调用了自身

add(10) = 10 + add(9); --- 求前十项的和相当于第十项加上前 9 项的和

add(9) = 9 + add(8);

…

add(3) = 3 + add(2);

add(2) = 2 + add(1);

add(1) = 1;

练习：输入一个数字 n，求 n!

10 个阶梯，依次迈出 1 个或者 2 个阶梯，总共有多少种走法？

f(10) = f(9)+f(8)

f(9) = f(8) + f(7)

f(8) = f(7) + f(6)

…

f(3) = f(2) + f(1)

f(2) = 2

f(1) = 1

注意：在递归的时候，当执行次数过多会产生 StackOverflowError - 栈溢出错误

总结：在一些场景中，如果能确定这一项和前 n 项的关系，那么可以使用递归 --->逆推

/**10 个阶梯，依次迈出 1 个或者 2 个阶梯，总共有多少种走法？
	*/
	public static int step(int n){
		if(n == 1)
			return 1;
		if(n == 2)
			return 2;
		return step(n - 1) + step(n - 2);
	}

一些基本常识：

JAVESE 
        基本语法
        面向对象
        API（最容易翻车的部分）
IDE  ---  智能开发工具
Eclipse（日食） --- 免费、功能非常强大，基于插件（别人做好的，封装好的功能，就像小时候玩的游戏机插卡）、开源（开放源代码，官网找到源码，写出另一个，开源有的免费，有的收费）、绿色（以压缩包的形式，解压就能用）    - SUN
    Kepler（开普勒，现在用的最古老的一个版本） -> Luna（月神，JDK1.8 不建议使用）-> Mars（火星，支持 JDK 的 5 个版本）->Neon（霓虹灯）->Oxygen（氧气，这是现在的最新版本，有很多的东西不是很稳定）
Intelli J（社区版和专业版：提供了很多的定制，代码依赖管理，按年收费，）

2.面向对象

面向对象是一种思维方式，相对于面向过程而言的。（比如你吃过的东西，你去定义一下你吃的苹果，生活很常见的，定势思维，但是要描述很难）。

（吃下午茶，想吃蛋糕，得有这个蛋糕，要获取（一种，你自己做，一种你去买，准备材料，制作蛋糕，烘培蛋糕），每一个动作的执行者是你，很清楚着每一个步骤执行的细节，这就是面向过程）。然后不想做，想买，告诉糕点师（根据你想要的去制作材料，制作蛋糕，烘焙蛋糕），这个流程中执行者是糕点师，你在流程中起了一个发起者/主导者（你要看哪个糕点师做的好吃，这就是面向对象），不用管糕点师怎么去做，糕点师就是这个对象。

面向过程在流程中关注动作执行的每一个细节。 --- 自己动手做

面向对象重点找这个对象，只要找到了对象，那么这个对象所具有的功能就能够被使用 --- 找别人做（比如用的手机、电脑，要开机，就是有一个键（进行了面向对象的封装），不然你就要把电脑拆开，自己将线接上；还有去买洗衣机，他们的导购，就给你介绍这些，不然你得自己去了解这些资料。）

面向对象给我们带来了很多的好处，但不一定比面向过程好。（比如，你早上起床穿衣服，就是面向过程；而面向对象就像妃嫔，别人来穿，那样很有气场，但是效率低）--- 相对简单的事务建议使用面向过程，相对复杂的事务建议使用面向对象。

面向对象本身是基于面向过程的。