继承问题的简单认知

继承

• 继承：子类继承父类的成员，也就是所有子类的共性都存在在父类中。

• 优点：提高了代码的复用性，以及维护性。

• 缺点：类和类之间产生关系后，会增加耦合性，不符合软件设计原则：高内聚（一个事务，独立完成功能的能力），低耦合（事物和事物之间产生了依赖关系）。

• 注意事项：

1. java中只支持单继承，也就是一个类只能由一个父类，但支持多层继承。

2. 父类私有成员，子类无法继承。

3. 构造方法不参与继承。

父类构造的作用：

创建子类对象时，会先执行父类的构造方法。

理由：由于子类继承父类数据，甚至要使用父类数据，在此之前，父类数据会进行初始化和赋值等操作，操作完成后才能让子类继承其自身数据。

在每个类的每个构造方法中的第一行，有一条默认语句 super();这条语句在调用父类的空参构造，用来优先完成父类数据的初始化。

方法重写

• 方法重写：父类的方法功能不能满足子类的需求，子类就可以对其重写。

• 注意事项

  1. 子类不能重写父类的私有方法，（因为私有方法都不能继承，）

  2. 子类在重写父类方法时，方法的权限修饰符要比父类的高或者一样，不能比父类低。

  3. 构造方法不参与重写。

  4. 静态方法不参与重写。静态方法属于类

  5. 父类方法中被final修饰的方法，子类不能对其进行重写。

package Class04_03.HomeWork;
public class Test_00 {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }
}
class Fu {    //父类
    public Fu() {
        System.out.println("fu");
    }
    public void show(){
        System.out.println("父类方法");
}
}
class Zi  extends  Fu{        //extends 表示继承  Zi就是Fu的子类
    public Zi()	{
        System.out.println("zi");
    }
    public void show() {
        System.out.println("子类方法");
    }
}

关键字：final

• final ：最终的，可以修饰变量，成员方法，类。

• final 修饰变量，此变量就会变成常量，就不能在对其重新进行赋值。

• final 修饰成员方法，此方法就不能被重写，但是可以继承。

• final 修饰类，此类就不能被继承。

• final修饰的基本数据类型，指的是变量的值不能再更改。

• final修饰的引用数据类型，指的是其地址值不能再更改。

public static final int NUM=200; 公共的静态常量，使用类名直接调用。

抽象

• abstract 抽象的，可以修饰类和方法

  • 修饰方法 变为抽象方法 在void前添加 abstract

  • 修饰类 变为抽象类，在class之前添加abstract，抽象类中可以定义抽象方法，也可以定义非抽象方法。

• 抽象方法：就是只给出子类所共有的功能的声明。不用说明功能的具体体现，其子类自身的功能由子类按照其自身差异性去重写方法。

• 父类的抽象方法会强制的让子类进行方法重写；其非抽象方法没有强制性。

• 抽象类的特点

  1. 一旦类中拥有抽象方法，这个类中就必须为抽象类，但抽象类中可以没有抽象方法。

  2. 抽象类不能直接创建对象，但是可以通过多态的方式间接的对其进行实例化

  3. 抽象类的子类必须对所有父类的抽象方法进行重写，不如此做就会报错

  4. 抽象类的子类若不对所有的抽象方法进行重写，也可以选择将自身变为抽象类

  5. 抽象类中构造方法的作用，让子类通过多态的方法对其进行间接的实例化

  6. 抽象类中可以定义成员变量，也可以定义构造方法，同样的可以同时拥有抽象方法和非抽象方法。

abstract不能和那些关键词共存

1. 不能和private共存，相互矛盾，private修饰的成员不能被继承，而abstract需要被子类继承。

2. 不能和final共存，相互矛盾，被final修饰后，就不能被更改，而abstract是被强制进行重写的。

3. 不能和static共存，相互矛盾，static不参与继承，而abstract需要被子类继承，定义在一起就没有了意义。

多态

• 指一种事物在不同时刻所表现的不同状态。多态也是向上转型的一种

• 多态的前提：

1. 多态一定是出现在继承体系当中。

2. 要有方法重写，如果不重写，语法虽是正确的，但是这样就失去了多态的意义。

3. 父类引用指向子类对象

• 优缺点

  • 优：提高了代码的复用性（继承提供的保证），提高了代码的扩展性。

  • 缺：不能直接的对子类特有成员进行访问

多态形式访问成员变量，编译看父类，运行也是看父类；多态形式访问成员方法，编译看父类，运行看子类；多态形式访问静态方法，访问的还是父类的静态方法。

开闭原则：一个类对修改时关闭的，对扩展是开放的。

package Class04_04.pm.Test_01;

abstract class Employee {  //抽象员工类
    String name;//姓名
    int id;//工号
    double salary;//工资
    public abstract void work(); //抽象方法  子类必须对其机型重写
    public void eat(){
        System.out.println(this.name+"恰饭");
    }
    public void sleep(){
        System.out.println(this.name+"睡觉");
    }
}
class Manager extends Employee{   经理也是员工
    double bonus;//奖金
    @Override
    public void work() {
        System.out.println(this.name+"管理员工");
        System.out.println(this.name+"应酬");
    }
}
public class Test {
        public static void main(String[] args) {
            Employee em=new Manager();    //属于员工的经理的属性职能
            em.name="贺赫赫";
            em.salary=11000;
            System.out.println("工资"+em.salary);
            System.out.println("姓名："+em.name);
            em.eat();
            em.sleep();
            Manager m = (Manager) em;    //经理本身的属性职能
            m.bonus=105000.0;
            System.out.println("年终奖："+m.bonus);
            m.work();
        }
}