继承与重写

访问修饰符

1. 公开级别：public 对外公开
2. 受保护级别： protected 对子类和同一个包中的类公开
3. 默认级别：没有修饰符 向同一个包中的类公开
4. 私有级别：private 只有类本身可以访问 不对外公开

注意

• 访问修饰符可以修饰类中的成员变量，成员方法以及类
• 修饰类的时候 只能用public或者默认

继承

细节问题

• 子类继承了父类所有的属性和方法，不能继承私有成员和构造方法。但是私有属性和私有方法不能在子类中直接访问，要通过公共的方法去访问。
  比如一个类中的属性都是private的，那么该类中就会对应有public的set，get方法来访问，而子类可以通过这种public的方法这种访问私有属性
• 当创建子类对象时，不管使用哪个子类的构造器，默认情况下总会去调用父类的无参构造器，如果父类没有无参构造器，则必须在子类的构造器中用super去指定用父类的哪一个构造器完成对父类的初始化工作，否则编译不通过（为了方便记忆：创建儿子的时候当然要先创建父亲）

eg：有个Student父类，Undergraduate子类

public class Student {
    private String name;
    private int age;
    private int score;

    public Student(){
        System.out.println("我是父类========无参构造器");
    }

    public Student(String name, int age, int score) {
        this.name = name;
        this.age = age;
        this.score = score;
        System.out.println("我是父类========有参构造器");
    }


    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }
}

public class Undergraduate extends Student{

    public Undergraduate() {
        System.out.println("我是子类=======无参构造器");

    }

    public Undergraduate(String name,int age,int score){
        super(name,age,score);
        System.out.println("我是子类=======有参构造器");
    }



    public static void main(String[] args) {

        Undergraduate b=new Undergraduate();
        Undergraduate a = new Undergraduate("TOm",22,149);
        System.out.println(a.getAge());

    }
}

• super在使用时必须放在构造器语句里面的第一句
• java中的所有类都是Object的子类
• 父类构造器的调用不限于直接父类，将一直往上追朔到最高类Object类（顶级父类）
• 子类只能直接继承一个父类

一般引用型的值都是存放在方法区的常量池中，变量名是在堆中的。举个例子：

String name = "ymy";  

内存分析

• 当加载类信息到内存的方法区时，会先加载Object类的信息，再是Grandpa，Father，Son

例题分析

class A {
    public A(){
        System.out.println("======我是A类的无参构造======");
    }
}

class B extends A{
    public B(){
        System.out.println("======我是B类的无参构造======");
    }

    public B(String name){
        System.out.println(name + "======我是B类的有参构造======");
    }
}

class C extends B{
    public C(){
        this("ABC");
        System.out.println("======我是C类的无参构造======");
    }

    public C(String name){
        super("hahaha");
        System.out.println("======我是C类的有参构造=======");
    }

    public static void main(String[] args) {
        C c = new C();
    }
}

最后会输出什么？

分析这条程序语句： C c=new C();

1. 首先可以判断出执行的是C类的无参构造
2. 找到C的无参构造函数，this("ABC"); 表示调用该类的有参构造函数，并且把ABC传递给形参name； 注意：当有this语句时，就会默认忽略掉隐形的super();语句
3. 转移到C的有参构造函数，super("hahaha"); 表示从调用父类对应形参列表的构造函数
4. 转移到B类的有参构造函数
5. B类有参构造函数里的第一句是隐藏的super(); 表示调用其父类A类的无参构造函数

public B(String name){
        System.out.println(name + "======我是B类的有参构造======");
    }

super关键字

super代表父类的引用，可以访问父类的属性，方法，构造器

基本语法

• 访问父类属性： super.属性名 不能访问私有父类私有属性
• 访问父类方法：super.方法(形参列表(没有参数就不填)) 不能访问私有父类私有方法
• 访问父类构造器： 若要用super访问父类构造器 ，则只能在子类的构造器中这样用super
• 当子类和父类中有属性或者方法重名时，为了能访问父类的成员，必须使用super

this与super的对比

子类的构造方法中，不能同时出现 super() 或 this() 调用其他其他构造器。
当构造器第一行没有显式地出现super() 和 this() 则默认调用父类无参构造器
this 和 super 都不能用于静态方法
super不是引用，super 也不保存内存地址，super 也不指向任何对象。super只是代表当前对象内部的那一块父类型的特征。

override覆盖重写

覆盖只能针对实例方法，不包含静态方法、私有方法、父类的属性、构造方法
子类某个方法若要和父类某个方法构成覆盖，则要满足：

• 方法的名称，返回类型（要么相同，要么是父类该方法返回类型的子类），参数列表一样
• 父类返回类型如果是基本类型，则重写的话一定要保持一样
• 子类的方法不能缩小父类方法的访问权限，但可以更高
• 不能比父类的方法抛出更多的异常，可以更少 eg：父类某一个方法的返回类型是Object类 ，那么子类的该方法返回类型可以是String类

override重写 与 overload重载的区别