JavaSE-方法定义与调用
1.方法的声明
1.1方法的定义
方法声明,又叫定义方法,指编写一段有特定功能的代码,在程序中使用时调用定义好的方法即可。可以实现代码的重用,简化程序编写和维护工作。
方法的结构为:
修饰符号 返回值类型 方法名称(参数类型1 形式参数1,…){
方法的主体;
返回值;
}
在方法定义时,如果声明返回值类型,则必须在方法体中使用return语句返回一个类型匹配的值。如果方法存在多个分支,则每个分支都需要使用return返回一个值。
例1:计算两个整数进行加法计算,并返回和。
Ans:
public int add(int a,int b){
if(a==0 && b==0){
return 0;
}else{
int c = a+b;
return c;
}
当方法内部需要返回不同值时,可以使用多个return语句,在不同情况下返回不同值,也可以根据不同情况,修改统一的返回值变量;再在方法的后面使用同一个return语句返回变量值。
例2:计算两个整数进行加法计算,并返回和。
Ans:
public int add(int a,int b){
int ret = 0;
if(a==0 && b==0){
ret= -1;
}else{
ret = a+b;
}
return ret;
}
声明方法时注意:形参必须注明数据类型,实参直接写,不需要类型声明。return只能返回一次,遇到return语句,方法结束执行,后续语句不执行。方法的返回值,必须与方法声明中的返回值类型匹配。方法定义,不能写在main()中,方法是不能嵌套的。
1.2 方法的分类
1.2.1 无参方法
无参方法是指方法名称后没有参数,格式为:方法名()。
例:
private void printColor(){
System.out.print("nono");
}
1.2.2 有参方法
有参方法时指方法名称后有参数,格式为:方法名(参数类型 形式参数,参数类型 形式参数…)。
有参方法的参数类型可分为基本数据类型和引用数据类型。
基本数据类型有:byte , short, int, long, float, double, char, long。
引用数据类型有:类,接口类型,数组类型,枚举类型,注解类型。
例1:基本数据类型
public void change(int a){//参数是基本数据类型
a = 12;
System.out.print("in method "+a);
}
例2:引用数据类型
public void change(String str){//参数是一个对象类型,引用数据类型
str = "in method";
System.out.print(str+" ");
}
1.2.3 无返回值方法
方法执行后不向本方法外部返回任何值。声明方法返回类型的位置不能省略不写,返回类型使用void关键字。
例:
public static void printColor(char color){
System.out.println(color);
}
1.2.4 有返回值方法
方法执行后向本方法外部返回数据值。使用return关键字,完成方法的返回值。遇到return语句,方法结束执行,后续语句不执行。因此在方法中,return语句只能执行一次。方法的返回值,必须与方法声明中的返回值类型匹配。
return表示返回值和终止方法的执行。
例:
public static int add(int x,int y){
int z=x+y;
return z;
}
1.2.5 基本数据类型与引用数据类型的区别
a).存储形式差别
基本数据类型在被创建时,在栈上给其划分一块内存,将数值直接存储在栈上;引用数据类型在被创建时,首先要在栈上给其引用分配一块内存,而对象的具体信息都存储在堆内存上,然后由栈上面的引用指向堆中对象的地址。其中,压栈:把数据放入栈中;弹栈:把数据取出;栈结构:先进后出。
b).调用方式差别
基本数据类型是传值调用,传递的参数是参数的数据。方法内部对形参修改不影响方法外面。
引用数据数据类型是传引用调用。①在方法内部对引用的修改,不影响方法外面;所谓的对引用进行修改就是使用赋值符号对形参进行赋值。②在方法内部对形参内部数据的修改,会影响方法外面;即对引用对象数据的修改会产生传递的效果。
① 修改数据内部数据,会影响实参数据值的情况,没有对数据数组重新赋值。即方法内部的修改会影响方法外面。
方法:
public void change(int[] array){//数组是一个引用数据类型
array[0] = 9;
for(int i : array){
System.out.print(i+"\t");
}
System.out.println();
}
调用:
int[] array = new int[]{1,2,3,4,5};
rp.change(array);
for(int k:array){
System.out.print(k+"\t");
}
System.out.println();
结果:9 2 3 4 5
② 修改数组的引用,不影响实参数据值情况,重新对数组进行赋值操作。即方法内部的修改不会影响方法外面。
方法:
public void change2(int[] array){
array = new int[]{2,3,4,5,6};
for(int i : array){
System.out.print(i+"\t");
}
System.out.println();
}
调用:
array = new int[]{1,2,3,4,5};
rp.change2(array);
for(int k:array){
System.out.print(k+"\t");
}
System.out.println();
结果:1 2 3 4 5
2.方法的调用
2.1 调用定义
方法调用,就是给方法的入口传入一些值(参数),然后在出口得到方法执行的结果(返回值)。注意:需要根据方法名称调用方法,方法只有在被调用后才生效。
注意方法调用的理解:优先从子类中查询方法,调用跟子类最接近的方法。
没有使用static修饰的方法称为实例方法,使用static修饰的方法称为类方法或静态方法。静态方法可以使用类名,方法名进行调用;实例方法必须通过实例对象进行调用。如果在同一个类中,可以省略类名,直接调用。
static修饰的全局变量或常量可以通过类名进行调用,例:String sex = VariableClass.WOMEN;
在定义方法时,参数列表上的参数称为形式参数,简称形参。形参是为了占位用,还不知道具体值。实际传递的参数叫实参.
对象引用方法/调用方法或属性/实例变量的操作符号时点号(.)。
例1:无参无返回值方法调用
package chap5.classroom;
public class Practice {
public static void show(){
System.out.println("hello");//方法声明
}
public static void main(String[] args) {
show();//调用方法
show();
}
}
例2:有参无返回值方法调用
package chap5.classroom;
public class Practice {
public static void show(int x,int y){
System.out.println(x+y);//方法声明
}
public static void main(String[] args) {
show(2,3);//调用方法
}
}
例3:查找颜色
方法:
private void printColor(String color,int count){
for(int i=0;i<count;i++){
System.out.println(color);
}
}
调用:
public static void main(String[] args) {
MethodsClass mClass = new MethodsClass();
mClass.printColor("紫色");
mClass.printColor("蓝色",3);
//静态方法可以使用类名,方法名进行调用
MethodsClass.printColor('白');
//如果在同一个类中,可以省略类名,直接调用
printColor('蓝');
}
mClass是一个实例变量的引用,经常把它称为实例对象。
2.2 递归调用方法
递归调用是方法体内调用自己。方法递归包含了一种隐式循环,它会重复执行某段代码,但这种代码执行无须循环控制。
递归调用时必须有终止条件,否则会产生死循环。
例1:用递归方法,计算1~100的和
Ans:
package chap5.classroom;
public class Recursion {
public static int sum(int num,int sum){
sum+=num--;
if(num==0){
return sum;
}else{
return sum(num,sum);
}
}
public static void main(String[] args) {
int a = 100;
int result = new Recursion().sum(a, 0);
System.out.println(result);
}
例2:用递归方法,计算阶乘:n!
Ans:
package chap5.classroom;
public class Recursion {
public static int factorial(int n,int sum){
sum*=n--;
if(n==1){
return sum;
}else{
return factorial(n,sum);
}
}
public static void main(String[] args) {
int b = 3;
int r = new Recursion().factorial(b,1);
System.out.println(r);
}
}
3.方法的重载
方法的重载(overload)就是在同一个类中,方法名相同参数列表不同。(参数的个数不同,参数的类型不同,参数类型的顺序不一样),与访问修饰符和返回值类型无关。
例:
public class MethodsClass {
public int add(int a,int b){
int ret = 0;
if(a==0 && b==0){
ret= -1;
}else{
ret = a+b;
}
return ret;
}
public static void printColor(char color){
System.out.println(color);
}
private void printColor(){
System.out.print("nono");
}
protected void printColor(String color){
System.out.println(color);
}
private void printColor(int color){
System.out.println(color);
}
public void printColor1(int count){
System.out.println(count);
}
//访问修饰符号时是默认(default)的
private void printColor(String color,int count){
for(int i=0;i<count;i++){
System.out.println(color);
}
}
void printColor(int count,String color){
for(int i=0;i<count;i++){
System.out.println(color);
}
}
public static void main(String[] args) {
MethodsClass mClass = new MethodsClass();
mClass.printColor("紫色");
mClass.printColor("蓝色",3);
MethodsClass.printColor('白');
printColor('蓝');
mClass.printColor(4,"红色");
int a = 5;
mClass.printColor(a);
}
}
4.练习
1.编写一个方法,求整数n的阶乘,例如5的阶乘是12345。 [必做题].
package chap5;
public class Subject1 {
public static int factorial(int n,int sum){
sum*=n--;
if(n==1){
return sum;
}else{
return factorial(n, sum);
}
}
public static void main(String[] args) {
new Subject1();
int b = 5;
int r = Subject1.factorial(b, 1);
System.out.println(r);
}
}
2.编写一个方法,判断该年份是平年还是闰年。[必做题]
package chap5;
public class Subject2 {
public static boolean leapYear(int n){
if(n%4==0 && n%10!=0 || n%40==0){
return true;
}else {
return false;
}
}
public static void main(String[] args) {
boolean b = leapYear(1890);
System.out.println(b);
}
}
3.编写一个方法,输出大于200的最小的质数。[选做题]
package chap5;
public class SubjectS1 {
public static int isPrime(){
boolean b = false;
int i;
int start = 201;
int num = 201;
while(b==false){
int k = (int)Math.sqrt(start);
for(i=2;i<=k;i++){
if(start%i==0){
break;
}
}
//如果start%i==0,那抛掉start,此时情况为:i<k
if(i<k){
start++;
}else{
b=true;
num=start;
}
}
return num;
}
public static void main(String[] args) {
int result = isPrime();
System.out.println(result);
}
}
4.写一个方法,功能:定义一个一维的int 数组,长度任意,然后将它们按从小到大的顺序输出(使用冒泡排序)(知识点:方法的定义和访问)。[选做题]
package chap5;
public class SubjectS2 {
public static int[] order(int[] arr){
for(int i=1;i<arr.length;i++){
for(int j=0;j<arr.length-i;j++){
if(arr[j]>arr[j+1]){
int a=arr[j+1];
arr[j+1]=arr[j];
arr[j]=a;
}
}
}
return arr;
}
public static void main(String[] args) {
int[] arr = {34,54,23,11,43,3};
System.arraycopy(order(arr), 0, arr, 0, arr.length);
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
}
}
5.判断一个数是不是质数
package chap5;
public class SubjectSS1 {
public static boolean prime(int n){
int m=2;
if(m<n){
if(n%m==0){
m++;
return false;
}
else{
return true;
}
}else{
return false;
}
}
public static void main(String[] args) {
boolean r = prime(300);
System.out.println(r);
}
}