day11--Java面向对象--JavaObject02-2

今天主要学习了以下内容：
1. 继承的优缺点，及继承的限制和注意事项
2. 子类对象的初始化
3. 父类成员变量的隐藏
4. 父类方法的覆盖

package com.cskaoyan.basic;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/17.
 * @version 1.0
 *
 *   继承概述
        Java中的继承 和 我们现实生活中的“继承”的含义基本类似，但是含义更广。
        1. 简单来说都可以表示“不劳而获”（类似于现实世界中继承的含义）
        2. 类型之间 “ is a” 的关系
            a. 一种类型(类) 继承 另外一种类型(类)
                 子类           父类
            b. 从数据类型，可以把子类类型，当做父类类型
               从数据类型的角度，数据类型：一个数据集合和基于这个数据集合的一组操作
                当子类继承父类，子类拥有了父类中定义的成员（父类中的数据集和基于数据集的操作）

            c. 一个学生对象 是 一个人

        被继承的类称之为父类(基类或超类)，继承其他类的类称之为子类(派生类，导出类)
        子类可以通过继承机制，不写任何额外代码就可以拥有父类的“所有”成员。

      继承的语法
      class 子类名 extends 父类名 {}


     优缺点：
        1，继承的优点：
           a. 代码复用(类)
           b. 提高了代码的可维护性(这是一把双刃剑)
              通过继承，实现代码复用，一定程度深，消除了冗余代码
           c. 弱化Java中的类型约束(多态的前提) 为什么说是优点？在多态中，体现出来

        2. 缺点：
              缺点：父类的修改可能会出现在所有子类中
                   1. 假设我们开发了一款模拟鸭子的一款游戏，所有鸭子都可以呱呱叫，都可以在河流中移动
                   2. 我们想到了继承(呱呱叫的行为，和游动的行为都放在父类中)
                   3. 于是为了，增加竞争力，我们需要给鸭子添加新的功能，飞行（添加到父类中？？？？？？）
                   4. 发现有一种鸭子“模型鸭子(橡皮鸭子)”

 */
public class Demo1 {

  public static void main(String[] args) {
    // 类型之间 “ is a” 的关系 , 如何从代码上去理解？
    //b. 从数据类型，可以把子类类型，当做父类类型
    //c. 一个学生对象 是 一个人
    Human human = new Student();


    // 弱化Java中的类型约束(多态的前提)
    // 在没有学习继承之前
    //  同一个类 引用   = new 类()
    Human human1 = new Human();
    human1 = new Student();


  }

}

// 父类（基类或者超类）
class Human {

  //姓名属性
  String name;

  public void eat() {
    System.out.println(name + "eating");
  }

  public void sleep() {
    System.out.println(name + "sleeping");
  }

}
// Student（子类，派生类，导出类）
class Student extends Human {

  //学号属性
  int sno;

  public void study() {
    //System.out.println(name + "learning");
  }
}

package com.cskaoyan.basic;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/17.
 * @version 1.0
 *
 * Java类继承的特点：在Java中类只能实现单重继承。（一个类不能同时继承多个类）
 * 单重继承：简单来说Java的extends关键字后只能跟一个类名
      class SubDemo extends Demo{} //ok
      class SubDemo extends Demo1,Demo2{} //error

    一个类只能继承其他的一个单独的类的成员吗？ 不是

 *
 */
public class Demo2 {

  public static void main(String[] args) {
    Son son = new Son();
    //Son类继承的Father的父类的成员
    System.out.println(son.grandI);
    son.grand();

    //Son类继承的Father中的成员
    System.out.println(son.fatherI);
    son.father();
  }
}

class A {}
class B {}
class C extends A {}
class D extends B {}
// class E extends A, B{}

// 单重继承 "重"
class GrandFather {
  int grandI;
  public void grand() {}
}

class Father extends GrandFather{

  int fatherI;
  public void father() {};
}

class Son extends Father {
  int sonI;
  public void son() {}
}

package com.cskaoyan.basic;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/17.
 * @version 1.0
 * 继承的注意事项：
      1. 子类只能访问父类所有 非私有的成员 (成员方法和成员变量)
      2. 子类不能继承父类的构造方法

 */
public class Demo3 {

  public static void main(String[] args) {
    NoticeSon noticeSon = new NoticeSon();
    noticeSon.test();
  }

}

class NoticeFather {

  private int privateValue = 100;
  int intValue;

  private void privateMethod(){}
  void method(){
    System.out.println(this.privateValue);
  }
}

class NoticeSon extends NoticeFather {

  int sonI;

  public void test() {
    // 访问父类中的私有成员变量
    //System.out.println(privateValue);
    //privateMethod();

    //其实，子类有继承父类的私有成员变量
    this.method();
  }

}

 图1 ：子类对象的内存映像1

 

补充yesterday

　　protect修饰符

　　在跨包的子类中，可以访问父类中protected成员

package com.cskaoyan.yesterday.antherpackage;

import com.cskaoyan.yesterday.onepackage.MemberAccess;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/17.
 * @version 1.0
 * protected:
 *    在跨包的子类中，可以访问父类中protected成员
 *
 */
public class TestMemberAccess extends MemberAccess{

  public static void main(String[] args) {

    // 这里访问不到是因为，静态上下文的关系
    //System.out.println(protectedValue);
  }

  public void testAccess() {

    //在子类类体中直接访问
    System.out.println(this.protectedValue);

    //创建对象访问
    // 通过父类对象不可以
    MemberAccess memberAccess = new MemberAccess();
    //System.out.println(memberAccess.protectedValue);

    // 通过子类对象可以访问到
    TestMemberAccess testMemberAccess = new TestMemberAccess();
    System.out.println(testMemberAccess.protectedValue);


  }

}

跨包的另一代码

package com.cskaoyan.yesterday.onepackage;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/17.
 * @version 1.0
 */
public class MemberAccess {

  protected int protectedValue;

}

接下来，讲继承相关的几个问题？

Q1：子类对象的初始化问题，在子类对象汇总父类继承数据和子类自己定义的数据，谁先谁后初始化（赋初值）？

Q2：子类和父类中，定义同名成员变量问题

Q3：子类和父类中，能否定义一模一样的方法？

1.  针对Q1：子类对象的初始化问题（Initialize）

　　在子类对象汇总父类继承数据和子类自己定义的数据，谁先谁后初始化（赋初值）？

1-1  子类对象的隐式初始化implicit（先调用父类构造方法，jvm隐式完成）

package com.cskaoyan.intialize.implicit;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/17.
 * @version 1.0
 *
 *  对于一个子类对象而言，其内存中的数据，分成了两部分：
 *  1. 从父类中，继承下来成员变量的值
 *  2. 子类中，自己定义的成员变量的值
 *
 *  这两部分数据，在给他们赋初值的时候，谁先赋初值谁后赋初值（谁先初始化值，谁后初始化值）？
 *  java语言的结论是，一定是先初始化，子类对象中，继承的父类变量的值，后，初始化子类对象中，
 *                 子类自己定义的成员变量值  先父后子
 *
 *  如何保证呢？
 *   核心思路：
 *   1. 首先，构造方法本身的功能，就是初始化对象成员变量值的
 *   2. 所以，显然，对我们只需要保证，父类的构造方法，先于子类的构造方法运行
 *   3. 如何让父类构造方法，先于子类构造方法执行(在子类的构造方法的，第一条语句的位置，先去调用父类)
 *
 *   如何具体从语法上，保证先执行父类构造方法，在执行父类构造方法，有两种方式：
 *   1. 子类对象的 隐式 初始化（先调用父类构造方法，jvm隐式完成）
 *      a. 当父类提供了默认的构造函数(无参构造方法)，
 *      b. 且子类的构造方法中, 没有显式调用父类的其它构造方法
 *      c. 则在执行子类的构造方法之前，会(jvm)自动执行父类的构造方法(无参构造方法)
 *
 */
public class Demo1 {

  public static void main(String[] args) {
    //创建子类对象
    InitializeSon initializeSon = new InitializeSon(100);
  }

}

class InitializeFather {
  int fatherI;

  public InitializeFather() {
    System.out.println("InitializeFather 的构造方法执行了");
  }

  public InitializeFather(int fatherI) {
    this.fatherI = fatherI;
  }
}
class InitializeSon extends InitializeFather {
  int sonI;

  public InitializeSon(int sonI) {
    // 首先调用父类构造方法。
    System.out.println("InitializeSon 的构造方法执行了");
    this.sonI = sonI;

  }
}

1-2  子类对象的显式初始化explicit（先调用父类构造方法，我们coder通过代码来保证）

package com.cskaoyan.intialize.explicit;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/17.
 * @version 1.0
 *
 *
 * 对于一个子类对象而言，其内存中的数据，分成了两部分：
 *  1. 从父类中，继承下来成员变量的值
 *  2. 子类中，自己定义的成员变量的值
 *
 *  这两部分数据，在给他们赋初值的时候，谁先赋初值谁后赋初值（谁先初始化值，谁后初始化值）？
 *  java语言的结论是，一定是先初始化，子类对象中，继承的父类变量的值，后，初始化子类对象中，
 *                 子类自己定义的成员变量值  先父后子
 *
 *  如何保证呢？
 *   核心思路：
 *   1. 首先，构造方法本身的功能，就是初始化对象成员变量值的
 *   2. 所以，显然，对我们只需要保证，父类的构造方法，先于子类的构造方法运行
 *   3. 如何让父类构造方法，先于子类构造方法执行(在子类的构造方法的，第一条语句的位置，先去调用父类)
 *
 *   子类对象的显式初始化:
 *      子类对象的显式初始化，是我们coder通过代码来保证，先执行父类构造方法，在执行子类构造方法
 *      核心问题是，如何在Java语法层面，显式调用父类的构造方法？ 通过一个关键字super
 *
 *      super关键字：  super代表父类对象的引用。
 *
 *      this 关键字：  表示当前对象的引用     super关键字：  super代表父类对象的引用。
        this访问 当前对象的成员变量值          super 访问父类对象中，成员变量的值
        this访问 当前对象的成员方法           super 访问父类对象，成员方法
        this 调用 当前类中定义的构造方法       super  调用父类中定义的构造方法
        this(实参列表)                      super(实参列表)

        注意事项：
            1. 必须保证，子类每个构造方法，都要满足子类对象的初始化流程
            2. 在子类构造方法中，通过super调用，父类构造方法时，该super语句，
               必须出现在，子类构造方法第一条语句的位置
            3. this() 和 super()都可以，写在构造方法的方法体中, 它们都需要在第一条语句的位置
               它们不能共存
 *
 */
public class Demo1 {

  public static void main(String[] args) {
    ExplicitSon explicitSon = new ExplicitSon(1000, 100);
    System.out.println(explicitSon.fatherI);
    System.out.println(explicitSon.sonI);

    //
    ExplicitSon explicitSon1 = new ExplicitSon(1000, 100);
    System.out.println(explicitSon1.fatherI);
    System.out.println(explicitSon1.sonI);
  }

}

class ExplicitFather {
  int fatherI;

  double fatherJ;

  //public ExplicitFather() {
  //  this(100);
  //}

  public ExplicitFather(int fatherI) {
    System.out.println("ExplicitFather(int fatherI) 执行了");
    this.fatherI = fatherI;
  }

  public ExplicitFather(int fatherI, double fatherJ) {
    this.fatherI = fatherI;
    this.fatherJ = fatherJ;
  }
}
class ExplicitSon extends ExplicitFather{
  int sonI;
  public ExplicitSon(int fatherI, int sonI) {
    //调用一下父类的有参构造方法
    super(fatherI);
    //super();
    this.sonI = sonI;
  }

  public ExplicitSon(int fatherI, double fatherJ, int sonI) {
    // 显式调用父类的2参构造方法，把参数值通过super传递给父类构造方法
    //System.out.println();
    super(fatherI, fatherJ);
    this.sonI = sonI;
  }
}

  图2 ：子类对象的内存映像2

2.  针对Q2：子类和父类中定义同名成员变量问题（父类域的隐藏FieldHidden）

package com.cskaoyan.fieldhidden;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/17.
 * @version 1.0
 *
 *  父类域的隐藏：
 *    如果，在子类中，定义了和父类同名的成员变量
 *    a. 在子类类体中，通过同名成员变量的变量名，访问到的是，子类中定义的同名成员变量值
 *       看起来，就好像父类成员变量，在子类中，被隐藏起来了
 *
 *    b. 注意： 在父类方法的方法体中，通过变量名访问同名成员变量的值访问到的是，父类中定义的成员变量值
 *
 *
 *  1. 在子类中是否可以定义和 父类同名的 成员变量？ 可以
    2. 如果可以，那么在子类中访问这个同名变量，
        究竟访问到的是父类对象中的值，还是子类对象中的值？ 子类中同名成员变量的值

       如果在父类中访问呢？ 访问到的是父类中定义的同名成员变量的值

    3. 是否可以在子类对象中，同时访问到子类对象和父类对象中的同名成员变量的值？ 可以

 */
public class Demo1 {

  public static void main(String[] args) {
    FieldSon fieldSon = new FieldSon();
    // 调用子类的方法，在子类方法的方法体中，访问同名成员变量
    //fieldSon.sonAccess();

    // 在子类对象上，调用父类中定义的方法，在父类方法方法体中，访问同名成员变量
    fieldSon.fatherAccess();

    //针对第3文，在子类中，实现同时访问，父类，子类中的同名成员变量的值
    fieldSon.allAccess();
  }
}

class FieldFather {

  int intValue = 100;

  // 在父类方法的方法体中，通过变量名访问同名成员变量的值访问到的是，父类中定义的成员变量值
  public void fatherAccess() {
    System.out.println(intValue); //100
  }
}

class FieldSon extends FieldFather {
  int intValue = 200;

  public void sonAccess() {
    System.out.println(intValue);  //200
  }

  /*
      同时访问到，父类，子类中定义的同名成员变量的值
   */
  public void allAccess() {
    //访问子类同名成员变量值
    System.out.println(intValue);

    //利用，super，访问父类中，定义的同名成员变量值
    System.out.println(super.intValue);
  }

  public static void testReference() {
    //this 用不了
     // 静态上下文的问题
    //System.out.println(super.intValue);

  }

}

3.  针对Q3：子类和父类中，能否定义一模一样的方法？（方法重载MethodOverride）

package com.cskaoyan.methodoverride;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/17.
 * @version 1.0
 *
 * 方法覆盖的问题：
 *   当子类中定义了和父类"一模一样"的方法，如果在子类方法体中，调用"一模一样"的方法，
 *   访问到的是子类中定义的那个"一模一样的方法"
 *   注意：但是，如果我们在父类方法的方法体中，访问那个"一模一样的方法"，访问到的仍然是子类中的方法
 *   所以，对于子类父类定义"相同"方法的问题，方法覆盖
 *
 *  1. 子类中能否定义和父类一模一样的方法?
 *
    2. 如果可以，那么在子类类体中访问这个一模一样 的方法，
       究竟访问到的是父类中的方法，还是子类中的方法？  访问到的是，子类中定义的那个和父类方法声明一模一样的方法
       如果在父类中访问呢？

   3. 是否可以在子类方法的方法体中，同时访问到子类和父类中定义的一模一样的方法？



     当我们调用子类对象上调用方法，该方法在运行时，怎么确定，运行哪个方法的？ 就近原则
     1. 当方法执行的时候(如果子类方法调用了其他方法)，
        优先在子类中找目标方法，如果在子类中找到了目标方法，执行子类中定义的目标方法

     2. 如果说，在子类中，没有找到目标方法，接着到父类中找目标方法，如果找到，
        就执行父类中定义的方法

     方法覆盖，就是在子类定义和父类一模一样的方法，修改父类方法的

     着重强调： 对方法覆盖的效果，在子类对象上，
              调用父类中的方法，在父类中方法的方法体中，调用父类和子类定义的“相同方法”

 */
public class Demo1 {

  public static void main(String[] args) {
    //创建子类对象
    OverrideSon overrideSon = new OverrideSon();
    // 在子类方法体中，调用
    //overrideSon.sonAccess();

    // 在父类方法体中调用
    overrideSon.fatherAccess();

    //创建了一个父类对象：
    //OverrideFather overrideFather = new OverrideFather();
    //overrideFather.fatherAccess(); //father access

    //在子类类体中，同时访问子类和父类中定义的一抹一样的方法
    //overrideSon.allAccess();


    // 说明：
    // overrideSon.access();
  }
}

class OverrideFather {
  /*
      父类中定义的方法
   */
  public void access() {
    System.out.println("father access");
  }

  public void fatherAccess() {
    this.access(); //son access
  }

}

class OverrideSon extends OverrideFather {

  /*
      子类中定义的和父类一模一样的方法
   */
  public void access() {
    System.out.println("son access");
  }

  public void sonAccess() {
    // 在子类方法调用一下，子类，父类中定义的一模一样的方法
    access(); //son access
  }

  /*
      同时，在子类方法体中，实现同时访问，父类和子类中定义的一模一样的方法
   */
  public void allAccess() {
    // 调用子类中的access方法
    access();

    //利用super关键字，访问，父类中定义的一模一样的成员方法
    super.access();
  }

}

方法覆盖，在实际开发中，经常使用的, 使用的场景是什么呢？

package com.cskaoyan.methodoverride;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/17.
 * @version 1.0
 *
      方法覆盖，在实际开发中，经常使用的, 使用的场景是什么呢？
         当子类继承父类之后，想要修改父类的方法实现，就可以使用方法覆盖
 */
public class Demo2 {

  public static void main(String[] args) {
    // 应该具有飞行行为的普通鸭子
    FirstTypeDuck firstTypeDuck = new FirstTypeDuck();
    firstTypeDuck.fly();

    // 不应该具有飞行行为的模型鸭子
    ModelDuck modelDuck = new ModelDuck();
    modelDuck.fly();
  }

}


class BaseDuck {

   void quack() {
     System.out.println("呱呱叫");
   }

   void swim() {
     System.out.println("游泳");
   }

   // 添加飞行
  void fly() {
    System.out.println("fly");
  }

}

/*
    某种类型的鸭子
 */
class FirstTypeDuck extends BaseDuck{

}

class ModelDuck extends BaseDuck {

  // 在子类中利用方法覆盖，在子类中修改，父类方法的实现
  void fly() {
    System.out.println("no fly");
  }
}