Java基础之继承，重写

1.继承概述
               1.1当多个类中有大量的相同共性的时候就可以不断向上抽取，定义父类，让子类去继承父类
               1.2 父类：超类，基类
                    子类：派生类

2.继承的好处
               2.1继承提高了代码的复用性
               2.2让类与类之间产生关系，给多态提供多态

3.继承的特点
               3.1

                    子类不可以访问父类私有成员,但是继承了父类的私有成员

                    如果想访问父类的私有成员，需要间接性访问
               3.2

                    单继承：一个子类只能有一个直接父类

                         java支持多层（重）继承（继承体系）,但是一个类可以被多个类所继承

                         A extends B
                         B extends C

                         在java中是通过"多实现"的方式来实现的

                    多继承：一个子类可以有多个直接父类

                    java只支持单继承，不支持多继承，因为如果可以多继承， 就会出现调用的不确定性。

                    java对C++进行了改良

4.什么时候把类的关系定义为继承呢？
               由于继承体现了一种关系：（子类）is a（父类）的关系 狗是宠物的一种
               不要为了获取部分功能或复用代码而继承，而当类和类之间产生关系了才会使用继承

5.子类和父类成员（成员变量,成员函数,构造函数）
               5.1子父类成员变量之间的关系
                    5.1.1通过子类访一个成员变量的规则(重名情况下)
                         A:先在局部找，有的话直接使用
                         B:成员位置找
                         C:父类找
                         D:以上都找不到就报错

 5.1.1This和Super的用法

                    this代表本类对象的引用

                    super代表父类的内存空间的标志，继承谁，super就指向谁

                         成员变量

                         this.变量 --当前类的变量

                         super.变量 -- 父类的变量

                         成员函数

                         this.函数名() -- 本类的函数

                         super.函数名() -- 父类的函数

         

                         构造函数(放在第一句)

                         this(参数) -- 本类构造函数

                         super(参数) -- 父类构造函数

               5.2子父类成员函数之间的关系
                    5.2.1复写(重写,覆盖)
                              先找子类，子类有，用子类，没有在用父类的
                    5.2.2复写和重写(面试题)
                              重写：子父类中，出现方法出现相同的情况下。（返回值，方法名，参数）一模一样
                              重载：在同一个类中，函数名相同，参数列表不同就是重载。
                    5.2.3复写的时候注意事项
                              父类中的私有方法不可以被重写
                              子类方法的访问权限一定大于等于父类方法的访问权限
                              静态的方法只能被静态方法重写。这个其实不能算对象关系
                    5.2.4复写的应用
                              当子类需要父类的原始功能，而子类还有独特功能的
                              可以使用super.父类方法名()
                              class Phone
                              {
                                   public void call()

                                   {

                                        打电话;

                                   }
                              }
                              class NewPhone extends Phone
                              {
                                   public void call()
                                   {
                                        super.call();
                                        玩游戏;
                                   }
                              }

6.继承中构造函数关系

               子类默认都会访问父类的无参数构造函数，在子类中的构造函数中都有一条super()，在第一行
               因为子类继承了父类，就代表要用父类的东西，那你要不先加载父类的东西，子类用啥啊

               如果父类中没有无参数的构造函数，那咋整呢？
                    可以用过super()，给一个参数，调用父类有参数的构造函数进行初始化动作
                    还可以this()，给一个参数，让this调用别的子类构造函数，让那个子类构造函数进行super()调用父类的构造函数，this和super不能共存，因为都必须定义在第一行

私有成员赋值

class Fu

{

       public Fu(){}

       public Fu(String name)

      {

             this . name = name;

      }

       private String name ; //我是私有的，怎么可以给我赋值呢？

       public String getName()

      {

             return this . name ;

      }

       public void setName(String name)

      {

             this . name = name;

      }

      

}

class Zi extends Fu

{

       public Zi(){}

       public Zi(String name)

      {

             super (name);

      }

}

public class Demo

{

       public static void main(String[] args)

      {

             //1.可以通过get和set对外提供的方法进行访问

            Zi z = new Zi();

            z.setName( "李磊" );

            System. out .print(z.getName());

            

             //2.可以通过子类的构造函数，子类接受到的值在传递给父类来处理

            Zi z1 = new Zi( "李磊" );

            System. out .print(z1.getName());

      }

}

  

构造代码块，静态代码块，构造函数执行顺序（面试）

package com.abc;

class Demo

{

       public static void main(String[] args)

      {

             new Zi();

      }

}

class Fu

{

       static

      {

            System. out .println( "父类静态代码块" ); // 1

      }

      

      {

            System. out .println( "父类构造代码块" ); // 3

      }

      Fu()

      {

            System. out .println( "父类构造函数" ); // 4

      }

}

class Zi extends Fu

{

       static

      {

            System. out .println( "子类静态代码块" ); // 2

      }

      

      {

            System. out .println( "子类构造代码块" ); // 5

      }

      Zi()

      {

            System. out .println( "子类构造函数" ); // 6

      }

}

final

     是一个关键字，可以用于修饰类，成员变量，成员函数
     特点：
          它修饰的类不能被继承
          它修饰的成员变量是一个常量
          它修饰的成员方法是不能被子类重写的

子父类中构造函数的变化过程（图解）