Java学习中的一些小问题

1、接口、继承和多态

Question:

1、super关键字怎么用？
2、重写、重载、重构有什么区别？
3、多重继承时，实例化一个子类对象，父类的构造方法如何被调用？

Answer:

1、在继承中，子类可以继承父类的构造方法，成员方法，可以在子类的构造方法中使用super关键字来调用父类的构造方法和成员方法，如下代码所示

class B extends A {  // 子类B继承父类A
    public B(){      // 子类B的构造方法
        super();     // 调用父类的构造方法
        super.doSomething();  // 调用父类的成员方法(不能调用权限为private的成员方法)
    }
}

2、重写（也可以叫覆盖）是指在子类中将父类的成员方法的名称保留，但是改写成员方法的实现内容，或者修改成员方法的返回值类型，修改成员方法的存储权限。重载是指对于同一个类中的成员方法，保持方法名称一致，但是改变方法的参数个数、参数类型、参数顺序。重构是特殊的重写方式，子类与父类的成员方法返回值、方法名称、参数类型以及个数完全相同、唯一不同的是方法实现内容

3、有三个类，Parent类、SubParent类和Subroutine类，后者依次继承前者

class Parent{
    public Parent(){
        System.out.println("调用父类parent()的构造方法");
    }
}

class SubParent extends Parent{
    public SubParent(){
        System.out.println("调用父类subparent()的构造方法");
    }
}

public class Subroutine extends SubParent{
    public Subroutine(){
        System.out.println("调用父类Subroutine()的构造方法");
    }
    public static void main(String[] args){
        Subroutine s = new Subroutine();
    }
}

执行结果：

调用父类parent()的构造方法
调用父类subparent()的构造方法
调用父类Subroutine()的构造方法

可以看到，在子类中，只调用了子类的构造方法实例化了子类对象，但是实例化的子类对象先后调用了父类的构造方法，并且是从顶级父类开始依次调用 ，最后才调用子类的构造方法，也就是说子类的对象在实例化之前必须先实例化父类的对象。
注意： 在实例化子类对象时，父类无参构造方法将被自动调用，但是有参构造方法只能依赖于super关键字显示地调用。

2、抽象类与接口

2.1 抽象类

在解决实际问题中，一般将父类定义为抽象类，需要使用这个父类进行继承与多态处理。在抽象类中不能实例化对象。

抽象类语法：

public abstract class Test{
    abstract void testAbstract();    // 没有方法体
}

只要类中有一个抽象方法，这个类就是抽象类。
抽象类被继承后需要实现其中所有的抽象方法，也就是保证相同的方法名称，参数列表和相同的返回值类型创建出非抽象方法，当然也可以是抽象方法。

2.2 接口

接口是抽象类的延伸，可以将它看作是纯粹的抽象类，接口中所有的方法都没有方法体

语法定义

public interface drawTest{
    void draw();     // 接口内的方法，省去abstract 关键字
}

一个类实现一个接口可以用implements 关键字，代码如下：

public class A extends B implements C {
    ...
}

注意：在接口中定义的方法必须被定义为 public 或abstract 形式，其它修饰权限不被java编译器认可。即使不将该方法申明为public ，它也是固定public 的。

接口中定义的任何字段都自动是static 和 public 的

interface drawTest{    // 定义一个接口
    public void draw();    
}

class B extends A implements drawTest{  // B类继承A类，并且实现drawTest接口
    public void draw(){
        System.out.println('Class B.draw()');
    }

    void doAnything(){    // 覆盖父类方法
        // something
    } 
}

class C extends A implements drawTest{  // C类继承A类，并且实现drawTest接口

    public void draw(){
        System.out.println('Class C.draw()'); 
    }
    void doAnything(){    // 覆盖父类方法
        // something
    } 

}


class D extends A{       // D类继承A类
    void doAnything(){

    }
}

public class A{     // 定义A类
    public void doAnything(){
        // do something 
    }

    public static void main(String[] args){
        drawTest[] d={new B(),new C()};   // 接口也可以进行向上转型操作
        for(int i=0;i<d.length;i++){
            d[i].draw();    // 调用draw()方法
        }

    } 

}

Java 中不允许多重继承，但是使用接口可以实现多重继承，因为一个类可以实现多个接口

多重继承语法如下：

class 类名 implements 接口1,接口2,...,接口n

2.3、接口和抽象类

两者的异同：

相同：都可以有抽象方法
不同：抽象类可以有实例变量，但接口中不能有，接口中的变量都是静态( static )和常量 ( final )
抽象类可以有非抽象方法，但是接口中只能是抽象方法

以下内容引用自[1]

1、抽象层次不同。抽象类是对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。

2、 跨域不同。抽象类所跨域的是具有相似特点的类，而接口却可以跨域不同的类。我们知道抽象类是从子类中发现公共部分，然后泛化成抽象类，子类继承该父类即可，但是接口不同。实现它的子类可以不存在任何关系，共同之处。例如猫、狗可以抽象成一个动物类抽象类，具备叫的方法。鸟、飞机可以实现飞Fly接口，具备飞的行为，这里我们总不能将鸟、飞机共用一个父类吧！所以说抽象类所体现的是一种继承关系，要想使得继承关系合理，父类和派生类之间必须存在”is-a” 关系，即父类和派生类在概念本质上应该是相同的。对于接口则不然，并不要求接口的实现者和接口定义在概念本质上是一致的， 仅仅是实现了接口定义的契约而已。

3、 设计层次不同。对于抽象类而言，它是自下而上来设计的，我们要先知道子类才能抽象出父类，而接口则不同，它根本就不需要知道子类的存在，只需要定义一个规则即可，至于什么子类、什么时候怎么实现它一概不知。比如我们只有一个猫类在这里，如果你这是就抽象成一个动物类，是不是设计有点儿过度？我们起码要有两个动物类，猫、狗在这里，我们在抽象他们的共同点形成动物抽象类吧！所以说抽象类往往都是通过重构而来的！但是接口就不同，比如说飞，我们根本就不知道会有什么东西来实现这个飞接口，怎么实现也不得而知，我们要做的就是事前定义好飞的行为接口。所以说抽象类是自底向上抽象而来的，接口是自顶向下设计出来的。

[1] : http://www.cnblogs.com/chenssy/p/3376708.html