继承！！！

学习目标：

• 继承
• 对象的初始化过程

---

继承

为什么需要继承？

实例化产生的对象有许多共性，将共性进行抽取而产生的类叫做父类，实现代码的复用。

继承的语法

eg：public Animal{

   public String name;

  public int age;

  public float weight;

public void eat(){

   System.out.println(name + "正在吃饭");

}

public void sleep(){

  System.out.println(name + "正在睡觉");

}

}

class Dog extends Animal{   //Dog类继承Animal类

   public void bark(){

        System.out.println(name + "汪汪叫");

}

在此代码中，Animal类是父类，Dog是子类，extends是表示继承关系的关键字，子类继承了父类的成员变量和成员方法，换句话说就是父类中的成员变量和成员方法子类中都有。子类继承父类后，必须添加自己特有的成员，体现与父类的不同。

注意！！！

private String name  可以被继承吗？？

答案是可以的！！访问修饰限定符只能决定访问权限，不能决定能不能被继承

父类成员的访问

子类中访问父类的成员变量

  1.子类和父类不存在同名成员变量

public class Base {

  int a;

  int b;

}

public class Derived extends Base{

  int c;

  public void method(){

  a = 10; // 访问从父类中继承下来的a，因为子类中没有

  b = 20; // 访问从父类中继承下来的b，因为子类中没有

  c = 30; // 访问子类自己的c

 }

}

2.子类和父类存在同名变量

public class Base {

  int a;

  int b;

  int c;

}

/////////////////////////////////////////////////////////////////

public class Derived extends Base{

  int a; // 与父类中成员a同名，且类型相同

  char b; // 与父类中成员b同名，但类型不同

public void method(){

  a = 100; // 访问父类继承的a，是子类自己新增的a

  b = 101; // 访问父类继承的b，是子类自己新增的b

  c = 102; // 子类没有c，访问的肯定是从父类继承下来的c

  // d = 103; // 编译失败，因为父类和子类都没有定义成员变量b

}

}

总结：如果访问的成员变量子类中有且子类和父类成员变量不同名，优先访问自己的成员变量，如果访问的成员变量子类中没有，就访问父类继承下来的，如果父类中也没有，就编译错误。

如果访问的成员变量子类和父类都有且同名，优先访问子类的成员变量

换句话说成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。

子类访问父类的成员方法

1.成员方法不同名

public class Base {

  public void methodA(){

   System.out.println("Base中的methodA()");

 }

}

public class Derived extends Base{

  public void methodB(){

     System.out.println("Derived中的methodB()方法");

}

public void methodC(){

  methodB(); // 访问子类自己的methodB()

  methodA(); // 访问父类继承的methodA()

  // methodD(); // 编译失败，在整个继承体系中没有发现方法methodD()

 }

}

总结：成员方法没有同名时，在子类方法中或者通过子类对象访问方法时，则优先访问自己的，自己没有时 再到父类中找，如果父类中也没有则报错。

2.成员方法同名

public class Base {  //父类

  public void methodA(){

   System.out.println("Base中的methodA()");

}

  public void methodB(){

   System.out.println("Base中的methodB()");

 }

}

public class Derived extends Base{  //子类

  public void methodA(int a) {

   System.out.println("Derived中的method(int)方法");

}

  public void methodB(){

   System.out.println("Derived中的methodB()方法");

}

  public void methodC(){

     methodA(); // 没有传参，访问父类中的methodA()

     methodA(20); // 传递int参数，访问子类中的methodA(int)

     methodB(); // 直接访问，则永远访问到的都是子类中的methodB()，基类的无法访问到

 }

}

那么当父类和子类的成员方法同名时，如何访问父类的同名成员方法呢？？？

为了解决这一问题，java中提供了super关键字！！！

super关键字

public class Base {    //父类

int a;

int b;

public void methodA(){

System.out.println("Base中的methodA()");

}

public void methodB(){

System.out.println("Base中的methodB()");

}

}

public class Derived extends Base{    //子类

int a; // 与父类中成员变量同名且类型相同

char b; // 与父类中成员变量同名但类型不同

// 与父类中methodA()构成重载

public void methodA(int a) {

System.out.println("Derived中的method()方法");

}

// 与基类中methodB()构成重写(即原型一致，重写后序详细介绍)

public void methodB(){

System.out.println("Derived中的methodB()方法");

}

public void methodC(){

// 对于同名的成员变量，直接访问时，访问的都是子类的

a = 100; // 等价于： this.a = 100;

b = 101; // 等价于： this.b = 101;

// 注意：this是当前对象的引用

// 访问父类的成员变量时，需要借助super关键字

// super是获取到子类对象中从基类继承下来的部分

super.a = 200;

super.b = 201;

// 父类和子类中构成重载的方法，直接可以通过参数列表区分清访问父类还是子类方法

methodA(); // 没有传参，访问父类中的methodA()

methodA(20); // 传递int参数，访问子类中的methodA(int)

// 如果在子类中要访问重写的基类方法，则需要借助super关键字

methodB(); // 直接访问，则永远访问到的都是子类中的methodA()，基类的无法访问到

super.methodB(); // 访问基类的methodB()

}

}

在子类方法中，如果想要明确访问父类中成员时，借助super关键字即可。

子类的构造方法

子类对象构造时，需要先调用父类构造方法，然后执行子类的。

 

public class Base {   //父类

   public Base(){

      System.out.println("Base()");

 }

}

public class Derived extends Base{     //子类

   public Derived(){

      System.out.println("Derived()");

 }

}

public class Test {

    public static void main(String[] args) {

         Derived d = new Derived(); 

    //在new一个Derived对象时，首先执行父类的构造方法，然后执行子类的构造方法

 }

}

结果打印：

Base()

Derived()

对象的初始化过程

初始化

没有继承关系时：

静态代码先执行，并且只执行一次，在类加载阶段执行，当有对象创建时，才会执行实例化代码块，实例化代码块执行完成后，最后执行构造方法

静态代码>实例化代码>构造方法

有继承关系时：

父类静态代码块优先于子类静态代码块执行，且最早执行，紧接着执行父类的实例化代码块和构造方法，在执行子类的实例化代码块和构造方法，第二次实例化子类对象时，父类和子类的静态代码块都不会执行

final关键字

final 关键字可以用来修饰变量  成员方法  以及类

1.修饰变量表示常量（即不能再被修改）

eg.  final  int  a = 10;

       a = 20;//编译错误，a不能再被修改

2.修饰类表示这个类不能再被继承

eg. final public class Animal{

    ........

}

public class Dog extends Animal{

   ......

}   //编译出错，Dog不能继承Animal

3.修饰方法表示该方法不能被重写