自学JAVA-继承、父类构造器、super、方法重写

继承

1.为什么需要继承
    提高代码复用性
    继承是多态的前提
    
2.继承的注意事项
    a)继承的语法
        class 子类 extends 父类{}
        
    b)父类/超类/基类
        子类/派生类
        
    c)当多个类存在相同的属性和方法时，可以从这些类中抽象出父类，
    在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，
    只需要通过extends来声明继承父类即可
    
    d)子类自动拥有父类的属性和方法(受访问修饰符影响)
    
    e)受访问修饰符影响，子类不能访问父类的属性和方法，可以通过父类的公开去访问，
    类似封装
    
    f)java中是单继承机制，子类最多只能继承一个父类(指直接继承)，但是可以实现多个接口
    
    g)所有类都是Object的子类
    
    h)多层继承、查看关系

public class Student extends Person {
    private double shengHuoFei = 0;

    public double getShengHuoFei() {
        return shengHuoFei;
    }

    public void setShengHuoFei(double shengHuoFei) {
        this.shengHuoFei = shengHuoFei;
    }
}

public class Teacher extends Person {
    private double gongzi = 0;

    public double getGongzi() {
        return gongzi;
    }

    public void setGongzi(double gongzi) {
        this.gongzi = gongzi;
    }
}

public class Person {
    private String name = null;
    private int age = 0;
    private boolean sex = false;

    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 boolean isSex() {
        return sex;
    }

    public void setSex(boolean sex) {
        this.sex = sex;
    }
}

public class Hello {
    public static void main(String[] args) {

        Student student = new Student();
        student.setName("czw");
        student.setAge(18);
        student.setShengHuoFei(100);
        System.out.println(student.getName());
        System.out.println(student.getAge());
        System.out.println(student.getShengHuoFei());


        Teacher teacher = new Teacher();
        teacher.setName("lbw");
        teacher.setAge(19);
        teacher.setGongzi(100);
        System.out.println(teacher.getName());
        System.out.println(teacher.getAge());
        System.out.println(teacher.isSex());
        System.out.println(teacher.getGongzi());

    }
}

父类构造器

1.当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器
    super()
    
2.如果父类没有提供无参构造器，则须在子类构造器中用super()去指定使用父类的哪个构造器
    super(参数列表)
    super()和this()都只能放在构造器第一行，因此这两个方法不能共存在一个构造器
    
3.父类构造器的调用不限于直接父类，一直往上追溯到Object类(顶级父类)

super

1.为什么需要super
    a)子类和父类具有同名属性和方法时，默认使用子类的同名属性和方法，为了访问父类的属性和方法，必须通过super来调用
    
    b)super代表父类对象的引用，用于访问父类对象的属性、方法、构造器
    
2.访问父类的属性(受访问修饰符影响)
    super.属性名;
    
3.访问父类的方法(受访问修饰符影响)
    super.方法名(参数列表);
    
4.访问父类的构造器
    super(参数列表);

继承练习

第一题
    public class A {
    A() {
        System.out.println("A类无参");
    }

    A(String name) {
        System.out.println("A类有参");
    }
}
    
    public class B extends A {
    B() {
        this("");
        System.out.println("B类无参");
    }

    B(String name) {
        System.out.println("B类有参");
    }
}

    问题：B b = new B(); // 会输出什么
    
    答案：A类无参
        B类有参
        B类无参

第二题
    public class A {
    A() {
        System.out.println("A类");
    }
}

    public class B extends A {
    B() {
        System.out.println("B类无参");
    }

    B(String name) {
        System.out.println(name + "B类有参");
    }
}

    public class C extends B {
    C() {
        this("Hello");
        System.out.println("C类无参");
    }

    C(String name) {
        super("Java");
        System.out.println("C类有参");
    }
}

    问题：C c = new C();
    
    答案：A类
        JavaB类有参
        C类有参
        C类无参

第三题
    public class Hello {
    public static void main(String[] args) {


    }
}

class A {
    String name = "AA";
    private int age = 100;

    public void test() {

    }
}

class B extends A {
    String java = "java";
    private int nums;

    public void demo() {
        // super 可以访问哪些成员(属性和方法)
        System.out.println(super.name);
        super.test();


        // this 可以访问哪些成员
        System.out.println(this.java);
        System.out.println(this.nums);
        System.out.println(this.name);
        this.test();
        this.demo(); // 实际上就是调用本身，递归，但是要有边界条件来退出

    }
}

class C extends B {
    String name = "BB";

    public void test() {

    }

    private void show() {
        // super 可以访问哪些成员(属性和方法)
        System.out.println(super.java);
        System.out.println(super.name); // AA
        super.test();
        super.demo();

        // this 可以访问哪些成员
        System.out.println(this.java);
        System.out.println(this.name); // BB
        this.test();
        this.demo();



    }
}

super是访问父类的但是也包括爷爷类
this是访问本身的但是这个也包含了继承过来的东西
如果有重名是会访问子类的，比如子类C继承父类B，B有一个test方法恰好C也有一个test()方法
如果this.test() 则会调用C类的test()

方法重写

1.为什么需要重写

2.子类可以重写父类属性和方法

3.方法重写特点
    a)方法重写也叫方法覆盖
    
    b)子类方法的名称、参数，与父类完全相同
    
    c)子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类
        比如父类返回类型Object，子类返回类型是String
        
    d)子类方法不能缩小父类方法的访问权限
    
4.重载与重写的区别
    重载：同一个类中，方法名相同，但参数类型、个数或顺序不同，
        与返回值无关，与修饰符无关
            
    重写：父类和子类中，方法名相同，参数相同，子类返回类型与父类一样或者是其子类
        ，子类不能缩小父类的访问范围

欢迎各位读者加入我们的交流群，进入公众号(Python三剑客)可获取加群方式