继承与多态

class Grandparent  {          public Grandparent()       {                System.out.println("GrandParent Created.");    }          public Grandparent(String string)      {                System.out.println("GrandParent Created.String:" + string);     }    }        class Parentt extends Grandparent  {          public Parentt()       {                super("Hello.Grandparent.");                System.out.println("Parent Created");           // super("Hello.Grandparent.");          }      public Parentt(String s)      {          System.out.println("Parent Created.String:"+s);      }    }        class Childd extends Parentt  {          public Childd()       {          super("Hello.Parent.");          System.out.println("Child Created");          }    }        public class TestInherits  {          public static void main(String args[])       {                Childd c = new Childd();      }    }

因为子类继承自父类，会沿用父类的东西(没被覆盖的函数以及可见的成员变量等)，而这些东西子类是没有的，需要先初始化父类才能被使用。
构造一个对象，先调用其构造方法，来初始化其成员函数和成员变量。
子类拥有父的成员变量和成员方法，如果不调用，则从父类继承而来的成员变量和成员方法得不到正确的初始化。
不能反过来调用也是这个原因，因为父类根本不知道子类有神魔变量而且这样一来子类也得不到初始化的父类变量，导致程序运行出错！

public final class Address  {      private final String detail;      private final String postCode;        //在构造方法里初始化两个实例属性      public Address()      {          this.detail = "";          this.postCode = "";        }      public Address(String detail , String postCode)      {          this.detail = detail;          this.postCode = postCode;      }      //仅为两个实例属性提供getter方法      public String getDetail()      {           return this.detail;      }        public String getPostCode()      {           return this.postCode;      }      //重写equals方法，判断两个对象是否相等。      public boolean equals(Object obj)      {          if (obj instanceof Address)          {              Address ad = (Address)obj;              if (this.getDetail().equals(ad.getDetail()) && this.getPostCode().equals(ad.getPostCode()))              {                  return true;              }          }          return false;      }      public int hashCode()      {          return detail.hashCode() + postCode.hashCode();      }      public static void main(String args[])       {               Address add=new Address("123","456");             System.out.println(add.getDetail());             System.out.println(add.getPostCode());             Address arr=new Address("123","456");             System.out.println(add.equals(arr));     }  }

public class ExplorationJDKSource {        /**       * @param args       */      public static void main(String[] args) {          System.out.println(new A());      }    }    class A{}

public class Fruit  {        public String toString()      {          return "Fruit toString.";      }        public static void main(String args[])      {          Fruit f=new Fruit();          System.out.println("f="+f);          System.out.println("f="+f.toString());      }  }

class ABC  {      public void print()      {          System.out.println("Parent print");      }  }  public class test extends ABC{        public void print()      {          super.print();          System.out.println("Children print");      }      public static void main(String[] args) {          // TODO Auto-generated method stub          test t1=new test();          t1.print();      }    }

public class TestInstanceof  {      public static void main(String[] args)      {          //声明hello时使用Object类，则hello的编译类型是Object，Object是所有类的父类          //但hello变量的实际类型是String          Object hello = "Hello";          //String是Object类的子类，所以返回true。          System.out.println("字符串是否是Object类的实例：" + (hello instanceof Object));          //返回true。          System.out.println("字符串是否是String类的实例：" + (hello instanceof String));          //返回false。          System.out.println("字符串是否是Math类的实例：" + (hello instanceof Math));          //String实现了Comparable接口，所以返回true。          System.out.println("字符串是否是Comparable接口的实例：" + (hello instanceof Comparable));          String a = "Hello";          //String类既不是Math类，也不是Math类的父类，所以下面代码编译无法通过          //System.out.println("字符串是否是Math类的实例：" + (a instanceof Math));      }  }

import java.net.InterfaceAddress;    class Mammal{}  class Dog extends Mammal {}  class Cat extends Mammal{}    public class TestCast  {      public static void main(String args[])      {          Mammal m;          Dog d=new Dog();          Cat c=new Cat();          m=d;          //d=m;          d=(Dog)m;          //d=c;          //c=(Cat)m;          System.out.println("good");      }  }

public class ParentChildTest {      public static void main(String[] args) {          Parent parent=new Parent();          parent.printValue();//100          Child child=new Child();          child.printValue();//200            //父类变量去引用子类对象          parent=child;            parent.printValue();//调用子类的方法200            //如果子类被当作父类使用,则通过子类访问的字段是父类的!          parent.myValue++;          System.out.println(parent.myValue);//101          parent.printValue();//200            ((Child)parent).myValue++;          parent.printValue();        }  }    class Parent{      public int myValue=100;      public void printValue() {          System.out.println("Parent.printValue(),myValue="+myValue);      }  }  class Child extends Parent{      public int myValue=200;      public void printValue() {          System.out.println("Child.printValue(),myValue="+myValue);      }  }

parent.myValue++;就是将子类当成父类来使用，通过子类访问的字段是父类的所以，当输出myvalue时是101，是父类的值+1；
最后将基类强制转换成子类后，将value++，此时访问的才是子类的字段，故而输出结果为201.

package zoo4;  import java.util.Vector;    public class Zoo {        public static void main(String args[]) {          Feeder f = new Feeder("小李");          Vector<Animal> ans = new Vector<Animal>();            //饲养员小李喂养一只狮子          ans.add(new Lion());          //饲养员小李喂养十只猴子          for (int i = 0; i < 10; i++) {              ans.add(new Monkey());          }          //饲养员小李喂养5只鸽子          for (int i = 0; i < 5; i++) {              ans.add(new Pigeon());          }          f.feedAnimals(ans);      }  }    class Feeder {        public String name;        Feeder(String name) {          this.name = name;      }        public void feedAnimals(Vector<Animal> ans) {          for (Animal an : ans) {              an.eat();          }      }  }    abstract class Animal {        public abstract void eat();  }    class Lion extends Animal {        public void eat() {          System.out.println("我不吃肉谁敢吃肉！");      }  }    class Monkey extends Animal {        public void eat() {          System.out.println("我什么都吃，尤其喜欢香蕉。");      }  }    class Pigeon extends Animal {        public void eat() {          System.out.println("我要减肥，所以每天只吃一点大米。");      }  }

package zoo5;  import java.util.Vector;    public class Zoo {        public static void main(String args[]) {          Feeder f = new Feeder("小李");          Vector<Animal> ans = new Vector<Animal>();            //饲养员小李喂养一只狮子          ans.add(new Lion());          //饲养员小李喂养十只猴子          for (int i = 0; i < 10; i++) {              ans.add(new Monkey());          }          //饲养员小李喂养5只鸽子          for (int i = 0; i < 5; i++) {              ans.add(new Pigeon());          }          f.feedAnimals(ans);      }  }    class Feeder {        public String name;        Feeder(String name) {          this.name = name;      }        public void feedAnimals(Vector<Animal> ans) {          for (Animal an : ans) {              an.eat();          }      }  }    interface Animal {        public void eat();  }    class Lion implements Animal {        public void eat() {          System.out.println("我不吃肉谁敢吃肉！");      }  }    class Monkey implements Animal {        public void eat() {          System.out.println("我什么都吃，尤其喜欢香蕉。");      }  }    class Pigeon implements Animal {        public void eat() {          System.out.println("我要减肥，所以每天只吃一点大米。");      }  }