2020-11-9 JAVA学习记录

Java学习记录第七天

2020年11月2日开始正式学习Java
2020年11月9日是我学习Java的第七天

第七天整体学习内容

面向对象（第二部分）
类的结构之二：方法（补充）

• 关键字：return
• 方法的重载
• 可变个数形参的方法
• Java的值传递机制
• 递归方法

面对对象的特征之一：封装性

类的结构之二：方法（补充）

关键字：return

1. 使用范围：
   使用在方法体重
2. 作用：
   ①结束方法
   ②针对于有返回值类型的方法，使用“return 数据；”方法返回所要的数据
3. 注意点：
   return关键字后面不可以声明执行语句。（类似于break和continue）

方法的重载

1. 方法的重载的概念

定义：

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

总结：

“两同一不同”:同一个类、相同方法名
参数列表不同：参数个数不同，参数类型不同

2. 构成重载的举例

举例：

//如下的4个方法构成了重载
public void getSum(int i,int j){
   System.out.println("1");
}
public void getSum(double d1,double d2){
   System.out.println("2");
}
public void getSum(String s ,int i){
   System.out.println("3");
}
public void getSum(int i,String s){
   System.out.println("4");
}

不构成重载的举例：

//如下的3个方法不能与上述4个方法构成重载
public int getSum(int i,int j){
   return 0;
}
public void getSum(int m,int n){
}
private void getSum(int i,int j){
}

3. 如何判断是否构成方法的重载？

严格按照定义判断：两同一不同。
跟方法的权限修饰符、返回值类型、形参变量名、方法体都没关系！

4.如何确定类中某一个方法的调用：

方法名 —> 参数列表

可变个数形参的方法

1. 使用说明

1. jdk 5.0新增的内容
2. 具体使用：

① 可变个数形参的格式：数据类型 … 变量名
② 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。
③ 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
④ 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
⑤ 可变个数形参在方法的形参中，必须声明在末尾
⑥ 可变个数形参在方法的形参中,最多只能声明一个可变形参。

2.举例说明：

public void show(int i){
	
}
public void show(String s){
	System.out.println("show(String)");
}
public void show(String ... strs){
	System.out.println("show(String ... strs)");
	for(int i = 0;i < strs.length;i++){
		System.out.println(strs[i]);
	}
}
//不能与上一个方法同时存在
//	public void show(String[] strs){
//		
//	}

调用时：

test.show("hello");
test.show("hello","world");
test.show();

test.show(new String[]{"AA","BB","CC"});

java的值传递机制

1.针对于方法内变量的赋值举例：

System.out.println("***********基本数据类型：****************");
int m = 10;
int n = m;
System.out.println("m = " + m + ", n = " + n);
n = 20;
System.out.println("m = " + m + ", n = " + n);
System.out.println("***********引用数据类型：****************");
Order o1 = new Order();
o1.orderId = 1001;
Order o2 = o1;//赋值以后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体。
System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
o2.orderId = 1002;
System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);

规则：

如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

2.针对于方法的参数概念

形参：方法定义时，声明的小括号内的参数
实参：方法调用时，实际传递给形参的数据

3.java中参数传递机制：值传递

规则：

• 如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。
• 如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。

推广：

如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

递归方法

1. 定义：

递归方法：一个方法体内调用它自身。

2. 如何理解递归方法？

方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。

3.举例：

// 例1：计算1-n之间所自然数的和

public int getSum(int n) {// 3
	if (n == 1) {
		return 1;
	} else {
		return n + getSum(n - 1);
	}
}

	// 例2：计算1-n之间所自然数的乘积:n!
public int getSum1(int n) {
	if (n == 1) {
		return 1;
	} else {
		return n * getSum1(n - 1);
	}
}

//例3：已知一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n),
//其中n是大于0的整数，求f(10)的值。

public int f(int n){
	if(n == 0){
		return 1;
	}else if(n == 1){
		return 4;
	}else{
//		return f(n + 2) - 2 * f(n + 1);
		return 2*f(n - 1) + f(n - 2);
		}
	}

//例4：斐波那契数列

//例5：汉诺塔问题

//例6：快排

面向对象的特征之一：封装性（封装与隐藏）

1.为什么要引入封装性？

• 我们程序设计追求“高内聚，低耦合”。
  高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉；
  低耦合 ：仅对外暴露少量的方法用于使用。

• 隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

2.问题引入：

** 当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到属性的数据类型和存储范围的制约。除此之外，没其他制约条件。但是，在实际问题中，我们往往需要给属性赋值加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。（比如：setLegs()同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有的(private).**
–>此时，针对于属性就体现了封装性。

3.封装性思想具体的代码体现：

体现一：将类的属性xxx私化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值

private double radius;
public void setRadius(double radius){
	this.radius = radius;
}
public double getRadius(){
	return radius;
}

体现二：不对外暴露的私有的方法
体现三：单例模式（将构造器私有化）
体现四：如果不希望类在包外被调用，可以将类设置为缺省的。

4.Java规定的四种权限修饰符

1. 权限从小到大顺序为：private < 缺省 < protected < public
2. 具体的修饰范围：

修饰符	类内部	同一个包	不同包的子类	同一个工程
private	yes
(缺省)	yes	yes
protected	yes	yes	yes
public	yes	yes	yes	yes

3. 权限修饰符可用来修饰的结构说明：

4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
修饰"类"的话，只能使用：缺省、public