【Java】方法基础知识-CFANZ编程社区

文章目录

方法基础知识

一、方法的定义
二、方法的调用
三、方法的返回值
四、方法的重载
五、方法的重写

5.1 方法重写规则

六、方法重载、重写的区别

返回顶部

方法基础知识

一、方法的定义

方法包含一个方法头和一个方法体。下面是一个方法的所有部分：

修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}

修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
返回值类型：方法可能会返回值。returnValueType是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下return
ValueType 是关键字void。
方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
方法体：方法体包含具体的语句，定义该方法的功能。

返回顶部

二、方法的调用

含有static的方法（静态方法），完整的调用方法是：类名.方法名（实参） ;
不含static的方法（成员方法），必须先创建对象，然后：引用.方法名（实参）;
在同一个类中调用时，可以省略 “类名.”；但当未声明 “类名.”时，默认从当前类中寻找方法，不能省略类名调用其他类中的方法。

public class method {
  
  public static void sum(long a,long b){ //形参
    System.out.println(a+"+"+b+"="+(a+b));
    method1.dosome(); //调用dosome方法体
  }
  
  public static void dosome(){
     System.out.println("hello world!");
  }
  //形参与实参个数与类型都要一一对应
  //存在类型自动转换  
  //   int-->long  double！-->long

  /**
   * @param args
   */
  //主方法
  public static void main(String[] args) {
    // TODO Auto-generated method stub
    
      method.sum(14,25); //实参列表
      method.sum(2l, 3l);
      dosome();   
  }
}

结果：
14+25=39
hello world!
2+3=5
hello world!
hello world!

返回顶部

三、方法的返回值

1.当该方法没有特殊声明返回值类型的时候，默认为void类型

2.方法的返回值类型不是void的时候：

要求方法必须保证百分之百的执行“return 值;”的语句来进行值的返回
一个方法有返回值的时候，当我们调用了这个方法，，方法返回了一个值，对于调用者来说，我们可以选择接收返回值，也可以选择不接收。但一般情况下的都是接收的。

public class method {
    //方法
    public static int divide(int a, int b) {
        System.out.println("I love you!");
        int c = a / b;
        return c;
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        divide(10, 3); //调用方法,这里没有接收返回值
        //接下来接收返回值
        //采用变量接收
        //变量的数据类型需要和返回值的数据类型相同，或者可以自动数据类型转换
        //boolean  b = divide(10,3);  编译出错，类型不兼容
        
        //等号（赋值运算符）的右边先执行，结果赋给i
        int i = divide(10,3);
        System.out.println(i);
        
        long x = divide(10,3);
        System.out.println(x);
        
        System.out.println(divide(10,3));
    }

}

错例：

* 没有返回值 
* public static int divide(int a,int b){ 
*                return ; 
* }

* 返回类型不相符
*  public static int divide(int a,int b){
*                return true ; 
* }

3.返回语句 return；

深入return语句：

带有return关键字的Java语句只要执行，所在的方法执行结束
在同一个作用域中，return语句下面不能编写任何代码，因为return语句下的代码永不执行**

public class method {
  
  /*缺少返回语句，无法保证"return 1"能够执行*/
     public static int m(){
       int a=10;
       if(a>3){
         return 1;
       }
     }
     
   /* 可以保证返回值的执行 */
  public static int m(){
       int a=10;
       if(a>3){
         return 1;
       }else{             //else语句
         return 0;
       }
     }    
  
   public static int m(){
       int a=10;
       if(a>3){
         return 1;
       } //这样同样可以，因为如果满足了就不执行return以后的语句，否则继续
       return 0;
     }  
   
  /**
   * @param args
   */
  public static void main(String[] args) {
    // TODO Auto-generated method stub
    m();
    System.out.println(m ());
  }
}
结果：
1

4. 在含有“viod”的方法中使用“return 语句”

"return;"在返回值为 void 的语句中时，主要作用就是终止当前方法

public class method91 {
   
  /*编译器报错，为空的方法 ，不能带有返回值
  public static void m(){
    return 10;
  }
  */
  /*
   public static void m(){
     return;
  }
   */
  
  public static void m(){  //return;语句不是结束for循环，而是结束整个方法
      for(int i=0;i<9;i++){
        if(i==4){        
          return;
        }
        System.out.print(i);
      }
      System.out.println("Hello World!");
  }
  // 对比：
  public static void m1(){      //break；语句是结束当前for循环
      for(int i=0;i<9;i++){
        if(i==4){        
          break;
        }
        System.out.print(i);
      }
      System.out.println("Hello World!");
  }
  /**
   * @param args
   */
  public static void main(String[] args) {
    // TODO Auto-generated method stub
           m();
           m1();
           
           for(int i=9;i>0;i--){
             if(i==4){
                return;
             }
             System.out.println("i-->:"+i);
           }
          System.out.println("hello world!!!");
  }

}
结果：
0123
0123
hello world!!!
i-->:9
i-->:8
i-->:7
i-->:6
i-->:5

返回顶部

四、方法的重载

1.又被称为：overload
2.什么时候考虑使用方法重载？

功能相似时，尽力让方法名相同；功能不同时，尽量不同名

3.什么条件满足了之后构成方法重载？

 在同一个类中
 方法名相同
 参数列表不同：
   -数量不同
   -顺序不同
   -类型不同

4.方法重载与什么有关系？与什么无关？

方法重载与方法名 + 形参参数列表关
方法重载与返回值类型无关
方法重载与修饰符列表无关

public class method {

  public static void m1(){}
  public static int  m1(int a){
    return a;
  }
  
  public static int m2(int a,int b){
    return b ;
  }
  public static double m2(double a,double b){
    return b;
  }
  public static long m2(long a,long b){
    return b;
  }
  
  /*错例：
  方法重复了，起决定作用的时方法里定义的类型*/
  public static void m4(int a,int b){}
  public static void m4(int b,int a){}
  
  /*方法重载与返回值类型无关*/
  public static int m4(){}
  public static void m4(){}
  
  /*方法重载与修饰符列表无关*/
  void y(){}
  public static void y(){}
  
  
  /**
   * @param args
   */
  public static void main(String[] args) {
    // TODO Auto-generated method stub
    m1();
    System.out.println();
    m1(10);
    System.out.println(m1(10));
    m2(10,100);
    System.out.println(m2(10,100));
    m2(10.0,10.2);
    System.out.println(m2(10.0,10.2));
    m2(4l,5l);
    System.out.println(m2(41,51));
  }
}
结果：

10
100
10.2
51

返回顶部

五、方法的重写

方法的重写主要在继承时涉及较多。当子类继承了父类的方法之后，由于子类具有父类功能/行为的同时又具有独特的模式，此时使用父类的方法不能够满足子类需求，那么我们就需要重写父类的方法体。
注意重写时格式、参数要与父类方法保持一致。

5.1 方法重写规则

方法的重写规则参数列表必须完全与被重写方法的相同。
返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类（java5 及更早版本返回类型要一样，java7及更高版本可以不同）。
访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为protected。
父类的成员方法只能被它的子类重写。
声明为 final 的方法不能被重写。
声明为 static 的方法不能被重写，但是能够被再次声明。
子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。
子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
构造方法不能被重写。
如果不能继承一个方法，则不能重写这个方法。

package 多态;
//动物类
public class Animal {
  public void move(){
    System.out.println("动物在移动。");
  }
}

package 多态;
//鸟类
public class Bird extends Animal {
  //重写父类方法
  public void move(){
      System.out.println("鸟儿在飞翔。");
    }
}

package 多态;
//猫类
public class Cat extends Animal {
  //重写父类方法
   public void move(){
      System.out.println("猫在走猫步。");
    }
   //猫类中特有的方法
    public void catchMouse(){
      System.out.println("猫抓老鼠!");
    }
}

返回顶部

六、方法重载、重写的区别

方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载可以理解成多态的具体表现形式。

(1) 方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载(Overloading)。
(2) 方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写(Overriding)。
(3) 方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。

区别点	方法重载	方法重写
访问权限修饰符	可以修改	一定不能缩小范围，可以适当扩大范围
返回类型	可以修改	一定不能修改
参数列表	必须修改	一定不能修改
异常	可以修改	可以减少或删除，一定不能抛出新的或者更广的异常

返回顶部