Java——方法重写

一、续方法重写（举例）
//为什么要有方法重写？ 子类有时候对父类的方法实现并不满意，他想要在父类的方法基础之上扩展一些自己的功能（逻辑属性），那么这个时候他可以使用方法重写。
注意：1.父类的私有方法，子类不能重写，父类私有的方法，子类不能继承，何谈重写
2.子类重写父类方法时，这个方法的权限修饰符，要比父类的高，或者跟父类一样,你最好跟父类一样就行
3. 静态方法谈不上重写,静态方法不参与重写
例如：

public class MyTest {
    public static void main(String[] args) {
        
        Zi zi = new Zi();
        // zi.test2();
        Zi.test2();
    }
}
class Fu {
    public void show() {
        System.out.println("我是父类的show方法");
    }
    private void show2() {
        System.out.println("我是父类私有的show方法");
    }
    public void test() {
        System.out.println("我是父类公共的test方法");
    }
    public static void test2() {
        System.out.println("我是父类静态方法");
    }
}
class Zi extends Fu {
    public void show() {
        System.out.println("我是子类的show方法");
    }
    public void test() {
        System.out.println("我是子类公共的test方法");
    }
    public static void test2() {
        System.out.println("我是子类静态方法");
    }
}

二、多态
（一）概述及其前提
概述：某一个事物，在不同时刻表现出来的不同状态。简单说狗是狗的类型，狗也是动物的一种。
前提：1.要有继承关系
2.要有方法重写
3.要有父类引用指向子类对象
（二）多态中的成员访问特点
1.成员变量：编译看左边，运行看左边。
2.构造方法：创建子类对象的时候，会访问父类的构造方法，对父类的数据进行初始化。
3.成员方法：编译看左边，运行看右边。
4.静态方法：编译看左边，运行看那左边。（不算是重写）
多态的好处：a:提高了代码的维护性(继承保证)
b:提高了代码的扩展性(由多态保证)
（三）多态的内存图解

举例：
动物园里有很多种动物：
比如说，狗，猫等。
狗有姓名和年龄，猫也有姓名和年龄。
狗有跑步的方法，猫也有跑步的方法。而且都仅仅是跑步。
狗有吃饭的方法，猫也有吃饭的方法。只不过，狗吃骨头，猫吃鱼。

public class Fu {
    private String name;
    private int age;
    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 void run()
    {
        System.out.println("跑步");
    }
    public void eat(){
        System.out.println("吃饭");
    }
}
子类：public class Zi extends Fu {
    private String name;
    private int age;
    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 void run()
    {
        System.out.println("狗有跑步的方法，猫也有跑步的方法");
    }
    public void eat(){
        System.out.println("狗有吃饭的方法，猫也有吃饭的方法");
    }
}
Cat：public class Cat extends Zi {
    private String name;
    private int age;

    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 void run(){
        System.out.println("猫也有跑步的方法");
    }
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
Dog: public class Dog extends  Zi {
    public String getName() {
        return super.getName();
    }
    public void setName(String name) {
        super.setName(name);
    }
    public int getAge() {
        return super.getAge();
    }
    public void setAge(int age) {
        super.setAge(age);
    }
    public void run(){
        System.out.println("狗有跑步的方法");
    }
    public void eat(){
        System.out.println("狗吃骨头");
    }
}
测试类：public class MyTest {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.setName("淘气");
        cat.setAge(1);
        System.out.println(cat.getName());
        System.out.println(cat.getAge());
        cat.eat();
        cat.run();
        System.out.println("----------------------");
        Dog dog = new Dog();
        dog.setName("旺财");
        dog.setAge(2);
        System.out.println(dog.getName());
        System.out.println(dog.getAge());
        dog.eat();
        dog.run();
    }
}

三、抽象类
（一）概述及其特点
定义：在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。
特点：1.抽象类和抽象方法必须用abstract关键字修饰
抽象类格式: abstract class 类名 {}
抽象方法格式: public abstract void eat();
2.抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
3.抽象类中可以有构造方法,抽象类不能进行实例化,那么要构造方法有什么作用呢?答：用于子类访问父类数据时的初始化
4.抽象类不能直接实例化那么，抽象类如何实例化呢?
按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
5.抽象类的子类
要么是抽象类
要么重写抽象类中的所有抽象方法
成员特点：
A:抽象类的成员特点
a:成员变量：既可以是变量，也可以是常量。
b:构造方法：有。
用于子类访问父类数据的初始化。
c:成员方法：既可以是抽象的，也可以是非抽象的。
B:案例演示
抽象类的成员特点
C:抽象类的成员方法特性：
a:抽象方法 强制要求子类做的事情。
b:非抽象方法 子类继承的事情，提高代码复用性。
注意事项：
1.一旦一个类中有了抽象方法，此类必须定义为抽象类
2.抽象类中，既可以有抽象方法，也可以有非抽象方法
3.非抽象方法，可以让子类继承下去直接用，抽象方法，强制子类必须重写
4.子类必须重写抽象类中所有的抽象方法
5.抽象类中既可以定义常量，也可以定义变量
6.抽象类中，可以有构造方法，用来让子类初始化父类的数据
举例：