thinking in java逍遥游记 之 夜的第八章 - 多态

总结; 1. 什么是多态：个人觉得，多态就是父类有表现出子类的趋势。

          2 . 注意三种情况的时候，不存在多态：  一： field不存在多态哦  二：当父类方法申明为private的时候，也就是说不能被重写。 三：含有static方法不存在多态。

          3. is-a，is-like-a，组合的应用，组合其实在有的场合下更加的灵活。

          4. 关于构造方法的执行的顺序。    

 

关键代码：

package com.huxin.thinkinginjava.eighth;

/*
 * 要充分理解多态的含义
 */
class Animal {
 public void happy() {
  System.out.println("动物高兴了");
 }
}
class Dog extends Animal {
 public void happy() {
  System.out.println("小狗高兴了哦，汪汪");
 }
}
public class PolymorphicTest {
 public static void play(Animal a) {
  a.happy();
 }
 public static void main(String[] args) {
//  Animal a = new Dog();
//  play(a);  
  Animal a = new Dog();
  a.happy();
 }
}

 

public class AttentionTest {
 public static void main(String[] args) {
        Test1 test1 = new Test2();
        System.out.println(test1.i);          //1.说明field不会有多态！！！
        test1.staticBase();                   //2.说明static的方法不会有多态！！！
        //test1.base();                       //3.这样写会报错,因为private的方法不能被子类重写！！！！！
 }
}
class Test1{
    int i = 10;
 private void base(){
  
 }
 public static void staticBase(){
  System.out.println("我是父类的static的方法");
 }
}
class Test2 extends Test1{
 int i = 20;
 public void base(){
  System.out.println("子类");
 }
 public static void staticBase(){
  System.out.println("我是子类的static的方法");
 }
}

/*
 * 组合的一个应用
 */
public class Transmogrity {
 public static void main(String[] args) {
  Stage stage = new Stage();
  stage.act();                    //HappyActor is acting
  stage.change();
  stage.act();                   // SadActor is acting
 }

}
class Stage{
 private Actor actor = new HappyActor();
 public void act(){
  actor.act();
 }
 public Actor change(){
  actor = new SadActor();
  return actor;
 }
}
class Actor{
 public void act(){
  System.out.println("Actor is acting");
 }
}
class HappyActor extends Actor{
 public void act(){
  System.out.println("HappyActor is acting");
 }
}
class SadActor extends Actor{
 public void act(){
  System.out.println("SadActor is acting");
 }
}

 

/*
 * 关于构造方法的执行的顺序：
 * 1.先调用基类的构造方法（反复的调用）
 * 2.然后在给field进行初始化  (其实在初始化的时候，这个field已经分配了内存空间，并且给了一个初值，这个过程是在类加载的时候完成的)
 * 3.再调用自己的构造方法。
 */
public class SandWich extends Lunch{
 int i = 2;
 private Bread breadl = new Bread();
 SandWich(int i){
  System.out.println("SandWich"+i);
 }
 public static void main(String[] args) {
       new SandWich(6);
 }
}
class Bread{
 Bread(){
   System.out.println("bread的构造方法");
 }
}
class Meal{
 Meal(){
   System.out.println("Meal的构造方法");
 }
}
class Lunch extends Meal{
 Lunch(){
  System.out.println("Lunch的构造方法");
 }
}

 

public class Rtti {               //rtti运行时，内容识别
 public static void main(String[] args) {
       Useful[] use = {new Useful(),new MoreUseful()}; //这是一个Useful的数组，但是还是可以放MoreUseful，因为会自动向上转型
       use[0].a();
       //use[1].c();      //系统会报错,因为向上转型之后，就不能访问它的新方法。这也是多态的一个缺点。
       ((MoreUseful)use[1]).c();
 }
}
class Useful{
 public void a(){}
 public void b(){}
}
class MoreUseful extends Useful{
 public void a(){}
 public void b(){}
 public void c(){}
 public void d(){}
}