C++和Java中的继承性比较

继承的目的在C++和Java中是一样的。继承在这两种语言中都被用于重用代码和/或创建 “is-a “关系。下面的例子将展示Java和C++在提供继承支持方面的差异。

1)在Java中，所有的类都直接或间接地继承自Object类。 因此，在Java中总是有一个单一的类继承树，而Object类是这个树的根。在Java中，当创建一个类时，它会自动继承自Object类。然而在C++中，有一个类的森林；当我们创建一个没有继承自另一个类的类时，我们在森林中创建了一棵新的树。

按照Java的例子显示， Test类 自动继承于Object类。

class Test {
    // members of test
}
class Main {
    public static void main(String[] args)
    {
        Test t = new Test();
        System.out.println("t is instanceof Object: "
                           + (t instanceof Object));
    }
}

输出

t is instanceof Object: true

2)在Java中，祖先类的成员是不能直接访问的， （更多细节请参考 这 篇文章）。

3) 在Java中， 受保护成员访问的含义有些不同。 在Java中，一个类 “A “的受保护成员可以在同一包的其他类 “B “中访问，即使B没有继承自A（它们都必须在同一包中）。

例如，在下面的程序中，A的受保护成员可以在B中访问。

class A {
    protected int x = 10, y = 20;
}
 
class B {
    public static void main(String args[])
    {
        A a = new A();
        System.out.println(a.x + " " + a.y);
    }
}

输出

10 20

4) Java使用 “extends “关键字来继承。与C++不同，Java不提供像public、protected或private这样的 继承 指定符。因此，在Java中我们不能改变基类成员的保护级别，如果某些数据成员在基类中是公开的或受保护的，那么它在派生类中仍然是公开的或受保护的。与C++一样，基类中的私有成员在派生类中是不可访问的。

与C++不同，在Java中，我们不必记住那些继承规则，这些规则是基类访问规范和继承规范的组合。

5) 在Java中，方法默认是虚拟的。在C++中，我们明确地使用虚拟关键字。

6)Java对接口使用单独的关键字interface，对抽象类和抽象函数使用抽象关键字

下面是一个Java抽象类的例子。

// An abstract class example
abstract class myAbstractClass {
 
    // An abstract method
    abstract void myAbstractFun();
 
    // A normal method
    void fun() { System.out.println("Inside My fun"); }
}
 
public class myClass extends myAbstractClass {
    public void myAbstractFun()
    {
        System.out.println("Inside My fun");
    }
}

以下是一个Java接口的例子，

// An interface example
public interface myInterface {
   
    // myAbstractFun() is public
     // and abstract, even if we
    // don't use these keywords
    void myAbstractFun();
    // is same as public abstract void myAbstractFun()
}
 
// Note the implements keyword also.
public class myClass implements myInterface {
    public void myAbstractFun()
    {
        System.out.println("Inside My fun");
    }
}

7)与C++不同，Java不支持多重继承。 一个类不能从多个类中继承。但是，一个类可以实现多个接口。

8) 在C++中，父类的默认构造函数被自动调用，但如果我们想调用父类的参数化构造函数，我们必须使用Initializer列表。和C++一样，在Java中，父类的默认构造函数会被自动调用，但如果我们想调用参数化的构造函数，那么我们必须使用super来调用父类的构造函数。请看下面的Java例子。

package main;
 
class Base {
    private int b;
    Base(int x)
    {
        b = x;
        System.out.println("Base constructor called");
    }
}
 
class Derived extends Base {
    private int d;
    Derived(int x, int y)
    {
        // Calling parent class parameterized constructor
        // Call to parent constructor must be the first line
        // in a Derived class
        super(x);
        d = y;
        System.out.println("Derived constructor called");
    }
}
 
class Main {
    public static void main(String[] args)
    {
        Derived obj = new Derived(1, 2);
    }
}

输出

Base constructor called
Derived constructor called

如果你发现有什么不正确的地方，或者你想分享更多关于上面讨论的主题的信息，请写评论。