class Fu
{    Fu（）
  {
     System.out.println("FU....Run");
}
    }
class   Zi  extends Fu
{
    Zi()
{
   System.out.println("Zi....Run");
}
}
class TestDemon
{  public static void main(String[] args)
  {
        Zi  z=new Zi();
}
为什么打印的结果是    Fu....Run
                                    Zi....Run,

这个里面是怎么调用的啊？

}

public class TestIPEnCode extends TestCase{

　　/**

　　* 把IP地址转换成4字节的数组

　　*/

　　public void testEnCodeIp(){

　　String ip="192.168.1.0";

　　String [] ips=ip.split("[.]");

　　byte [] ipbs=new byte[4];

　　//IP地址压缩成4字节,如果要进一步处理的话,就可以转换成一个int了.

　　for(int i=0;i< 4 ;i++){

　　int m=Integer.parseInt(ips[i]);

　　byte b=(byte) m;

　　if(m>127){

　　b=(byte)(127-m);

　　}

　　System.out.println(b);

　　ipbs[i]=b;

　　}

　　//把4字节的数组解成IP

　　ip="";

　　for(int i=0;i< 4;i++){

　　String tmp=String.valueOf(ipbs[i]);

　　if(ipbs[i]< 0){

　　tmp=String.valueOf(127+Math.abs(ipbs[i]));

　　}

　　if(i< 3){

　　ip+=tmp+".";

　　}else{

　　ip+=tmp;

　　}

　　}

　　System.out.println(ip);

　　}

　　}

你新建了子类对象的时候 就方法子类构造函数 子类构造函数有一个隐式的super(),这样就指向了父类，然后再执行System.out.println("Zi....Run");

你新建了子类对象的时候 就方法子类构造函数 子类构造函数有一个隐式的super(),这样就指向了父类，然后再执行System.out.println("Zi....Run");

对于多态的表现：

成员函数：编译看左边，运行看右边。（其实就是子类覆盖了父类的函数）

成员变量：编译运行都看左边。

静态：编译运行都看左边。


成员函数：编译看左边，运行看右边。（其实就是子类覆盖了父类的函数）

成员变量：编译运行都看左边。

静态：编译运行都看左边。

• class  Test
• {
•         public static void main(String[] args)
•         {
•                 Cat c = new Cat();
•                 c.eat();//调用猫的吃方法-吃鱼
•                 c.catchMouse();//调用猫的吃方法----抓老鼠
•                 /**
•                  * 自动类型提升，猫对象提升了动物类型。但是特有功能无法s访问。
•                  * 专业讲：向上转型。将子类型隐藏。就不用使用子类的特有方法。
•                  */
•                 Animal a = new Cat();
•                 a.eat();//eat被覆盖 调用猫的吃方法----吃鱼
•                 //a.catchMouse();编译会失败，动物类没有猫爪老鼠的功能
•                 //如果还想用具体动物猫的特有功能。
•                 //你可以将该对象进行向下转型。
•                 //向下转型的目的是为了使用子类中的特有方法。
•                 Cat c2 = (Cat)a;
•                 c2.eat();//猫吃鱼
•                 c2.catchMouse();//猫爪老鼠。
•                 Dog d = new Dog();
•                 method(d);
•                 }
•         public static void method(Animal a)//Animal a = new Dog();
•         {
•                 if(a instanceof Cat)//instanceof：用于判断对象的具体类型。只能用于引用数据类型判断
•                                                         //通常在向下转型前用于健壮性的判断。
•                 {
•                         Cat c = (Cat)a;
•                         c.catchMouse();
•                 }
•                 else if(a instanceof Dog)
•                 {
•                         Dog d = (Dog)a;
•                         d.lookHome();
•                 }
•                 else
•                 {
•                 }
•         }
• }
  

为什么会有这条隐士的super（）呢？有什么用呢？

构造函数的第一行都有一行默认的super() 除非你给他指定了this(),this()和super()只能存在一个

class Fu
{    Fu（）第四步执行父类

  {
     System.out.println("FU....Run");
    }
class   Zi  extends Fu
{
    Zi()  第二部开始执行构造函数
{
    第三步执行隐式的super(),并指向父类
   System.out.println("Zi....Run");  第五步
}
}
class TestDemon
{  public static void main(String[] args)
  {
        Zi  z=new Zi();  第一步 创建对象
}

在继承中，子类构造函数中有隐式的super();
因此，在子类构造函数运行时的顺序应该是：

1.首先执行父类的构造函数
2.再是对象所在类的构造函数
3.最后执行子类的构造函数
4.析构函数的执行和构造函数相反


还有在子类的构造函数中，如果父类中只有无参的构造函数，那么子类不用调用父类的构造函数，会隐式调用。
                                   如果父类中有带参数的构造函数，那么子类必须要调用父类的构造函数，想父类传递参数。

楼主的父类的构造函数明显是无参的，所以楼主没有调用时正确的，但是既然他继承了父类，那么父类的方法他一定拥有，所以会隐式调用，希望楼主能明白

还有就是如果父类中自定义了带参数的构造方法，而没有不带参的构造方法，那么子类在构造函数时是也必须来调用这个带参的构造方法吗？再假如父类中都是带参的构造函数，而且不止一个，毕老师说过所以的子类的构造函数的第一行都有隐式的supper（）方法，那么可不可在子类的第一行来自定义所要调用父类中的指定构造函数呢？那么此时的子类中是不是应该没有哪条隐式语句supper（）呢？