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

在C++中继承可分为公有继承（public）保护继承(protected)和私有继承（private),而在Java中默认只有一种继承（相当于C++中的公有继承）下面我们来看一段代码

1. #include <iostream>  
2. using namespace std;  
3.   
4. class A{  
5.     int aprivate;  
6.     void Aprivate(){  
7.         cout << "A类的private方法" << endl;  
8.     }  
9. protected:  
10.     int aprotected;  
11.     void Aprotected(){  
12.         cout << "A类的protected方法" << endl;  
13.     }  
14. public:  
15.     A(){}  
16.     A(int a, int b, int c):aprivate(a), aprotected(b), apublic(c){}  
17.     int apublic;  
18.     void Apublic(){  
19.         cout << "A类的public方法" << endl;  
20.     }  
21. };  
22.   
23. //class B : private A{  
24.       
25. //public:  
26. //  B(){}  
27. //  B(int a, int b, int c):A(a, b, c){}  
28. //  void Bpublic(){  
29. //      Aprotected();  
30. //      cout << "B类的public方法----" << aprotected << endl;  
31. //  }  
32. //};  
33.   
34. int main(){  
35.     A a(100, 200, 300);  
36.     a.Apublic();  
37. //  a.Aprotected();  
38. //  a.Aprivate();  
39.     cout << a.apublic << endl;  
40. //  cout << a.aprotected << endl;  
41. //  cout << a.aprivate << endl;  
42.   
43.     return 0;  
44. }  

我们定义了一个类A，可以看到：

1、类A外部我们只可以访问公有成员（public），protected和private的成员均不可访问。

2、类A内部成员函数可以访问所有成员，包括（public、protected、private).

上面这两个特点和Java是完全相同的。

下面我们来让B类继承子A类，代码如下：

1. class B : private A{  
2.       
3. public:  
4.     B(){}  
5.     B(int a, int b, int c):A(a, b, c){}  
6.     void Bpublic(){  
7.         Aprotected();  
8.         cout << "B类的public方法----" << aprotected << endl;  
9.     }  
10. };  

将上面的继承改为私有继承、保护继承、公有继承，都有以下结论：

1、子类B内部可以访问父类的非private成员。

2、子类B和父类A在类体外部均不可访问类的私有（private）成员。

3、如果是公有继承（public),则子类B在外部可访问父类A的公有属性（如 Apublic()方法）。

4、如果是私有继承和保护继承，子类B在外部不可访问类A的所有属性。

5、如果是保护继承，在B类中继承自A类的保护属性和公有属性均变为保护属性，同理私有继承。

上面这些描述可能有些绕，其实我们可以从上面的结论中看到如下结论，继承方式（public、protected、private)会改变子类继承自父类属性的访问权限（private、protected、public),如下：

	public	protected	private
共有继承	public	protected	不可见
私有继承	private	private	不可见
保护继承	protected	protected	不可见

从上面的分析我们可以看出继承方式可以改变子类继承子父类属性的访问区域，所以如果此时有子类C继承自B类，同样会影响到C类对A类成员的访问。

下面我们来看看Java中的继承，先来看一段代码：

1. public class A {  
2.       
3.     private int aprivate;  
4.     int afriendly;  
5.     protected int aprotected;  
6.     public int apublic;  
7.       
8.     private void Aprivate(){  
9.         System.out.println("A类的private方法");  
10.     }  
11.       
12.     void Afriendly(){  
13.         System.out.println("A类的friendly方法");  
14.     }  
15.       
16.     protected void Aprotected(){  
17.         System.out.println("A类的protected方法");  
18.     }  
19.       
20.     public void Apublic(){  
21.         System.out.println("A类的public方法");  
22.     }  
23. }  

1. public class Test {  
2.       
3.     public static void main(String[] args) {  
4.         A a = new A();  
5.         //a.Aprivate();  
6.         a.Afriendly();  
7.         a.Aprotected();  
8.         a.Apublic();  
9.         //System.out.println(a.aprivate);  
10.         System.out.println(a.afriendly);  
11.         System.out.println(a.aprotected);  
12.         System.out.println(a.apublic);  
13.     }  
14. }  

可以看到:

1、Java比C++多了一个friendly访问权限，应为C++中没有包的概念（是命名空间）.

2、Java中的protected属性是可以在类外部访问的。

3、Java中的friendly属性可以在相同包下的类外部访问。

注意：protected属性也可以在同一个包类访问，如果Test类和A类不在同一个包下的话，上面的a.Afriendly()和a.Aprotected()均不可访问。

1. public class B extends A{  
2.       
3.     public void Bpublic(){  
4.         Afriendly();  
5.         Aprotected();  
6.         Apublic();  
7.     }  
8. }  

1. B b = new B();  
2. b.Bpublic();  
3. b.Afriendly();  
4. b.Aprotected();  
5. b.Apublic();  

可以看到：

1、Java中的继承不区分（私有继承和公有继承）所以继承后相当于C++中的公有继承。

2、Java中的protected成员是可以在类外部被访问的（protected和friendly的前提是在同一个包下）。

下面我们再来看一个特点：

1. public class B extends A{  
2.       
3.     @Override  
4.     public void Afriendly() {  
5.         super.Afriendly();  
6.         System.out.println("重写了A类的Afriendly方法");  
7.     }  
8.       
9.     public void Bpublic(){  
10.         Afriendly();  
11.         Aprotected();  
12.         Apublic();  
13.     }  
14. }  

可以看到：

1、在子类B中重写A类的Afriendly方法的时候我们可以将访问权限增大（如上面的public）

2、Java中的文件中只能有一个public类。

3、Java中的外部类（对应的是内部类，这里暂且不谈）只能被修饰为public或friendly，不能被修饰为private或protected.

最后我们来做一个总结吧：

1、在Java中有四种权限，public可以在整个工程访问，protected属性可以在本类和子类的整个工程访问，friendly属性可以在本类的整个工程访问，private只能在本类内部访问。

2、在C++中又三中权限，public可以在整个工程访问，protected属性只能在本类内部和子类的内部访问，private属性只能在子类内部访问。

另外C++中可以多继承，一个多继承的例子如下：

1. #include <iostream>  
2. using namespace std;  
3.   
4. class B1{  
5.     int b1;  
6. public:  
7.     B1(int i){  
8.         b1 = i;  
9.         cout << "构造函数 B1." << i << endl;  
10.     }  
11.     void print(){  
12.         cout << b1 << endl;  
13.     }  
14. };  
15.   
16. class B2{  
17.     int b2;  
18. public:  
19.     B2(int i){  
20.         b2 = i;  
21.         cout << "构造函数 B2." << i << endl;  
22.     }  
23.     void print(){  
24.         cout << b2 << endl;  
25.     }  
26. };  
27.   
28. class B3{  
29.     int b3;  
30. public:  
31.     B3(int i){  
32.         b3 = i;  
33.         cout << "构造函数 B3." << i << endl;  
34.     }  
35.     int getb3(){  
36.         return b3;  
37.     }  
38. };  
39.   
40. class A : public B2, public B1{  
41.     int a;  
42.     B3 bb;  
43. public:  
44.     A(int i, int j, int k, int l):B1(i), B2(j), bb(k){  
45.         a = l;   
46.         cout << "构造函数 A." << l << endl;  
47.     }  
48.   
49.     void print(){  
50.         B1::print();  
51.         B2::print();  
52.         cout << a << ", " << bb.getb3() << endl;  
53.     }  
54. };  
55.   
56. int main(){  
57.     A aa(1, 2, 3, 4);  
58.     aa.print();  
59.     return 0;  
60. }