java方法-带参方法-形参-实参-方法重载-方法的参数传递-构造方法

方法

方法概述

方法：是将具有独立功能的代码块组织成为一个整体，使其具有独特功能的代码集；

注意：
①方法必须先创建才可以使用，该过程称为方法定义；
②方法创建后并不是直接运行的，需要手动调用后才执行，该过程称为方法调用；

方法的定义和调用

注意：方法必须先定义后调用，否则程序会报错。

方法定义：

public static 返回值类型 方法名(){
		方法体；
}

// 这里定义static类型，因为后面的方法调用是static的main。

方法调用：在main方法中。

方法名（）;

案例：

public class Demo16{
    public static void main(String[] args) {
        isEvenNumer();
    }
    //定义方法：定义一个变量，判断变量是否是偶数
    public static void isEvenNumer(){
        int number = 10;//输出true
        number = 9;//输出false
        if(number %2 == 0){
            System.out.println(true);
        }else{
            System.out.println(false);
        }
    }
}

案例：

public class Demo16{
    public static void main(String[] args) {
        getMax();
    }
    public static void  getMax(){
        int a = 10;
        int b = 20;
        if(a > b){
            System.out.println(a);
        }else{
            System.out.println(b);
        }
    }
}

带参数方法的定义和调用

带参数方法定义格式

一般格式：
public class void 方法名(参数){.....}
单个参数：
public class void 方法名（数据类型 变量名）{.....}
多个参数：
public class void 方法名（数据类型1 变量名1，数据类型2 变量名2，...）{.....}

注意：
①方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序都将报错；
②方法定义时，多个参数之间使用逗号（,）分隔。

带参数方法调用

// 一般格式：
方法名（参数）；

// 单个参数：
方法名（变量名/常量名）；

// 多个参数：
方法名（变量名1/常量值1，变量名2/常量名2）；

注意：
方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序将报错。

带返回值方法的定义和调用

定义格式

public static 数据类型 方法名（参数）{
	return 数据；
}

注意：
方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错。

调用格式

格式1：
方法名（参数）；

格式2：
数据类型 变量名 = 方法名（参数）；

注意：
方法的返回值通常会使用变量接收，否则该返回值将无意义。

案例：实现接收一个参数，判断该数据是否是偶数，并返回真假值；

public class Demo17{
    public static void main(String[] args) {
        //调用格式1 不输出任何值。
        System.out.println("格式1");
        isEvenNumber(5);
        System.out.println("--------");
        isEvenNumber(8);
        System.out.println("格式2");
        boolean b = isEvenNumber(5);
        // 相当于 boolean b = false;
        boolean b1 = isEvenNumber(8);
        // 相当于 boolean a = true;
        System.out.println(b);
        System.out.println(b1);
    }
    public static boolean isEvenNumber(int number){
        if(number % 2 == 0){
            return true;
        }else{
            return false;
        }
    }
}

案例：获取两个数的较大值，数来自于参数

public class Demo17{
    public static void main(String[] args) {
        //使用定义好的方法保存结果
        int max = getMax(25,15);
        System.out.println(max);
        System.out.println("------------");
        //直接通过System.out.println();输出
        System.out.println(getMax(25,45));
    }
    public static int getMax(int a,int b){
        if(a > b){
            return a;
        }else{
            return b;
        }
    }
}

类方法

概念
可以被类所调用的，也能够被对象所调用的方法 = 类方法；

备注2022/8/11
类方法中可以直接调用本类的类方法；
类方法中可以使用this来调用本类的类方法；（类存在的属性和方法都可以使用this.xx调用）；
类方法中可以调用外部其他类的方法；
类方法中可以调用实例方法，只要实例化对象就可以。

形参和实参

形参：方法定义中的参数，等同于变量定义格式；
实参：方法调用中的参数，等同于使用变量或常量。

案例：设计方法用于打印两个数中的较大数，数据来自方法参数。

public class Demo17 {
    public static void main(String[] args) {
        //常量参数 实参
        getMax(10,20);
        System.out.println("-----------");
        //调用方法的时候，方法需要几个参数就定义几个，需要什么类型的变量就传什么类型的变量。
        //变量参数 实参
        int x = 20;
        int y = 30;
        getMax(x,y);
    }
    public static void getMax(int a,int b){
    // a 和 b 是形式参数
        if(a > b){
            System.out.println("最大的值是："+a);
        }else{
            System.out.println("最大的值是："+b);
        }
    }
}

备注2022/8/11
形参可以被视为local variable。
形式参数只能用final修饰符。（不能被字段修饰符修饰，字段修饰符 = new private protected public internal static readonly）

classes类名{
	[字段修饰符] 类型标识符 变量名 = new 类型标识符;
}

形式参数是类名，则形式参数就是对象。

形参和返回值

形参和返回值：
①基本数据类型：比较简单不介绍
②引用数据类型：重点介绍面向对象过程中的抽象类和接口

总结
形参和返回值：
类——需要类的对象；
抽象类——需要抽象类子类的对象；
接口——需要接口实现类的对象；

类名作为形参和返回值

① 方法的形参是类名，说明 需要是该类的对象

    public void useCat(Cat c){
        c.eat();
    }
    
    //创建操作类对象，并调用useCat方法
    CatOperator c = new CatOperator();
    //由于CatOperator类中的方法useCat需要一个Cat类型的对象
    Cat cc = new Cat();
    c.useCat(cc);

②方法的返回值是类名，说明 返回的是该类的对象

    public Cat getCat(){
        Cat c = new Cat();
        return c;
    }

抽象类名作为参数和返回值

①方法的形参是抽象类名，说明 需要该抽象类的子类对象

    public void useAnimal(Animal a){
        a.eat();
    }

   AnimalOperator ao = new AnimalOperator();
   //调用useAnimal方法，此时参数是抽象类对象
   //它的实例化必须使用多态的形式
   Animal c = new Cat();
   ao.useAnimal(c);

② 方法的返回值是抽象类名，说明 返回的是该抽象类的子类对象

 public Animal getAnimal() {
     Animal ao = new Cat();
     return ao;
 }

接口名作为形参和返回值

①方法形参是接口名，说明 需要的是该接口实现类对象

public void useJumpping(Jumpping j){
    // 测试类中Jumpping jj = new Cat();
    j.jump();
}

JumppingOperator jo = new JumppingOperator();
//接口不能直接实例化，需要创建接口的实现类，采用多态的形式创建实现类对象
Jumpping jj = new Cat();
//编译看左边，执行看右边； 左侧Jumpping类有jump这个方法；右侧Cat中重写了jump这个方法
jo.useJumpping(jj);

② 方法返回值是接口名，说明 返回的是该接口的实现类对象

public Jumpping getJumpping() {
    Jumpping j = new Cat();
    return j;
}

Jumpping jo2 = jo.getJumpping();
jo2.jump();

方法的注意事项

• 方法不能嵌套定义
• void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据；但是不能写return 常量或变量（明确的返回值）；
  

方法的通用格式

格式

public static 返回值类型 方法名（参数）{
	方法体；
	return 数据；
}

解释：

符号	说明
public static	修饰符
返回值类型	方法操作完毕之后返回的数据的数据类型；如果方法操作完毕，没有数据返回，这里写void，并且方法体中一般不写return
方法名	调用方法时使用的标识
参数	由数据类型和变量名组成，多个参数之间用逗号隔开
方法体	完成功能的代码块
return	如果方法操作完毕，有数据返回，用于把数据返回给调用者

两个明确

定义方法时：

• 明确返回值类型：主要是明确方法操作完毕之后是否有数据返回，如果没有，写void；如果有，则写对应的数据类型；
• 明确参数：主要明确参数的类型和数量。

调用方法

• void类型方法，直接调用即可
• 非void类型方法，推荐使用变量接收调用

方法重载

定义：
方法重载指同一个类中定义的多个方法之间的关系。

满足条件：

• 多个方法在同一个类中
• 多个方法具有相同的方法名
• 多个方法的参数不同，类型不同或数量不同

特点：

• 重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式
• 重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关；也就是不能通过返回值来判断两个方法是否相互构成重载。

案例：不是方法重载情况

案例：方法重载调用

public class Demo17{
    public static void main(String[] args) {
        //方法调用
        int result = sum(10,20);
        System.out.println(result);
        double result2 = sum(11.0,10.0);
        System.out.println(result2);
        int result3 = sum(1,1,1);
        System.out.println(result3);
    }
    //求两个int类型数据和的方法
    public static int sum(int a,int b){
        return (a+b);
    }
    //求两个double类型数据和的方法
    public static double sum(double a,double b){
        return (a + b);
    }
    //求三个int类型数据和的方法
    public static int sum(int a,int b,int c){
        return (a + b + c);
    }
}

说明
①方法重载与返回值无关；
②在调用的时候，java虚拟机会通过参数的不同来区分同名的方法。

练习案例
使用方法重载思想，设计比较两个整数是否相同的方法，兼容全整数类型（byte、short、int、long）

public class Demo17{
    public static void main(String[] args) {
        //调用方法
        System.out.println(compare(10,20));
        //由于整型默认是int类型，所以执行的是方法compare(int a,int b)
        System.out.println(compare((byte)10,(byte)20));
        //因为int类型比byte类型范围大，所以需要使用强制类型转化
        System.out.println(compare((short)10,(short)20));
        //因为int类型比short类型范围大，所以需要使用强制类型转换
        System.out.println(compare(10L,20L));
        //加L因为：定义long类型数据，不加L系统会按照整型默认int类型处理，但实际想定义的是long类型会超过int类型的取值范围而报错。
    }
    public static boolean compare(byte a,byte b){
        System.out.println("byte");
        return a == b;
    }
    public static boolean compare(short a,short b){
        System.out.println("short");
        return a == b;
    }
    public static boolean compare(int a,int b){
        System.out.println("int");
        return a == b;
    }
    public static boolean compare(long a,long b){
        System.out.println("long");
        return a == b;
    }
}

方法的参数传递

方法的参数传递传递的是值 不是 引用。

基本数据类型

对于基本数据类型的参数，形式参数的改变，不影响实际参数的值。

理解：

案例代码：

public class Demo17{
    public static void main(String[] args) {
        int number = 100;
        System.out.println("调用change方法前：" + number);
        //输出 100
        change(number);
        System.out.println("调用change方法后：" + number);
        //输出 100
    }
    public static void change(int number){
        number = 200;
    }
}

引用类型

对于引用类型的参数，形式参数的改变，影响实际参数的值。

理解：

案例代码：

public class Demo17{
    public static void main(String[] args) {
        int[] arr = {10,20,30};
        System.out.println("调用change前："+arr[1]);
        change(arr);
        System.out.println("调用change后：" + arr[1]);
    }
    public static void change(int[] arr){
        arr[1] = 200;
    }
}

构造方法

构造方法概述

构造方法是一种特殊的方法。
作用：创建对象
功能：主要是完成对象数据的初始化
格式：

public class 类名{
	修饰符 类名（参数）{
	}
}

IDEA中的快捷键 :（创建构造方法）alt + inster（小键盘上的0数字键，按键顺序num lock》0）
其中点击constructor，创建构造方法的选项，要想创建带多个参数的构造方法，需要按下shift再通过鼠标左键选中。
具体图示：

案例

// 111-StudentDemo3
//学生测试类
public class StudentDemo3 {
    public static void main(String[] args){
        //创建对象
        Student2 stu = new Student2();

        stu.show();
    }
}

//学生类 构造方法
public class Student2 {
    //成员变量
    private String name;
    private int age;
    //成员方法
    public void show(){
        System.out.println(name + "," + age);
    }
    //构造方法
    public Student2(){
    //构造方法的方法名必须和类名一致，不一致会报错
        System.out.println("无参数构造方法");
    }
}

构造方法的注意事项

• 构造方法的创建
  ①如果没有定义构造方法，系统将给出一个默认的无参数构造方法；
  ②如果定义了构造方法，系统将不再提供默认的构造方法。

• 构造方法的重载
  ①如果自定义了带参数构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法。

• 推荐的使用方式
  无论是否使用，都手工书写无参数构造方法。

案例

// 111 
//学生类
public class Student {
    //成员变量
    private String name;
    private int age;
    //成员方法
    public void show(){
        System.out.println(name + "," + age);
    }
    //构造方法
    //没有写构造方法的时候，在测试类中创建对象的时候也没有报错，原因是创建对象的时候，所对应类没有构造方法，系统会默认创建一个无参构造方法。
    //一旦在类中给出有参数的构造方法，系统将不在提供无参的构造方法，如果需要使用，必须手动给出。
    public Student(){//构造方法的方法名必须和类名一致，不一致会报错
        System.out.println("无参数构造方法");
    }
    public Student(String name){
        this.name = name;
    }
    public Student(int age){
        this.age = age;
    }
    public Student(String name,int age){
        this.name = name;
        this.age = age;
    }
}

//测试类
public class StudentDemo {
    public static void main(String[] args){
        //创建对象
        Student stu = new Student();//无参构造对象
        //输出无参数构造方法
        stu.show();//null,0

        Student stu1 = new Student("汪苏泷");
        stu1.show();//汪苏泷,0

        Student stu2 = new Student(33);
        stu2.show();//null,33

        Student stu3 = new Student("许嵩",36);
        stu3.show();//许嵩,36
    }
}

构造方法特点

①构造方法的名称必须与类名相同
②构造方法可以带参数
③构造方可以重载
④构造方法有返回值，但是不能写返回值类型。

④解析：
当创建对象时：类名 变量名 = new 类名(); 
该构造函数会返回一个 类名 类型的值，而这个值就是对象的地址。

备注2022/8/11
Class中的constructor不可以省略；（默认省略，自带空参构造函数）
constructor必须与class同名，但方法不能与class同名；（成员方法可以与类名相同）
constructor在一个对象被new时执行；
一个class只能定义一个constructor（空参构造和有参构造，多个）。

实例方法

备注2022/8/11

• 实例方法 = 相对于类方法的其他方法；类方法 = static关键字修饰的方法；
  实例方法可直接调用超类的实例方法。（不可以调用父类的private实例方法）
  实例方法可直接调用超类的类方法。（类方法只有本类可以调用）
  实例方法可直接调用其他类的实例方法。（×）
  实例方法可直接调用本类的类方法。（√）