在Java中通过关键字extends继承一个已有的类，被继承的类称为父类(超类，基类)，继承产生的新的类称为子类(派生类)。Java不允许多继承。
1.继承

class Animal{
    void eat(){
        System.out.println("Animal eat");
    }
    void sleep(){
        System.out.println("Animal sleep");
    }
    void breathe(){
        System.out.println("Animal breathe");
    }
}

class Fish extends Animal{

}

public class TestNew{

    public static void main(String[] args) {
        //继承了父类的所有方法
        Animal an = new Animal();
        Fish fn = new Fish();

        an.breathe();
        fn.breathe();
        
     }
 }

运行之后的结果为：
Animal breathe
Animal breathe

2.覆盖

class Animal{
    void eat(){
        System.out.println("Animal eat");
    }
    void sleep(){
        System.out.println("Animal sleep");
    }
    void breathe(){
        System.out.println("Animal breathe");
    }
}

class Fish extends Animal{
    void breathe(){
        System.out.println("Fish breathe");
    }

}

public class TestNew{

    public static void main(String[] args) {
        //继承了父类的所有方法
        Animal an = new Animal();
        Fish fn = new Fish();

        an.breathe();
        fn.breathe();
        
    }
}

运行之后的结果为：
Animal breathe
Fish breathe

如果在子类中定义一个跟父类相同的函数，也即在子类中定义一个与父类同名，返回类型，参数类型均相同的一个方法，称为方法的覆盖。方法的覆盖发生在子类和父类之间。

3.一个例子（继承Thread类）

public class Example extends Thread{
     @Override
     public void run(){
        try{
             Thread.sleep(1000);
             }catch (InterruptedException e){
             e.printStackTrace();
             }
             System.out.print("run");
     }
     public static void main(String[] args){
             Example example=new Example();
             example.run();
             System.out.print("main");
     }
}

这个类虽然继承了Thread类，但是并没有真正创建一个线程
创建一个线程需要覆盖Thread类的run方法，然后调用Thread类的start()方法启动，这里直接调用run()方法并没有创建线程，跟普通方法一样调用一样，是顺序执行的。

4.重载
如果有两个方法的名称相同，但参数不一致，这样一个方法是另一个方法的重载。
方法名相同方法的参数类型，个数顺序至少有一项不同