Java-06-动手动脑

1.为什么子类的构造方法在运行之前，必须调用父类的构造方法？能不能反过来？为什么不能反过来？

因为子类继承于父类，子类中有父类的对象，父类的构造方法初始化后，子类才能运行自己的构造方法

不能放过来，继承关系决定了调用构造函数的顺序。

2.

源代码：

public class ExplorationJDKSource {

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

    }
}
class A{}

结果截图：

反编译截图：

结果分析：

由反编译即如果可以看出，classA中虽然什么都没有，但继承了来自于“老祖宗”的Object中的方法，所以出现了如上结果

3方法覆盖

源代码：

class Parent 
{
    public void fu()
     {
            System.out.println("Parent ");
          }

}



class Child extends Parent 
{
    public void fu()
     {
        super.fu();
        System.out.println("Child ");
      }
}

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
                    Child c = new Child();
                    c.fu();
    }

}

结果截图：

结果分析：方法覆盖时，可以通过super在子类中调用被子类覆盖的父类方法。

1.覆盖方法的允许访问范围不能小于原方法。

2覆盖方法所抛出的异常不能比原方法更多。

3声明为final方法不允许覆盖。例如，Object的getClass()方法不能覆盖。

4不能覆盖静态方法。

4.

源代码：

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;

    }
}

下列语句哪一个将引起编译错误?为什么?哪一个会引起运行时错误?为什么?
  m=d;
  d=m;
  d=(Dog)m;
  d=c;
  c=(Cat)m;

先前判断：

第二个与第四个会引起编译错误

无运行错误

结果截图：

子类有父类没有的变量和方法，可以直接给父类对象赋值，而父类中没有子类的一些方法，变量，

不能直接给子类对象赋值，父类对象经过子类强制转换可以赋值给子类的对象，而子类对象可以赋值给父类对象。

同为子类对象不能互相赋值。

父类对象已经被Dog类赋值，在强制赋值给Cat类会出现错误。

5.运行以下测试代码

 代码

public class ParentChildTest {
    public static void main(String[] args) {
        Parent parent=new Parent();
        parent.printValue();
        Child child=new Child();
        child.printValue();
        
        parent=child;
        parent.printValue();
        
        parent.myValue++;
        parent.printValue();
        
        ((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);
    }
}

1.   左边的程序运行结果是什么？
2.   你如何解释会得到这样的输出？
3.   计算机是不会出错的，之所以得到这样的运行结果也是有原因的，那么从这些运行结果中，你能总 结出Java的哪些语法特性？
 结果截图

1子类对象可以赋值给父类的对象。父类进行子类强制转换可以赋值给子类的对象。

2子类能覆盖父类，但是父类中的变量的值是不改变的，访问父类中的变量时可用super来访问，反之则一直被子类覆盖。父类被覆盖时，对父类中的变量进行操作时，父类中的变量改变，但输出时仍输出覆盖父类的子类的变量。

3（child）Parent.myValue++,这时改变的将是覆盖父类的子类。

4当子类与父类拥有一样的方法，并且让一个父类变量引用一个子类对象时，到底调用哪个方法，由对象自己的“真实”类型所决定，这就是说：对象是子类型的，它就调用子类型的方法，是父类型的，它就调用父类型的方法。

这个特性实际上就是面向对象“多态”特性的具体表现。

如果子类与父类有相同的字段,则子类中的字段会代替或隐藏父类的字段，子类方法中访问的是子类中的字段（而不是父类中的字段）。如果子类方法确实想访问父类中被隐藏的同名字段，可以用super关键字来访问它。

如果子类被当作父类使用,则通过子类访问的字段是父类的