day12--Java面向对象--JavaObject02-3

今天我们主要学习了如下内容：

1. 方法覆盖的条件及注意事项
2. final关键字
3. 多态的概念，及效果
4. 多态成员的访问特征
5. 多态的优点及多态的弊端
6. 解决多态的弊端(instanceof + 强制类型转化)

 

1. 继承（extend）中方法覆盖（method override）的条件及注意事项

Demo1

package com.cskaoyan.extend.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();
  }

}

 

Demo2

package com.cskaoyan.extend.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");
  }
}

 

Demo3

package com.cskaoyan.extend.methodoverride;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/18.
 * @version 1.0
 *
 *   对于方法覆盖的实现而言， 探究一下方法覆盖发生的条件：  "一模一样"
 *   主要看的是子类和父类的方法声明部分： 访问权限  返回值  方法签名
 *   1. 方法声明的访问权限的条件
 *        并非子类和父类方法的访问权限要相同，只要子类方法的访问权限，
 *        不小于父类方法的访问权限
 *
 *   2. 方法返回值
 *         1） 基本数据类型的方法返回值：子类必须和父类相同
 *         2） 引用数据类型
 *             a. 子类父类返回值类型相同
 *             b. 子类方法返回值类型 是 父类方法返回值类型的 子类类型 (因为，可以把子类类型看做是父类类型)
 *
 *   3. 方法签名
 *        子类方法的方法签名必须和父类一样
 */
public class Demo3 {

  public static void main(String[] args) {

    Son son = new Son();
    son.testOverride();
  }

}

class Father {

  // 测试方法权限的条件
  protected void testAccess() {
    System.out.println("father test");
  }

  // 测试方法返回值类型（基本数据类型）
  public int testReturnValue1() {
    System.out.println("father return value");
    return 0;
  }

  // 测试方法返回值类型（引用数据类型）
  public A testReturnValue2() {
    System.out.println("father return value 2");
    return null;
  }

  /*
    利用该方法测试，有没有实现方法覆盖的效果
  */
  public void testSignature() {}
  /*
        利用该方法测试，有没有实现方法覆盖的效果
   */
  public void testOverride() {
    // 测试父类的test方法，是否被子类覆盖
    //testAccess();

    // 测试引用类型的返回值类型
    testReturnValue2();
  }

}
class Son extends Father {

  //访问权限部分，子类要覆盖父类方法要满足的条件
  protected void testAccess() {
    System.out.println("son test");
  }

  //测试方法返回值类型（基本数据类型）
  public int testReturnValue1() {
    System.out.println("father return value");
    return 0;
  }

  //测试方法返回值类型（引用数据类型）
  public B testReturnValue2() {
    System.out.println("son return value 2");
    return null;
  }

  /*
      利用该方法测试，有没有实现方法覆盖的效果
  */
  //@Override  // 如果给一个方法加了override注解，没有报错，就说明该方法成功覆盖了父类的方法
  public void testSignature(int i) {}

}

class A {}

class B extends A {}

 

Demo4

package com.cskaoyan.extend.methodoverride;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/18.
 * @version 1.0
 *
 * 注意事项：
      1. 父类中私有方法不能被重写(override 覆盖或重写)
      2. 静态方法不能被重写(override 覆盖或重写)！

 */
public class Demo4 {

  public static void main(String[] args) {
    NoticeSon noticeSon = new NoticeSon();
    noticeSon.testOverride(); // father private
                              // father static
  }

}

class NoticeFather {

  //测试私有方法
  private void privateMethod() {
    System.out.println("father private");
  }
  // 测试静态方法
  public static void staticMethod() {
    System.out.println("father static");
  }

  /*
      测试方法覆盖的效果
   */
  public void testOverride() {
    //privateMethod();

    staticMethod();
  }
}

class NoticeSon extends NoticeFather {
  //测试私有方法
  //@Override
  private void privateMethod() {
    System.out.println("son private");
  }
  // 测试静态方法
  //@Override
  public static void staticMethod() {
    System.out.println("son static");
  }

}

 

2. final关键字

package com.cskaoyan.keyfinal;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/18.
 * @version 1.0
 *
 * final关键字：
          final是 最终 的意思，可以修饰类，变量，成员方法

      final修饰类：一旦类被final修饰，那么该类就不能被继承
      final修饰方法：一旦方法被final修饰，该方法就不能被覆盖
      final修饰变量：一旦一个变量被final 该变量就只能被赋值一次，一旦赋值之后，其值就不能被修改
         a.对于局部变量而言，如果被final修饰，那么该变量必须在使用之前赋值，而且只能赋值一次

         b.对于成员变量而言，如果被final修饰，保证，对于成员变量而言我们要保证，
           必须在 对象创建完毕 之前 ，给对象的该成员变量值赋值一次（我们自己赋值）

     常量：
       a. 字面值常量   1 2 3.0 true false "helloworld"
       b. 自定义常量   被final 修饰的变量就是自定义常量
          final int a = 1;

 */
public class Demo1 {

}

// final修饰类
final class FinalFather {}
//class FinalSon1 extends FinalFather{}

// final修饰方法
class FinalMehthodFahter {
  public final void finalMethod() {}
}
class FinalMethodSon extends FinalMehthodFahter{
  //public void finalMethod() {}
}

// 测试final修饰变量
class FinalVariable {

  final int finalField1 = 1;
  final int finalField2;
  final int finalField3;

  // 构造代码块
  {
    finalField2 = 3;
  }

  //构造方法中
  public FinalVariable(int a) {
    finalField3 = a;

    // final修饰的成员变量只能被赋值一次，赋值之后不能修改
    //finalField3 = 4;
  }

  /*
      如果仅在构造方法中，对final修饰的成员变量初始化，
      必须保证每个构造方法中都必须对final成员变量赋初值
   */
  public FinalVariable() {
    finalField3 = 103;
  }

  public void testLocalFinal() {
    final int a;
    a = 2;

    //a = 3;


  }

}

 

3. 多态的概念、效果 及  多态成员的访问特征

package com.cskaoyan.polymorphism;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/18.
 * @version 1.0
 *
 *  多态：某一个事物，在不同时刻(或条件下)表现出来的不同状态。
 *
 *  Java语言中的多态指什么呢？ “同一个对象”的行为(方法)，在不同的时刻或条件下，表现出不同的效果。
 *
 *  要实现多态的效果，有前提条件：
 *  1. 继承
 *  2. 要有方法覆盖
 *  3. 父类引用指向子类对象(对象有时也称之为实例)
 *
 *  多态成员的访问特征：父类引用指向子类对象的时候，如果我们父类引用，去访问子类对象中的成员
 *
 *  成员变量：
 *    编译看左边，运行看左边
 *
 *  成员方法：
 *    编译看左边，运行看右边
 *
 *  仅从理解的角度来解释：
 *  1. 编译看左边： 父类引用指向子类对象，此时编看左边是在说，
 *                通过引用变量可以访问到的子类成员的范围，是由引用类型来决定的
 *
 *     a. 迄今为止，我们是怎么去访问一个对象？我们都是通过一个中间人即引用变量，间接访问堆上对象
 *     b. 也就是说，只有通过引用变量，我才能访问到堆上的对象
 *
 *     举例：
 *     1. 我们如果把对象，当成我们的一台电视机，对于电视机而言，我们只能使用，遥控器去操作电视机
 *
 *     2. 这也就意味着，遥控器提供了什么样的功能，那我们只能使用，遥控器提供的功能，操作电视机
 *        此时即使电视机提供了很多功能可以使用，但是如果遥控器提供了，极其有限的功能
 *
 *     3. 这意味着，我们可以使用的电视机的功能，被遥控器给限制了
 *
 *     所以，回到java程序，访问对象的时候，引用变量，就是我们用来操作对象的"遥控器"，所以引用变量的类型
 *     决定了，可以访问到的成员的范围。
 *
 *  2. 对于成员方法的，运行(结果)看 右边(多态)
 *     就是说对于成员方法而言，通过引用变量，实际访问到的行为(方法), 是由引用实际指向的对象来决定的额
 *
 *  3. 对于成员变量，运行看左边
 *     一个对象 属性(成员变量) 和 行为，一个对象的属性(成员变量表示)，表示了一对象的外貌
 *     1. 在多态中，此时对于子类对象而言，把子类对象赋值给父类类型的引用，就相当于给子类对象
 *        披上了一个父类类型马甲， 因此，该子类对象开起来，就是一个父类对象(外貌特征，
 *        表现出的就应该是父类的外貌特征)
 *
 *
 *
 *
 *
 *
 */
public class Demo1 {

  public static void main(String[] args) {
    // 多态的基本知识
    //polymorphismBasic();


    // 父类引用指向子类对象
    Animal animal = new Dog();

    //通过父类引用访问子类对象的成员方法
    animal.shout();  //多态效果  汪汪汪
    System.out.println(animal.name); // xxxAnimal

    //利用另外一个子类来测试，多态的访问特征
    animal = new Cat();
    //成员便令
    System.out.println(animal.name);
    // 多态
    animal.shout();




    // 解释编译看左边
    System.out.println(animal.name);
    animal.shout();
    animal.eat();

    // 通过父类类型的引用，访问不到子类中自己定义的成员
    //animal.special();


  }

  private static void polymorphismBasic() {
    // 父类引用指向子类对象
    Animal animal = new Cat();

    //animal.shout(); //喵喵喵
    //条件发生改变
    animal = new Dog();
    //animal.shout(); //汪汪汪

    animal = new Animal();
    //调用一下
    testPolymorphism(animal);
    animal = new Dog();
    //调用一下
    testPolymorphism(animal);
    animal = new Cat();
    //调用一下
    testPolymorphism(animal);
  }

  public static void testPolymorphism(Animal animal) {
    // 这句代码，即使是编译器，也不知道，shout方法究竟执行的是哪个类中定义的shout方法
    animal.shout();
  }

}

class Animal {
  String name = "xxxAnimal";

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

  public void shout() {
    System.out.println("animal shout");
  }
}

class Cat extends Animal {

  String name = "xxxCat";

  @Override
  public void shout() {
    System.out.println("喵喵喵");
  }
}

class Dog extends Animal {
  String name = "xxxDog";
  @Override
  public void shout() {
    System.out.println("汪汪汪");
  }

  // 子类自己定义的方法
  public void special() {
    System.out.println("special");
  }
}

 

4. 多态的优点benefit

package com.cskaoyan.polymorphism.benefit;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/18.
 * @version 1.0
 *
 * 多态的好处
      1.提高了程序的维护性(由继承保证)
      2.提高了程序的扩展性(由多态保证)

    举例，模拟如下场景：
    现在有科学家，需要收集(不同)动物的声音并研究
    a. 假设一开始，科学家，只需要收集2种动物(猫和狗)的声音
    b. 接着，科学家提出需求，想要收集并研究更多种类的动物的声音(猪，鸭子，猴子...)
    c. 假设，没过多久，科学家又增加了要研究的动物的类型
 */
public class Demo1 {

  public static void main(String[] args) {

    Dog dog = new Dog();
    collectAndStudy(dog);

    Cat cat = new Cat();
    collectAndStudy(cat);

    //使用多态的解决方案
    Dog dog1 = new Dog();
    Cat cat1 = new Cat();
    Pig pig1 = new Pig();

    CollectAndStudyByPoly(dog1);
    CollectAndStudyByPoly(cat1);
    CollectAndStudyByPoly(pig1);
  }
  /*
      收集猫的声音并研究的功能
   */
  public static void collectAndStudy(Cat cat) {

    //1. 让猫发出声音
    cat.shout();

    //2. 收集声音并研究

  }
  /*
    收集猫的声音并研究的功能
 */
  public static void collectAndStudy(Dog dog) {

    //1. 让狗发出声音
    dog.shout();

    //2. 收集并研究声音
  }

  //针对猪
  public static void collectAndStudy(Pig pig) {
    //让猪。。。。

  }


  /*
      多态版本的解决方案
   */
  public static void CollectAndStudyByPoly(Animal animal) {
    // 在父类Animal引用上，调用其shout方法，让动物发出声音
    // 通过多态，保证，shout方法执行的时候，animal父类引用上调用shout()方法实际发出的叫声
    animal.shout();

    //2. 收集声音并研究
  }


}

class Animal {
  String name = "xxxAnimal";

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

  public void shout() {
    System.out.println("animal shout");
  }
}

class Cat extends Animal{
  String name = "xxxCat";

  public void shout() {
    System.out.println("喵喵喵");
  }
}

class Dog extends Animal {
  String name = "xxxDog";

  public void shout() {
    System.out.println("汪汪汪");
  }

}

class Pig extends Animal {
  String name = "xxxPig";

  public void shout() {
    System.out.println("猪叫");
  }
}

 

5.  多态的缺点flaw， 及解决多态的弊端(instanceof + 强制类型转化)

package com.cskaoyan.polymorphism.flaw;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/18.
 * @version 1.0
 *
 * 多态的弊端：不能访问子类特有功能(多态实现的第3个前提条件 父类 引用 指向 子类对象)
 *
 *  继续科学家收集并研究声音的场景：
 *  1. 科学家在收集鸭子这种动物声音，
 *     发现了这种动物的一个特点：发出声音之前，必须先在河里游一会，然后才会发出叫声
 *
 *
 *  如何解决多态的缺点呢？
 *     类型转化来解决 把父类类型的引用 ——> 子类类型的引用
 *
 *  为了解决多态的弊端，首先学习 类型转化 相关知识（父类 和 子类）
 *  父类类型引用   子类类型的引用
 *  1. 子类类型的引用 赋值 父类类型的引用 (安全的)          向上转型(天然允许)
 *  2. 父类类型的引用  赋值  子类类型的引用 (可能是不安全的) 向下转型
 *
 *  对于2中的引用类型转化，编译器默认不允许，但是我们java语言中，有强制类型转化
 *  目标类型  目标引用变量 = (目标类型)被转化的引用变量
 *
 *  int a = 10；
 *  byte b =(byte) a;
 *
 *  接下来，引入另外一个关键字 instanceof 关键字(运算符)
 *  该运算符，就可以用来判断，引用指向对象的实际类型
 *
 *  对象名(引用变量) instanceof 实际类型名
 *
 *  instanceof 运算符的结果类型是boolean类型
 *
 */
public class Demo1 {


  public static void main(String[] args) {

    Duck duck = new Duck();
    Dog dog = new Dog();
    Cat cat = new Cat();

    collectAndStudyByPoly(duck);
    collectAndStudyByPoly(dog);
    collectAndStudyByPoly(cat);

    // 引用的类型转化
    //referenceCast()
  }

  private static void referenceCast() {
    // 子类类型的引用，赋值给父类类型的引用
    Dog dog = new Dog();

    //子类引用赋值父类引用
    Animal animal = dog;

    //父类类型的引用 赋值给子类类型的引用
    // dog = animal;

    Animal an = new Animal();

    //Animal an = new Duck();

    // 因为如果父类引用，指向是一个父类对象，把父类类型的引用转化成子类类型的引用之后，
    // 我们就可以在，子类引用上访问，子类自己的成员
    // 编译器不允许，当时我们可以用强制类型转化
    Duck duck1 = (Duck) an;
    duck1.swim();
  }

  /*
      多态版本的解决方案
   */
  public static void collectAndStudyByPoly(Animal animal) {

    if (animal instanceof Duck) {
    //对于鸭子，得先让他游动一会
    Duck duck = (Duck) animal;
    duck.swim();
    }

    // 在父类Animal引用上，调用其shout方法，让动物发出声音
    // 通过多态，保证，shout方法执行的时候，animal父类引用上调用shout()方法实际发出的叫声
    animal.shout();

    //2. 收集声音并研究
  }
}


class Animal {
  String name = "xxxAnimal";

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

  public void shout() {
    System.out.println("animal shout");
  }
}
class Cat extends Animal{
  String name = "xxxCat";

  public void shout() {
    System.out.println("喵喵喵");
  }
}
class Dog extends Animal {
  String name = "xxxDog";

  public void shout() {
    System.out.println("汪汪汪");
  }

}

/*
    鸭子类
 */
class Duck extends Animal {

  String name = "xxxDuck";

  public void shout() {
    System.out.println("呱呱呱");
  }

  /*
      游泳行为
   */
  public void swim() {
    System.out.println("游泳");
  }
}