java方法

一、简介

        方法(method)，就是一段具有特定功能的代码。可以通过调用名字在任意的位置上进行重复使用,从而达到代码简化的目的。尽量在设计方法的时候只完成一个功能。

        特点和有点：1. java程序中最小的执行单元
                              2. 提高了代码的重用性和可维护性

二、定义

        方法要定义在类体中，它是类的一个成员，定义方式如下：

[访问权限修饰符]  [其他的修饰符]  返回值类型  方法名([参数列表]) { 
   // 方法体
   [return]
}

        如：获取和的方法

 //修饰符 返回值类型   方法名字    形式参数
    public    int      getSum(int i,int j){
        return i+j;   //方法体
    }

解释：

        1.修饰符：这是可选的，告诉编译器如何调用该方法，定义该方法的访问类型（public、private等）

        2.返回值类型：方法可能会返回一个值，returnValueType是方法返回值的数据类型，但是有些方法执行所需要的操作，没有返回值的时候，那么返回值类型为void

        3.方法名字：是方法的实际名称，方法名和参数表共同构成方法签名

        4.参数类型：参数就像是一个占位符。当方法调用时，传递值给参数。这个值被称为实参或者变量。参数列表式指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何的参数

        5.形式参数：在方法被调用时用于接受外界输入的数据

        6.实参：调用方法时实际传递给方法的数据

        7.方法体：方法体包含具体的语句，定义该方法的功能

注意：

1. 中空号表示可有可无的部分：即需要的时候要写上，不需要的时候该位置可以不用写

2. 方法名是标识符，使用小驼峰命名法。

3. 方法之间是平级的，不允许出现方法嵌套方法。

三、访问权限修饰词

       方法并不是在任何位置上都可以被调用，与权限修饰词有关。权限大，能使用的地方就多，权限小，能使用的地方就少。

        具体如下：

static ： 静态的方法，在调用的时候直接使用类名调用。也可以在本类的其他方法中直接写方法名调用。

final：final修饰的方法在子类中不能被修改了，因为是最终修饰的了。

四、返回值类型

void：无返回值类型，表示这个方法没有返回值

java中的任意类型：当返回类型不是void的时候，必须要有一个指定类型的返回值作为方法执行的结果。

这就需要说一下return关键字

return：

        1.在方法中表示结束此方法，所以在return后不能有代码，因为结束方法就执行不到这些代码，没有意义。

        2.void类型的方法没有返回值，return关键字可以不加（return；）

        3.返回值是其他类型的方法，return关键字必须添加，而且return必须返回一个该方法返回值类型的变量或者表达式表示方法执行完毕后把数据返回个调用者。

五、方法的参数列表

方法的参数叫做形式参数——形参

1.方法定义期间，位于方法的小括号参数列表的位置

2.符合变量的声明格式，但是不可以初始化

3.声明的变量名只是一个形式用来接收调用者的实际参数，重要的是变量类型，用于告诉调用者应该传入什么类型的数据。

六、调用方法

在说调用方法前先说实际参数的概念

实际参数：        

        1.位于方法被调用的位置，调用时需要传给形参的数据或者变量

        2.实际上，就是给形参赋值

        3.赋值时，需要实际参数和形式参数的类型、个数和顺序一一对上

1.无参方法调用：方法名（）;

2.有参方法调用：方法名(实际参数列表）；

七、方法的重载

        重载就是在一个类中有相同的函数名称，但形式参数不同的函数（类型不同，变量相不相同都一样）。

        规则：

1.方法名称必须相同

2.参数列表必须相同（个数，类型，参数，排列顺序），方法的返回值类型可以相同可以相同也可以不同。

3.返回值类型不同不可以作为判断方法重载的条件，也就是说返回值类型可以相同也可以不同

实现过程：方法名称相同时，编译器会根据调用的方法的参数个数，类型取逐个匹配选择对应的方法

案例代码：

 //方法重载
    public static int add(int a,int b ){
        
        return a+b;
    }
    public static int add(int a,int b,int c ){
        
        return a+b;
    }
    public static double add(int a,int b,double c ){
        return a+b;
    }

八、方法的递归

        递归就是在方法内部再次调用方法自己，递归的能力在于用有限的语句来定义对象无限的集合。

        案例：

 public static int f(int i){  //递归调用解决阶乘问题
        if(i==1){
            return 1; //定义一个边界
        }
        return i*f(i-1); //返回阶段，一层一层往回边界调用
    }
// 例如 i=5  

九、方法的种类

        1.构造方法

  也叫做构造器，也称构造器，构造函数，构造方法的名称和类名一样，并且没有返回值，通过new加上构造方法可以创建一个对象，每个类都有一个默认的构造方法，如果重新声明了构造方法，则系统默认的构造方法将不再使用。

案例代码：

Text1 t1 = new Text1();//引用无参构造函数创建对象
Text1 t2 = new Text1("张三",18);//引用有参构造函数创建对象
12

        2.静态方法

• 关键字static修饰的方法称为静态方法，也叫类方法，静态方法不属于对象，而是属于类，随着类的加载而加载，优先于构造方法执行。

• 静态方法可以直接使用类名.方法直接调用，如果静态方法位于本类中可以直接省略类名直接调用

• 在静态方法中，可以访问静态方法，可以引用类变量（被static修饰的变量），不能访问非静态方法与变量，不能使用super和this关键字。

        3.非静态方法

• 是不含有static关键字修饰的普通方法，又称为实例方法，成员方法。属于对象的，不属于类的。（成员属性，成员方法是属于对象的，必须通过new关键字创建对象后，再通过对象调用）。

• 在非静态方法中，即可以调用非静态方法，也可以调用静态方法，可以引用类变量和成员变量，可以使用关键字super和this

案例代码：

public class Text3 {
    
    int age = 18;//成员变量
    static String name = "迪丽热巴";//类变量
    
    public static void main(String[] args) {
        Text3 t1 =  new Text3();
        method();//本类中调用静态方法，直接省略类名
        t1.method1();//调用成员方法
    }
    
    //静态方法
    static void method() {
        System.out.println("静态方法");
        //访问属性
        System.out.println(name);
        //System.out.println(age);//报错，静态不能访问非静态
        //t1.method();//报错
    }
    
    //非静态方法，也叫成员方法
    void method1() {
        System.out.println("非静态方法1");
        method();//既可以调用静态方法
        new Text3().method2();//又可以调用非静态方法
        
        System.out.println(name);//既可以访问静态属性
        System.out.println(age);//又可以访问非静态属性
    }
    void method2() {
        System.out.println("非静态方法2");
    }
}
​
//运行结果
/*
迪丽热巴
非静态方法1
静态方法
非静态方法2
迪丽热巴
18
*/

4.抽象方法

        关键字abstract修饰的方法称为抽象方法，抽象方法必须定义在抽象类（abstract修饰的类称为抽象类）中，抽象类中既有抽象方法，也有非抽象方法，但是抽象方法必须定义在抽象类中，并且抽象方法没有方法体

案例代码：

public class Text3 {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.cry();
        }
    }
​
    // 定义一个抽象类
    abstract class Animal {
        String name;
        int age;
        // 抽象方法
        public abstract void cry(); // 不确定动物怎么叫的。定义成抽象方法，来解决父类方法的不确定性。
                                    //抽象方法在父类中不能实现，所以没有方法体。但在后续在继承时，要具体实现此方法。
    }
    // 抽象类可以被继承
    // 当继承的父类是抽象类时，需要将抽象类中的所有抽象方法全部实现。
    class Cat extends Animal {
        // 实现父类的cry抽象方法
        public void cry() {
            System.out.println("猫叫:喵喵");
        }
    }