方法

最新推荐文章于 2024-07-18 15:51:14 发布

B站大学酥糖

最新推荐文章于 2024-07-18 15:51:14 发布

阅读量206

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_45907053/article/details/107116819

版权

Java基础专栏收录该内容

37 篇文章 1 订阅

订阅专栏

面向对象

方法

方法:具有特定功能的代码段
方法作用是让其可重复使用完成某一个功能
当某段代码(功能)如果经常使用,那么可以使用一个大括号,将这段代码包裹起来,再给这段代码起个名字,以后就可以使用这个名字访问这个功能，这就是方法
    
    
    注意：
方法定义在类体当中,方法体之外（方法体里面代码执行时候是从上至下顺序执行的）
注意：方法体不能定义方法

根据是否有返回值,方法是否有参数:可以分为四类:

无参数无返回值方法
有参数无返回值方法
无参数有返回值方法
有参数有返回值方法

比如，这是没有使用方法写的代码

很明显的看出他们的功能是一样的都说求和，只是数据不一样，代码并没有得到复用

//程序1：计算13与14的和
int a=13;
int b=14;
int c=a+b;
System.out.println(a+"+"+b+"="+c);  //13+14=27 
//程序2：计算333与666的和
int d=333;
int e=666;
int f=d+e;
System.out.println(d+"+"+e+"="+f);  //333+666=999

使用方法写的代码

public class JiCai {
	public static void main(String[] args) {
	
		JiCai.qiuh(13,14);                  //实参，方法调用
		JiCai.qiuh(333,666);
		JiCai.qiuh(44,14);
}
	public static void qiuh(int a,int b){  //形参
	    int c=a+b;                         //返回值有没有看你是否需要函数的返回值
	    System.out.println(a+"+"+b+"="+c);
	}

//public表示公开的
//class表示定义类
//Turyn是一个类名
public class Turyn//表示定义一个公开的类，起名Turyn，由于是公开的类，所以源文件名必须是Turyn
//类体
//类体中不能直接编写java语句，除声明变量之外
//方法出现在类体当中
    
//方法
//public表示公开的
//static表示静态的
//void表示方法执行结束之后不返回任何数据
//main是方法名：主方法
//(String [] args)是形式参数列表，其中String []是一种引用数据类型，args是一个局部变量的变量名
//所以以下只有args这个局部变量的变量名是可以随意的修改
//主方法就需要这样固定编写，这是程序入口，sun公司规定的
    public static void main(String [] args){ 
   
}

方法定义

修饰符列表 返回值数据类型 方法名(参数列表){
            方法体;
            [return语句;]  (返回值有没有看是否需要函数的返回值，return语句可以理解为函数结束)
}


类（public class 类名）里面有两个方法，
    1、第一个方法是主方法，里面包含是调用语句，第二个方法是类体中写的方法，里面有包含是返回语句
    2、第二个方法修饰符里面如果包含static，主方法在调用的时候使用 类名.方法名（实参）

修饰符列表看类笔记里面的成员变量哪里有详细说明

1、返回值类型

由于返回值是一个具体存在的数据，数据都是有类型的，所以需要指定的是返回值的具体类型，

Java任意一种类型都可以，也有可能方法执行结束后不返回任何数据，

一个方法不返回任何数据那么返回值类型位置必须是void关键字

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eN5NG60I-1593787186160)(D:\Typora图片\1593245677989.png)]

1、如果返回值类型不是void是其他的类型，那么大括号里面必须保证有一个return语句执行，return 值;不然报错,并且要求值的数据类型与方法的返回值类型一致

2、但是如果返回值类型是void时，方法体不能编写return 值;但是可以写return;

3、只要带return关键字的语句执行，那么所在的方法结束也就是弹栈，因为方法结束会发生弹栈，而return就是表示方法结束但是不是jvm结束，是return所在方法结束。

4、

修饰符列表 A 方法名(参数列表){     //规定返回值类型是布尔型
            方法体;
            [return语句;]      //那么这里应该写return true或者return false
}

A这里就是返回值数据类型
也就是在这里定义了方法的返回值数据类型，它在这里定义了这个方法执行结束后应该返回一个什么样类型的数据，规定好方法的返回值类型是什么，一旦规定好，那这个方法执行结束后必须得返回类型数据，如果没有返回这种数据，那么编译器会报错。

举例

当方法返回值表示void的时候

public class tyy{
    public static void main(String[] args){
 //需求，定义并实现一个方法，该方法可计算两个int类型数据的商，要求将最终计算的结果返回给调用者       
    public static int divide(int a,int b){
//返回值类型不是void的时候，要求方法必须百分百的执行return值;这样的语句来完成值的返回，不返回就报错        
        int c=a/b;
        return c; //这样写麻烦还可以 return a/b;
    }
}

写完以后不会有任何结果，是因为没有调用

public class tyy{
    public static void main(String[] args){
//方法调用
//        由于在同一个类当中调用时，类名.可以省略
//            所以
        divide(10,3);   //这里没有接收方法的返回数据 
    public static int divide(int a,int b){
      return a/b;
    }
}
    
注意，这是调用，但是对于接受者来说可以选择不接收

采用变量接收返回值

变量的数据类型需要和返回值的数据类型相同，或者可以自动类型转换

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


// 赋值运算符的右边先执行，将执行结果赋值左边的变量       
        int i=divide(10,3);   //将调用的结果赋值到左边
                              // boolean b=divide(10,3); 编译报错，类型不兼容
        System.out.println(i);
//或者是        
       // System.out.println(divide(10,3));
       //同样的也是先执行右边divide(10,3)再打印输出
    public static int divide(int a,int b){
      return a/b;
    }
}

总结，要想输出结果必须得调用然后用变量去接受 结果=调用+变量接收

2、方法名

只要是合法标识符就行，最好是一个动词

方法名是用小驼峰命名规则，第一个字母小写，其余首字母大写

3、参数列表

简称形参，是局部变量，是变量就有数据类型

形参个数0-n个,多个形参用逗号隔开

int a,double b;

形参中起决定性作用的是形参的数据类型

//方法定义
public static int sum(int a,int b){  //这是形参
    
}
//方法调用
sum("abc","def");//编译器报错
//因为规定的是（int a,int b）是int类型数据，但是调用时候传递的却是字符串类型，所以形参中起决定性作用的是形参的数据类型
//    改
    sum(34,55);

形参名字只是一个标识符，形参名字 = 局部变量名字

4、实参

方法在调用的时候，实际给这个方法传递的真实数据被称为实际参数简称实参。

实参与形参必须满足数量相同和类型相同

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VbqGDBKW-1593787186166)(D:\Typora图片\1587191208715.png)]

public class tyy{
    public static void main(String[] args){
         tyy.sum();             //编译错误，参数数量不同
         tyy.sum(true,false);   //编译错误，实参和形参的类型不是对应相同的
         tyy.sum(10L,20L);      //正确
         tyy.sum(10,20);        //也正确，它存在自动类型转换int转为long
         tyy.sum(10.0,20);      //错误，浮点型比long类型大，不能进行自动转换
         tyy.sum((long)10.0,20);//正确
    }
    
    
    public static void sum(long a,long b){
        System.out.println(a+"+"+b+"="+(a+b));
    }
}

类型不同时要求能够进行相应的自动类型转换

5、方法体，类体

方法定义在类体当中，在一个类体中可以定义多个方法

方法体当中不能再定义方法

类体中不能直接写Java语句，但是除声明变量以外

方法体里面的代码有顺序（自上而下）但是方法体外面的代码暂时没有顺序，对于方法的编写位置没有先后

方法体里面的语句是为了完成某个功能的代码，使用会自上而下执行到分号结束

6、方法调用

如果方法只是定义不去调用则程序是不会执行的，

第一种：通过对象名.方法名进行调用，这是最普通的也是最常见的一种调用方式

第二种：通过new关键字调用构造方法，这种是在实例化对象时使用的方式

第三种：通过类名.方法名调用，当需要调用的那个方法为静态（有static的）方法时使用，表示用来调用某一类的方法

注意：方法的修饰符列表当中有static关键字，那么完整的调用方式是类名.方法名(实参列表); 但是有时候类名.可以省略

public class tyy{
    public static void main(String[] args){
//调用方法
        tyy.m();      //运行结果m method execute!    没有省略                
        m();          //运行结果m method execute!    省略了类名.
    }
    public static void m(){
        System.out.println("m method execute!");
    }
}
//这是在本类中调用的

调用其他类中的方法

不是本类中的

public class tyy{
    public static void main(String[] args){
       
        tyy.m();        
        m();
 //找的是当前这个类中的m方法       
 //调用其他类中的方法不是本类中的(是不是本类中的看大括号类的范围)    
        A.doOther();//运行结果 A's doOther method invoke!
 //表示调用A里面的doOther();方法 
        
        
 /*
 现在把A.doOther();中类名.省略掉，doOther(); 是不会执行的，因为去掉后表示是在当前这个类（也就是tyy这个类里面去找不会去A里面找）
 省略掉表示从当前类里面去找（当前类指调用语句被被包含的类里面）
 */
        
        
    }
    public static void m(){
        System.out.println("m method execute!");
    }
}

//调用其他类中的方法
class A{
    public static void doOther(){
        System.out.println("A's doOther method invoke!"); 
    }
}

又增加一个方法m2

public class tyy{
    public static void main(String[] args){
         tyy.m();        
         m();
         A.doOther();

    }
    public static void m(){  //m方法在调用时候可以去调用别的方法
        System.out.println("m method execute!");
        m2();//省略式，完整式是tyy.m2();
    }
// 又增加一个方法m2   
    public static void m2(){
        System.out.println("m2 execute!");
    }    
}


class A{  //注意，一个java文件中最好只写一个class，这里为了效果才写这个class
    
    public static void doOther(){
        System.out.println("A's doOther method invoke!"); 
    }
}

在调用方法同时还可以调用方法里面的方法

如果在其他类中也存在m2，需要调用其他类中m2不去调用本类中，那么就需要添加类名.

m1(){
    m2();
}

m1方法和m2方法在同一个类体当中的时候（也就是m1调用的时候可以调用m1里面的m2），类名.可以省略

方法的调用不一定在main方法中，可以在其他方法当中，只要是程序可以执行到的位置，都可以去调用其他方法

public class Mehg{
    public static void sum(int a,int b){
        System.out.println(a+"+"+b+"="+(a+b));
//调用doSome方法
       Mehg.doSome(); 
    }
    
//主方法    
public static void main(String[] args){
    
//调用sum方法
  Mehg.sum(1,2);
    System.out.println("Hello World!");
}    
    public static void doSome(){
      System.out.println("do some!");   
    }
}

7、深入return语句

方法调用完成之后,如果产出了数据,需要把这个数据给调用者返回,就需要通过return关键字,把方法内部的数据返回值调用者. 如果没有数据产出,也可以使用return,作用提前结束一个方法.

只要return关键字执行那么他所在的方法就执行结束。
在同一个作用域当中return语句下面不能编写任何代码，因为这些代码执行不到，编译器会报错。

或者当缺少返回语句，程序编译器也会报错

//编译器认为不能100%保证return1执行，所以会报错
public class FaFang{
  public static void main(String[] args){
  
  }
   public static int m(){ 
   
  //此方法必须返回一个int类型的结果，无法100%保证return 1;执行
    int a=10;
    if(a>3){    //这是大于3的处理办法，那如果它不是大于3怎么办，所以缺少了一个返回语句
         //缺少返回语句，所以编译不能通过
//因为编译器检测出a>3有可能为turn或者false ，当为假时候return 1;通过不了 ，通过不了这个大括号就不返回          
    return 1;
    }
    }
}

给它加一个返回语句，

只要带了else语句100%会保证执行

public class FaFang{
  public static void main(String[] args){
  
  }
    public static int m(){  
  
    int a=10;
    if(a>3){    
    return 1;
    }else{  //这里有一个else，它不是执行语句1就是语句0，会100%保证执行，所以编译通过
        return 0;
    }
    }
}



//加上调用输出
    
   public class FaFang{
  public static void main(String[] args){
  System.out.println(m());
      //因为现在m是一个方法，不是变量
  }
    public static int m(){  
  
    int a=10;
    if(a>3){    
    return 1;
    }else{  
        return 0;
    }
    }
}

else可以去掉

public class FaFang{
  public static void main(String[] args){
  
  }
    public static int m(){  
    int a=10;
    if(a>3){    
          return 1;
    }               //这里没有else{ 语句，但是和有了 }else{ 语句是一模一样的
          return 0;
    }
    }

同一个作用域当中return语句下面不能编写任何代码，因为这些代码执行不到，编译器会报错

public class FaFang{
  public static void main(String[] args){
  }
    public static int m(){  
    int a=10;
    if(a>3){    
          return 1;
          System.out.println("殊");//这里报错Unreachable code执行不到的代码
    }              
          return 0;
    }
    }

但是放在括号下面可以执行

public class FaFang{
  public static void main(String[] args){
  }
    public static int m(){  
    int a=10;
    if(a>3){    
          return 1;         
    }  
         System.out.println("殊");
          return 0;
    }
    }
//因为当a>3不成立时候也就不执行return 1肯定会跑去执行return 0，所以
//System.out.println("殊");会执行

但是我们一般使用

public static int m(){
    return 10>3 ? 1:0;
}

返回值类型是void的方法当中使用return语句

在返回值类型是void的方法当中，使用return;语句

没有运行结果

public class FaFang{
     public static void main(String[] args){
  }
     public static int m(){ 
         return 10;//编译错误，因为对于结果类型为空的方法，无法返回值
     }
}

没有运行结果

public class FaFang{
     public static void main(String[] args){
       m();  //调用方法
  }
     public static void m(){ //如果这里缺少void则会报错此方法必须返回int类型的结果
         return;
     }
}

return;语句出现在返回值为void的方法当中，主要是为了终止方法的执行

public class FaFang{
     public static void main(String[] args){
      
  }
     public static void m(){ 
        for(int i=0;i<10;i++){
            if(i==5){
                return;//终止的是m方法不终止for循环
                //作用域整个方法
              
            }
          System.out.println("i-->"+i);
        }
          System.out.println("Hello World!");
     }
}

输出结果为0-4没有输出Hello World!  因为他终止的是方法所以不输出 Hello World!

public class FaFang{
     public static void main(String[] args){
      
  }
     public static void m(){ 
        for(int i=0;i<10;i++){
            if(i==5){
                //return;
                break;//终止的是for循环，作用域for循环
            }
          System.out.println("i-->"+i);
        }
          System.out.println("Hello World!");
     }
}


输出结果为0-4和Hello World!

public class FaFang{
     public static void main(String[] args){
     
       m();
         
         for(int i=10;i>0;i--){
             if(i==2){
                 return;//结束的是main方法
 //如果是break还会执行 Execute World!               
             }
            System.out.println("data-->"+i); 
         }
       System.out.println("Execute World!");  
  }
    
     public static void m(){ 
        for(int i=0;i<10;i++){
            if(i==5){
                return;
              
            }
          System.out.println("i-->"+i);
        }
          System.out.println("Hello World!");
     }
}

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FZnotw1c-1593787186170)(D:\Typora图片\1593270996699.png)]$

分析以下程序的输出结果

public class yu{
    public static void main(String[] args){
        System.out.println("main begin");
        m1();//只有当这行结束下面的才会执行
             //暂停
        System.out.println("main over");
    }
    public static void m1(){
      System.out.println("m1 begin");
      m2();  //暂停
      System.out.println("m1 over"); 
    }
     public static void m2(){
      System.out.println("m2 begin");
      m3();  //暂停
      System.out.println("m2 over"); 
    }
     public static void m3(){
      System.out.println("m3 begin");
      System.out.println("m3 over"); 
    }
}

首先从程序入口开始执行
    main begin
    main begin执行完毕就到了 m1();只有 m1();执行结束下面的main over
    所以先执行m1也就是去调用m1
    m1 begin
    同理m1执行完毕也才能执行m1 begin所以先执行m2也就是去调用m2
    m2 begin
    同理调用m3
    m3 begin
    m3 over
      m3 over结束就代表m3由暂停恢复了活跃状态，所以也就执行m2 over
    m2 over输出后m2就结束了
    m2结束就输出m1 over
    m1 over输出又表示m1结束，结束就输出main over
    
    
    所以执行顺序
     main begin
     m1 begin
     m2 begin
     m3 begin
     m3 over
     m2 over
     m1 over
     main over