Java-继承之构造方法，重写，final关键字

Super和this的区别

• 区别：
  super()即为继承父类同一引用，通过Super来访问父类成员，就比如说孩子继承了父亲的财富，也创造了自己的财富。
  this 则代表的一个类的引用，谁去调用它，它就代表了谁。

• 这其中有几个用法：
  a.super.成员变量名()；super.成员方法名()
  b.this.成员变量名();this.成员方法名()
  c.super()->调用父类无参构造
  d.this()->调用本类无参构造

//Person父类

public class Person {

    public String name="父类";

    public Person(String name) {
        super();
        this.name = name;
    }

    public Person() {
        super();
        // TODO Auto-generated constructor stub
        System.out.println("这是父类的无参构造");
    }

    public void show(){
        System.out.println("这是父类的show方法");
    }

    public void talk(){
        System.out.println("这是父类的talk方法");
    }


//Student子类

public class Student extends Person{
    public String name="子类";

    public Student(String name) {
        super();
        this.name = name;
        System.out.println("子类的有参构造");
    }

    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }

    public void show(){
        System.out.println(this.name);
        System.out.println(super.name);
        this.talk();
        super.talk();

    }

    public void talk(){
        System.out.println("这是子类的talk方法");
    }

}

//测试类

public static void main(String[] args) {
        // TODO Auto-generated method stub

        Student student = new Student();
        student.show();
        /*
         * 这是父类的无参构造 /null/null/这是子类的talk方法/这是父类的talk方法
         */
        System.out.println("------------------------------------");
        Student student2 = new Student("王小明");
        System.out.println(student2.name);//这是父类的无参构造/子类的有参构造/王小明

}

• 需要注意的是，有了继承关系之后，会先执行父类构造方法，然后再执行子类，因为子类需要继承父类的部分数据，需要先初始化父类，子类才能初始化。可以自己写一个简单的构造输出一下，更方便于理解

• 如果父类有了有参构造函数，系统将不再给出无参构造函数。然而在子类的构造方法中都默认会有super()去调用父类的无参构造。如果出现这种情况，可以给父类写一个无参构造，或者在super()中传一个参数，例如super(“abc”)。

  -如果不用super()去调用父类中原有的引用，可以完全重写，重写完会覆盖掉父类原有的方法。

方法重写

• 方法重写的定义：当子类中出现和父类一样的方法时，(需要保证方法名，返回值，参数列表一致)这叫做方法重写。

  方法重写是重写父类中的方法，当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，丰富了功能，这样，即沿袭了父类的功能，又定义了子类特有的内容。例如以前的手机只能发信息，但是现在可以通过微信去发信息一样。

• 需要注意的是，父类中的私有方法，子类不可以重写，因为私有方法继承不了，也不会去重写。

• 子类重写父类方法时，权限修饰符不能比原来方法的权限低，最好一致， 权限修饰符号的级别大小 public>protected>缺省>private。

//Phone 父类

public class Phone {

    public String name;
    public int type;

    public void call(){
        System.out.println("打电话");
    }

    public void sent(){
        System.out.println("发短信");
    }

    private void play(){
        System.out.println("玩游戏");
    }

    public static void show(){
        System.out.println("父类静态方法");
    }

}


//Apple 子类

public class Apple extends Phone{

    String name;

    @Override//重写标志
    public void call() {
        // TODO Auto-generated method stub
        super.call();
        System.out.println("微信语音电话");
    }

    @Override
    public void sent() {
        // TODO Auto-generated method stub
        super.sent();
        System.out.println("微信聊天");
    }

    //@Override 静态方法不重写
    public static void show(){
        System.out.println("子类静态方法");
    }

    //play()不能重写，因为是父类私有的

}

//测试类

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Apple apple = new Apple();
        apple.name="iphoneX";
        apple.type=001;
        apple.call();// 打电话 微信语音电话
        apple.sent();// 发短信 微信聊天
        apple.show();//子类静态方法
    }
}

final关键字

• final关键字可以修饰方法，变量，类
• final 修饰方法，此方法不能被重写，但是可以被继承
• final 修饰变量，此变量变为一个常量，不能重新被赋值
• final 修饰类，该类不能被继承
• final 修饰一个基本数据类型，修饰后值不能再被改变
• final 修饰引用数据类型，修饰后该引用不能再被重新赋值