有关java的继承与实现，方法的重载

本人是大学生，想询问一下这些都是什么意思，有没有相应的实例，以及都用到了继承和实现，方法的重载的场景实例之类的(能有代码功能说明的注释)

【1】接口：

//定义接口Jumpping
public interface Jumpping {
    //定义抽象方法跳高
    public abstract void jump();
}

【2】父类：

//定义抽象的动物类
public abstract class Animal {
    //定义成员变量
    private String name;
    private int age;
    //生成无参构造方法
    public Animal() {
    }
    //生成带参构造方法
    public Animal(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;
    }
    //添加一个吃饭的抽象方法
    public abstract void eat();
}

【3】该子类继承父类并实现接口：

/**这里是Cat继承了Animal父类并实现了Jumpping的接口*/
public class Cat extends Animal implements Jumpping{
    //重写eat和jump方法，这里就是方法的重载
    @Override
    public void eat(){
        System.out.println("猫吃鱼");
    }
    @Override
    public void jump(){
        System.out.println("猫可以跳高了");
    }
    //生成无参和带参拿的构造方法
    public Cat() {
    }
    public Cat(String name, int age) {
        super(name, age);
    }
}

【4】测试类：

//定义一个测试类
public class AnimalDome {
    public static void main(String[] args) {
        //创建对象，调用方法
        Cat c1=new Cat();
        //调用方法，这两个方法一个是继承过来、一个是实现接口的
        c1.jump();
        c1.eat();

        System.out.println("----------------------");
        //无参构造赋值
        c1.setName("加菲猫");
        c1.setAge(5);
        System.out.println("品种："+c1.getName()+","+"年龄："+c1.getAge());
        //带参构造赋值
        c1=new Cat("小花猫",7);
        System.out.println("品种："+c1.getName()+","+"年龄："+c1.getAge());
        System.out.println("******************************************");

    }
}
}

public class Test03 {
    /**
     * 定义父类，形状
     */
    static class Shape {
        /**
         * 每个形状都有名称
         */
        private String name;

        /**
         * 无参构造器
         */
        public Shape() {
        }

        /**
         * 定义有参构造器，这个有点类似重载
         *
         * @param name
         */
        public Shape(String name) {
            this.name = name;
        }

        /**
         * 显示形状的面积
         */
        public void printArea() {
            System.out.println("这是形状父类,没有特殊化,无法显示面积");
        }
    }

    /**
     * 定义子类,圆形，继承形状，圆形是形状的特殊子类
     */
    static class Circle extends Shape {
        /**
         * 圆形有他特殊的属性半径
         */
        private int r;

        public Circle(int r) {
            super("圆形");
            this.r = r;
        }

        /**
         * 这个是方法重写，重写发生在父类和子类之间,子类继承父类方法(并重写父类方法
         */
        @Override
        public void printArea() {
            System.out.println("圆形面积:" + Math.PI * r * r);
        }

        /**
         * 这个是方法是重载，重载是在同一个类中,两个方法的方法名相同,参数列表不同
         * 把半径扩大后的面积
         *
         * @param addR
         */
        public void printArea(int addR) {
            System.out.println("扩大后的圆形面积:" + Math.PI * (r + addR) * ((r + addR)));
        }
    }

    public static void main(String[] args) {
        // 实例化一个形状
        final Shape shape = new Shape();
        shape.printArea();
        
        // 实例化一个圆形，形式上是Shape类实际上是Circle类
        final Shape circle = new Circle(1);
        circle.printArea();
        //这行会报错应为他表面上是Shape类
        // circle.printArea(2);
        // 强制转换为实际类型可以调用
        ((Circle) circle).printArea(3);
        
        // 实例化一个圆形，形式上是Circle类实际上也是Circle类
        final Circle circle1 = new Circle(2);
        circle1.printArea();
        circle1.printArea(2);

    }
}

https://blog.csdn.net/wlqchengzhangji/article/details/119644402

你有30块都够买一本java的书了
现在年轻人这么浮躁吗
宁愿花30块看别人放个链接，不自己上网搜搜

继承、实现：https://blog.csdn.net/wz_110/article/details/120240477
事例：https://blog.csdn.net/weixin_44556353/article/details/123985905
重载：https://blog.csdn.net/qq_51367068/article/details/125617646

参考一下

我去，现在的大学生这么有钱吗，这种问题就能出30块

确实，花30块让别人放些链接，自己搜一下的事情；壕的话还不如加点钱去买个一对一讲解的

有关java的继承与实现，方法的重载
从小白的角度简单给你分享下我对它的理解：
要了解Java的继承，首先我们要理解【抽象】的概念。
抽象：从众多的事物中抽取出 “共同的、本质性”的特征，而舍弃其“非本质的”特征的过程。

这里举几个简单的例子，方便你理解，
1、如果两个类存在继承关系，则子类会自动继承父类的方法和变量，在子类中可以调用父类的方法和变量。
【小白式理解，其实就是儿子可以无条件使用父亲的所有东西】
【Java继承实例】，链接：https://blog.csdn.net/weixin_52790678/article/details/124078267
2、方法的重载是指一个类中允许存在一个以上的同名方法，只要它们的参数个数或者类型不同。
【小白式理解，其实就是儿子可以有多个称呼】
【Java方法重载实例】，链接：https://blog.csdn.net/LLLLLLZZZZZ/article/details/122220348

仅供参考：
https://blog.csdn.net/weixin_44563573/article/details/90957513
https://blog.csdn.net/weixin_44563573/article/details/90943466

（建议还是先学会JavaEE基础，网上很多课程，可以自行查阅，多实践，推荐可以在某马上搜索学习，都是免费的）
https://blog.csdn.net/weixin_44563573/article/details/103760477

https://blog.csdn.net/wlqchengzhangji/article/details/119644402

Java继承、重写与重载 https://www.cnblogs.com/lang12/p/15366408.html
java中的继承以及重写和重载 https://blog.csdn.net/qq_54199667/article/details/121476150

好好学学多态