类的设计中,两个重要结构之二:方法
方法
描述类应该具的功能。
比如:Math类:sqrt()\random() \...
Scanner类:nextXxx() ...
Arrays类:sort() \ binarySearch() \ toString() \ equals() \ ...
1.举例
public void eat(){}
public void sleep(int hour){}
public String getName(){}
public String getNation(String nation){}
2. 方法的声明
权限修饰符 返回值类型 方法名(形参列表){
方法体
}
注意:static、final、abstract 来修饰的方法。
3. 说明
3.1 关于权限修饰符
默认方法的权限修饰符先都使用public
Java规定的4种权限修饰符:private、public、缺省、protected -->封装性再细说
3.2 返回值类型
返回值 vs 没返回值
3.2.1 返回值
- 如果方法返回值,则必须在方法声明时,指定返回值的类型。
- 同时,方法中,需要使用return关键字来返回指定类型的变量或常量:“return 数据”。
- 如果方法没返回值,则方法声明时,使用void来表示。通常,没返回值的方法中,就不需要
- 使用return.但是,如果使用的话,只能“return;”表示结束此方法的意思。
3.2.2 没返回值
我们定义方法该不该返回值?
① 题目要求
② 凭经验:具体问题具体分析
3.3 方法名
属于标识符,遵循标识符的规则和规范,“见名知意”
3.4 形参列表
方法可以声明0个,1个,或多个形参。
3.4.1 格式
数据类型1 形参1,数据类型2 形参2,...
3.4.2 没形参
我们定义方法时,该不该定义形参?
① 题目要求
② 凭经验:具体问题具体分析
3.5 方法体
方法功能的体现
4.方法使用
方法的使用中,可以调用当前类的属性或方法
特殊的:方法A中又调用了方法A:递归方法,方法中,不可以定义方法
return关键字
1.使用范围:使用在方法体中
2.作用:① 结束方法
* ② 针对于返回值类型的方法,使用"return 数据"方法返回所要的数据。
3.注意点:return关键字后面不可以声明执行语句。
方法的重载
1.方法的重载的概念
定义:在同一个类中,允许存在一个以上的同名方法,只要它们的参数个数或者参数类型不同即可
总结:"两同一不同":同一个类、相同方法名
参数列表不同:参数个数不同,参数类型不同
2.构成重载的举例:
举例一:
Arrays类中重载的sort() / binarySearch();PrintStream中的println()
举例二:
//如下的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.具体使用:
* 2.1 可变个数形参的格式:数据类型 ... 变量名
* 2.2 当调用可变个数形参的方法时,传入的参数个数可以是:0个,1个,2个,。。。
* 2.3 可变个数形参的方法与本类中方法名相同,形参不同的方法之间构成重载
* 2.4 可变个数形参的方法与本类中方法名相同,形参类型也相同的数组之间不构成重载。换句话说,二者不能共存。
* 2.5 可变个数形参在方法的形参中,必须声明在末尾
* 2.6 可变个数形参在方法的形参中,最多只能声明一个可变形参。
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中参数传递机制
值传递
规则:
* 如果参数是基本数据类型,此时实参赋给形参的是实参真实存储的数据值。
* 如果参数是引用数据类型,此时实参赋给形参的是实参存储数据的地址值。推广:
如果变量是基本数据类型,此时赋值的是变量所保存的数据值。
如果变量是引用数据类型,此时赋值的是变量所保存的数据的地址值。
4.典型例题与内存解析:
【例题1】
【例题2】
递归方法
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);
}
}
面向对象的特征一:封装与隐藏
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规定的四种权限修饰符
4.1 权限从小到大顺序为:private < 缺省 < protected < public
4.2 具体的修饰范围
4.3 权限修饰符可用来修饰的结构说明:
4种权限都可以用来修饰类的内部结构:属性、方法、构造器、内部类
修饰类的话,只能使用:缺省、public