创建javabean时，使用继承、接口、抽象类

接口中静态方法和，默认方法的区别

格式:

静态方法：使用static关键字定义的方法。它属于类，而不是类的实例。可以通过类名直接调用，不需要创建类的实例。

默认方法：在接口中定义的方法，没有使用abstract关键字，并且提供了实现。它允许接口有非抽象方法。

调用方式:

静态方法：可以通过类名直接调用，也可以通过类的实例调用。

默认方法：只能通过接口的实例调用，不能通过类名直接调用。

多态性:

静态方法：不支持多态，因为它们属于类而不是对象。

默认方法：支持多态，因为它们属于接口，而接口可以实现多态。

目的:

静态方法：通常用于工具类方法，如Math类中的数学计算方法。

默认方法：用于在不破坏现有实现的情况下向接口添加新的方法实现。

与继承的关系:

静态方法：子类不会覆盖父类的静态方法，因为静态方法属于类而不是对象。

默认方法：如果子类或实现类提供了与默认方法同名的方法，那么子类的方法会覆盖接口的默认方法。

使用场景:

静态方法：适用于不需要访问对象状态的场景，如数学计算、常量访问等。

默认方法：适用于在接口中提供可选的实现，允许不同的实现类有不同的行为。

与实例的关系:

静态方法：不依赖于类的实例，因此不能直接访问类的实例变量或实例方法。

默认方法：可以访问接口中定义的实例变量和方法，因为它们在实现类中是可见的。

与构造函数的关系:

静态方法：可以在构造函数执行之前调用。

默认方法：不能在构造函数执行之前调用，因为它们依赖于对象的实例。

实例

题目

最开始的父类

该父类可以直接用abstract修饰，变为抽象类，因为直接创建人的对象是没有意义的

package Sportsman;

public abstract class Person {
    private String name;
    private int age;

    //空参和带参
    public Person(){}
    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }

    //get和set方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

第一个父类的两个子类（都是抽象类）

package Sportsman;

public abstract class Sportsman extends Person{
    //空参和带参
    public Sportsman(){}
    public Sportsman(String name, int age){
        super(name , age);
    }

    //行为是抽象的运动
    public abstract void learnsport();
}

package Sportsman;

public abstract class Coach extends Person{
    //空参和带参
    public Coach() {}
    public Coach(String name, int age) {
        super(name, age);
    }

    //教练的行为是教运动
    public abstract void teach();
}

说英语的接口

package Sportsman;

public interface Speak_English {
    public default void Speak_English() {
        System.out.println("说英语");
    }
}

子类的子类

运动员的子类

package Sportsman;

public class Ping_Pong_Player extends Sportsman implements Speak_English{
    //空参和带参
    public Ping_Pong_Player(String name, int age) {
        super(name, age);
    }
    public Ping_Pong_Player() {}

    //重写抽象方法

    @Override
    public void learnsport() {
        System.out.println("学乒乓球");
    }
}

package Sportsman;

public class Basketball_Player extends Sportsman {
    //空参和带参
    public Basketball_Player() {}
    public Basketball_Player(String name, int age) {
        super(name, age);
    }

    //重写方法
    @Override
    public void learnsport() {
        System.out.println("学打篮球");
    }
}

教练的子类

package Sportsman;

public class Ping_Pong_Coach extends Coach implements Speak_English{
    //空参和带参
    public Ping_Pong_Coach() {}
    public Ping_Pong_Coach(String name, int age) {
        super(name, age);
    }

    //重写方法
    @Override
    public void teach() {
        System.out.println("教乒乓球");
    }
}

package Sportsman;

public class Basketball_Coach extends Coach {
    //空参和带参
    public Basketball_Coach() {}
    public Basketball_Coach(String name, int age) {
        super(name, age);
    }

    //重写方法
    @Override
    public void teach() {
        System.out.println("教打篮球");
    }
}

最后的测试类

package Sportsman;

public class Text {
    public static void main(String[] args) {
        //创建数据
        Ping_Pong_Player player1 = new Ping_Pong_Player("张三" , 24);
        Ping_Pong_Coach coach1 = new Ping_Pong_Coach("李四" , 35);
        Basketball_Player player2 = new Basketball_Player("牢大" , 25);
        Basketball_Coach coach2 = new Basketball_Coach("李刚" , 36);

        //测试方法
        player1.Speak_English();
        coach1.Speak_English();
        player1.learnsport();
        coach2.teach();
        player2.learnsport();
        coach2.teach();
    }
}