[Java基础]（方法格式、修饰符、返回值、方法名（形参）、静态方法、抽象方法、最终方法、方法重载、方法重写）

沫洺

已于 2022-11-19 20:11:47 修改

阅读量451

点赞数 1

分类专栏： Java基础文章标签： java

于 2022-08-05 19:29:24 首次发布

本文链接：https://blog.csdn.net/HeyVIrBbox/article/details/126170856

版权

Java基础专栏收录该内容

13 篇文章 4 订阅

订阅专栏

✨✨个人主页:沫洺的主页

📚📚系列专栏: 📖 JavaWeb专栏📖 JavaSE专栏 📖 Java基础专栏📖vue3专栏

📖MyBatis专栏📖Spring专栏📖SpringMVC专栏📖SpringBoot专栏

📖Docker专栏📖Reids专栏📖MQ专栏📖SpringCloud专栏

💖💖如果文章对你有所帮助请留下三连✨✨

🍁方法

🌺方法的好处

提高了代码的复用性。
让程序的逻辑更清晰。

🍃方法的格式

修饰符 返回值类型 方法名( 形参列表 ){
    方法体代码(需要执行的功能代码)
    return 返回值; 
}

修饰符

修饰符分为两种：访问权限修饰符，非访问权限修饰符

访问权限修饰符

public：共有访问。对所有的类都可见。
protected：保护型访问。对同一个包可见，对不同的包的子类可见。
default：默认访问权限。只对同一个包可见，注意对不同的包的子类不可见。
private：私有访问。只对同一个类可见，其余都不见。

非访问权限修饰符

static 修饰符，用来创建类方法和类变量，修饰后可直接调用。
final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
abstract修饰符，用来创建抽象类和抽象方法。
synchronized 用于多线程的同步。
volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
transient：序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。

返回值类型

返回值类型分为两大类：无返回值类型（void），有返回值类型（返回值的类型就是被返回数据的类型）。

void无返回值类型

void表示调用方法后无返回数据。方法里面可以写return语句，也可以不写。

写return后面没有写返回数据时，仅仅表示方法体的结束。
package moming;

public class Dome1 {
    public static void main(String[] args) {
        Dome1 dome1 = new Dome1();
        dome1.getName();
    }
    public void getName(){
        System.out.println("沫洺");
        return;
    }
}
沫洺

有返回值类型

如果这个方法有返回值，那么定义方法时必须指定返回数据的数据类型。
并且，在方法执行的最后一句必须是return语句。

例如下边的返回值类型为String，所以return的值类型也应该是String类型
package moming;

public class Dome1 {
    public static void main(String[] args) {
        Dome1 dome1 = new Dome1();
        System.out.println(dome1.getName());
    }
    public String getName(){
        String name = "沫洺";
        return name;
    }
}
沫洺

方法名（形参列表）

方法分为无参方法和有参方法，两者的区别就是前者调用时是无参调用，后者有参调用

形参列表可以有多个，甚至可以没有；如果有多个形参，多个形参必须用“，”隔开，且不能给初始化值。

package moming;

public class Dome1 {
    public static void main(String[] args) {
        Dome1 dome1 = new Dome1();
        System.out.println(dome1.getName());              //无参调用
        System.out.println(dome1.getName("有参的沫洺"));    //有参调用
    }
    public String getName(){
        String name = "无参的沫洺";
        return name;
    }
    public String getName(String name){  //将调用方法里的实参给方法里的形参
        return name;
    }
}

无参的沫洺
有参的沫洺

方法体（代码）

就是{}大括号里的代码段

return 返回值

注意有返回值的方法，接受这个方法返回值的变量类型要和返回值的类型保持一致

package moming;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;

public class Dome1 {
    public static void main(String[] args) {
        int age = getAge(22);
        String name = getName("沫洺");
        String[] arr = gettArr(new String[]{"a","b","c"});
        Date time = getTime(new Date());
        ArrayList<String> list = getList(new ArrayList<>(Arrays.asList("沫洺","23")));
        System.out.println(age);
        System.out.println(name);
        System.out.println(arr);
        System.out.println(time);
        System.out.println(list);
    }
    public static int getAge(int age){
        return age;
    }
    public static String getName(String name){
        return name;
    }
    public static String[] gettArr(String[] arr){
        return arr;
    }
    public static Date getTime(Date date){
        return date;
    }
    private static ArrayList<String> getList(ArrayList<String> list) {
        return list;
    }
}

22
沫洺
[Ljava.lang.String;@4c873330
Fri Aug 05 14:01:36 CST 2022
[沫洺, 23]

如果方法不需要返回结果，返回值类型必须申明成void(无返回值) , 此时方法内部不可以使用return返回数据。

注意

return语句下面，不能编写代码，因为永远执行不到，属于无效的代码。

补充

return; 跳出并立即结束所在方法的执行。
break; 跳出并结束当前所在循环的执行。
continue; 结束当前所在循环的当次继续，进入下一次执行。

🌾方法的调用流程

方法没有被调用的时候，在方法区中的字节码文件中存放

方法被调用的时候，需要进入到栈内存中运行

所以说方法的运行区域在栈内存

🌿方法种类（非访问权限修饰符）

静态方法

静态方法：被static修饰的方法。(static可与final，private共存)
格式: 
权限修饰符 static 返回值类型 方法名(参数){
    方法体;
}
静态成员（静态变量，静态方法）静态方法在类加载时就存在
静态方法只能调用静态成员，不能调用非静态成员。
静态属性，静态方法都是属于类的，可以直接通过类名.调用
类(包括抽象类)其静态方法是可以被继承的。
接口的静态方法不能被其实现类或者子接口继承。

抽象方法

抽象方法：被abstract修饰的方法(abstract 不能与static 和final修饰符共存)
格式:
权限修饰符 abstract 返回值类型 方法名(参数);
在继承父类(有抽象方法)、实现接口时，子类或实现类必须对抽象方法进行重写。
一般抽象方法没有方法体。

最终方法（最终类）

最终方法：被final修饰的方法
格式:
权限修饰符 final 返回值类型 方法名（）{
    方法体;
}
最终方法不能方法重写
最终类不能被继承，即不能有子类
最终类和非最终类都可以包含最终方法

🍂方法重载

同一个类中，出现多个方法名称相同，但是形参列表是不同的，那么这些方法就是重载方法。
形参列表不同指的是：形参的个数、类型、顺序不同，不关心形参的名称。
方法重载的作用：通过形参不同实现功能差异化的选择，可读性好，方法名称相同提示是同一类型的功能。

package moming;

public class Dome1 {
    public static void main(String[] args) {
        System.out.println(getUser("沫洺", 18, "男"));
        System.out.println(getUser("沫洺"));
        System.out.println(getUser(18,"沫洺",  "男"));
    }
    private static String getUser(String name) {
        String str = "沫洺是个大好人";
        return str;
    }
    private static String getUser(String name, int age, String sex) {
        String str = "沫洺是个好男人";
        return str;
    }
    private static String getUser(int age, String name, String sex) {
        String str = "沫洺是个大帅哥";
        return str;
    }
}

沫洺是个好男人
沫洺是个大好人
沫洺是个大帅哥

🌲方法重写

方法的重写是指两个方法的返回值、方法名、参数的类型和个数相同
一般是类在继承父类、实现接口时对父类或接口中的抽象方法进行方法重写的操作
方法的重写，不能发生在同类中，只能发生在子类或实现类中。
若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。

方法重写的权限：子类中的权限大于或等于父类的权限,（修饰符高低：private < 默认修饰符<protected < public）。

特殊情况：子类不能重写父类被声明为private权限的方法。

父类(Animal) 里面有个抽象方法和非抽象方法
package moming;

public abstract class Animal {
    public abstract void eat();
    public void sleep(){
        System.out.println("动物睡觉");
    }
}
接口() 接口默认方法是抽象的，公共的
package moming;

public interface Swim {
     void swim();
}
子类(实现类)() 子类继承父类、实现接口，重写抽象方法
package moming;

public class Dog extends Animal implements Swim{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
    @Override
    public void swim() {
        System.out.println("狗刨式游泳");
    }
    public void sleep(){
        System.out.println("狗睡觉");
    }
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();
        dog.swim();
    }
}
狗吃骨头
狗刨式游泳