Java进阶1：面向对象、重载和重写、多态-CSDN博客

继承

Java不支持多继承，但是支持多重继承，即可以迭代
使用extends和implements这两个关键子来实现继承
子类拥有父类中的非private属性和方法，对父类进行拓展
提高了代码的耦合性但是也降低了代码的独立性

extends关键字

extends只能继承一个类,就是单一继承，一个子类只能有一个父类。

//Animal.class
public class Animal {
    public String name;
    public Integer age;
    public void show(){
        System.out.println("我是："+this.name+", "+"我的年龄: "+this.age);
    }
}

//Cat.class
public class Cat extends Animal{
}

implements关键字

使用implements关键字可以开启多继承的特性，使用范围是类继承接口的情况，可以同时继承多个接口

public interface A {
    public void eat();
    public void sleep();
}
public interface B{
    public void show();
}
public class C implements A, B{
}

super和this关键字

super关键字用于对父类成员的访问
this关键字指向自己的引用

//Animal.java
public class Animal {
    public String name;
    public Integer age;
    public void show(){
        System.out.println("我是："+this.name+", "+"我的年龄: "+this.age);
    }
    public void eat(){
        System.out.println("Eat for Animal!");
    }
}
//Cat.java
public class Cat extends Animal{
    public void eat(){
        System.out.println("Eat for Cat!");
    }
    public void eattest(){
        this.eat();
        super.eat();
    }
}
//main函数
public class HelloWorld {
    //main函数，程序入口
   public static void main(String args[]){
       Cat cat = new Cat();
       cat.eattest();
   }
}

final关键字

把类变为最终类，这个类不能被继承、不能被修饰、不能被子类重写。

//定义最终类
final class ClassName { }

final定义的类其中的属性和方法不是final的

构造器

Java中的子类不继承父类的构造器！
Java只是调用（隐式或者显式）构造器
如果父类的构造器带了参数，在子类里面必须用super关键字显式调用

//Animal类（父类）
public class Animal {
    public String name;
    public Integer age;
    public void show(){
        System.out.println("我是："+this.name+", "+"我的年龄: "+this.age);
    }
    public Animal(String name, Integer age){
        this.name = name;
        this.age = age;
    }
}

//Cat类（子类）
public class Cat extends Animal{
    public Cat(String name, Integer age) {
        super(name, age);
    }
}

//主入口
public class HelloWorld {
    //main函数，程序入口
   public static void main(String args[]){
       Cat cat = new Cat("小米",12);
       cat.show();

       Animal animal = new Animal("某动物",11);
       animal.show();
   }
}

重写（Override）

重写的概念

重写是子类对于父类的允许访问的方法的实现过程进行重新编写，返回值和形参的类型都不允许被改变，即“优化，外壳不变，核心重写”。
重写的好处是，子类可以定义特定的属于自己的行为，能够根据需要实现父类的方法。
重写方法不能抛出新的检查异常或者比重写方法申明更加宽泛的异常，可以抛出比父类更加具体的、子类的异常：例如Exception—>IOException

重写的实现方法

//Animal.java
public class Animal {
    public void eat(){
        System.out.println("某只动物在吃饭");
    }
}
//Cat.java
public class Cat extends Animal{
    public void eat(){
        System.out.println("某只小猫在吃饭");
    }
}
//main
public class HelloWorld {
    //main函数，程序入口
   public static void main(String args[]){
        Animal animal = new Animal();
        animal.eat();

        Cat cat = new Cat();
        cat.eat();
   }
}

重写的规则

参数列表和被重写的方法的参数列表必须完全相同
返回类型和被重写的方法的返回类型可不相同，但是必须是父类的返回值类型的派生类。（Java<=5.0版本必须要一样）
访问权限不能比父类的权限更低（不能从public–>protected）
只能被它的子类重写
final的方法不能被重写，static方法不能被重写但是可以重新声明
子类和父类在同一个包中，子类可以重写父类的所有方法，除了声明为private和final的方法
子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比* * 被重写方法声明的更广泛的强制性异常，反之则可以。
构造方法不能被重写。
如果不能继承一个类，则不能重写该类的方法。

Super关键字的使用

通过super关键字，可以调用父类中重写之前的方法

重载（Overload）

重载是在一个类里面，方法名字相同，参数和返回值可以不同的函数
最常用的重载是构造器的重载
被重载的方法必须该表参数列表

public class Animal {
    public void eat(){
        System.out.println("某只动物在吃饭");
    }

    public void eat(String name){
        System.out.println("带参数的eat!");
    }
}