Java,C#,C++在继承，覆盖和多态,抽象类等几个方面的比较归纳

关于C#,C++,Java在继承，覆盖和多态,抽象类等几个方面的比较归纳。
C#,C++用visual studio2005编译通过；java代码用JDK1.4.2编译通过。

一、继承中的带参数构造函数
=============================
C#示例：
//myClass.cs

using System;
using System.Collections.Generic;
using System.Text;

namespace myClass
    class myFirst{
        int value_myFirst;
        public myFirst(int f)
        {
            value_myFirst = f;  
        }
    }
   
    class mySecond : myFirst{
        int value_mySecond;
       
        //构造函数传递参数时，采用base关键字，s在base()中不需重新声明类型int
        public mySecond(int s)
            : base(s)  
        {
            value_mySecond = s;      
        }
    }
       
    class Program
    {
        static void Main(string[] args)
        {
          
        }
    }
}

============================

C++示例：
#include "stdafx.h"

class myFirst{
private:
    int value_myFirst;
public:
    myFirst(int f){
        value_myFirst = f;  
    }
};

//继承需要声明继承的方式，此处是public
class mySecond : public myFirst{ 
private:
    int value_mySecond;
public:
    //构造函数传递参数时，用基类类名，s基类类名()中不需声明类型int
    mySecond(int s) : myFirst(s){
        value_mySecond = s;      
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
 return 0;
}

=============================

java示例：
package com;

class myFirst{
    int value_myFirst;
    public myFirst(int f){
        value_myFirst = f;  
    }
}

//继承采用extends关键字
class mySecond extends myFirst{
    int value_mySecond;
    public mySecond(int s){
        //传递给基类构造函数时，采用super关键字，而且必须是第一条语句。
        super(s); 
        value_mySecond = s;              
    }
}

public class myCon{
    public static void main(String[] args){
       
    }
}

注意：
1.注释中给出了三者的不同点。
2.另外，C++语法中定义的类后面必须加上分号";"
3.访问控制权限public等的格式，C#和java比较类似，C++相差很大。

 

 

二、方法覆盖与多态

C#示例：
//myClass.cs

using System;
using System.Collections.Generic;
using System.Text;

namespace myClass
{
    class myFirst
    {
        int value_myFirst;
        public myFirst(int f)
        {
            value_myFirst = f;
        }
        public void f1()
        {
            System.Console.WriteLine("myFirst.f1()!");
        }
        public virtual void f2()  //virtual也可以提到最前面
        {
            System.Console.WriteLine("myFirst.f2()!");
        }
    }

    class mySecond : myFirst
    {
        int value_mySecond;

        public mySecond(int s)
            : base(s)
        {
            value_mySecond = s;
        }
       
        //使用关键字new覆盖基类中的同名方法
        public new void f1()     //new也可以提到最前面
        {
            System.Console.WriteLine("mySeconde.f1()!");
        }
       
        //error当基类函数myFirst.f1()没有声明为virtual,abstract时不能override！
        //public override void f1() 
        //{
        //    System.Console.WriteLine("mySeconde.f1()!");
        //}
       
        //基类函数中虽然声明是virtual，但是仍然可以用new覆盖。
        //public new void f2()
        //{
        //    System.Console.WriteLine("mySeconde.f2()!");
        //}
       
        ////基类函数中虽然声明是virtual，用override覆盖。
        public override void f2()   //override也可以提到最前面
        {
            System.Console.WriteLine("mySeconde.f2()!");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            myFirst mf = new myFirst(1);
            mySecond ms = new mySecond(2);
            mf.f1(); //myFirst.f1()!
            mf.f2(); //myFirst.f2()!
            ms.f1(); //mySeconde.f1()!
            ms.f2(); //mySeconde.f2()!

            mf = ms; //向上转型之后
            mf.f1(); //myFirst.f1()!
           
            //mySeconde.f2()! 这是用override的运行结果；
            //如果是new那么，结果是myFirst.f2()!
            mf.f2();
        }
    }
}

=============================

C++示例

#include "stdafx.h"
#include <iostream>
using namespace std;

class myFirst{
private:
    int value_myFirst;
public:
    myFirst(int f){
        value_myFirst = f;  
    }

 void f1(){
  cout<<"myFirst.f1()!"<<endl;
 }
 vitual void f2(){  //声明为虚函数
  cout<<"myFirst.f2()!"<<endl;
 }
};

class mySecond : public myFirst{
private:
    int value_mySecond;
public:
    mySecond(int s) : myFirst(s){
        value_mySecond = s;      
    }
   
    //直接覆盖基类函数，无需C#中的new
 void f1(){
  cout<<"mySecond.f1()!"<<endl;
 }
   
    //覆盖基类需函数
 void f2(){
  cout<<"mySecond.f2()!"<<endl;
 }
};

int _tmain(int argc, _TCHAR* argv[])
{
 myFirst *mf = new myFirst(1);
 mySecond *ms = new mySecond(1);
 mf->f1();  //myFirst.f1()!
 mf->f2();  //myFirst.f2()!

 ms->f1();  //mySecond.f1()!
 ms->f2();  //mySecond.f2()!

 mf = ms;  //向上转型
 mf->f1(); //myFirst.f1()!
 mf->f2(); //mySecond.f2()!
 
 myFirst mf1(1);  //也可以
 mf1.f1();
 
 return 0;
}

=============================

java示例
//myCon.java

package com;

class myFirst{
    int value_myFirst;
    public myFirst(int f){
        value_myFirst = f;  
    }
    public void f1(){
        System.out.println("myFirst.f1()!");   
    }      
}

class mySecond extends myFirst{
    int value_mySecond;
    public mySecond(int s){       
        super(s); 
        value_mySecond = s;              
    }
    public void f1(){
        System.out.println("mySecond.f1()!");   
    }   
}

class myThird extends myFirst{
    int value_myThird;
    public myThird(int t){       
        super(t); 
        value_myThird = t;              
    }
    public void f1(){
        System.out.println("myThird.f1()!");   
    }    
}

public class myCon{
    public static void main(String[] args){
        myFirst mf = new myFirst(1);
        mySecond ms = new mySecond(1);
        myThird mt = new myThird(1);
               
        mf.f1();  //myFirst.f1()!            
        ms.f1();  //mySecond.f1()!     
        mt.f1();  //myThird.f1()!     
       
        //向上转型，由于java的动态绑定机制，
        //使得java能够调用派生类mySecond的f1()      
        mf = ms; 
        mf.f1();  //mySecond.f1()!
       
        mf = mt;
        mf.f1();  //myThird.f1()!     
              
    }
}

为了实现多态：
1.C#基类方法要声明为virtual，派生类覆盖时要用override；
2.C++基类方法要声明为virtual，派生类方法直接覆盖；
3.java直接覆盖就可以实现多态。

 

三、抽象类

C#示例
上面已经说明，虽然基类方法声明为virtual，以便派生类用override覆盖，但是派生类仍然可以用
new关键字覆盖(不具有多态性)。
可以强制让派生类覆盖基类的方法，将基类方法声明为抽象的，采用abstract关键字。
抽象方法没有方法体，由派生类来提供。

如果派生类不实现基类的抽象方法，则派生类也需要声明为abstract类

//myClass.cs

using System;
using System.Collections.Generic;
using System.Text;

namespace myClass{
   
    //类中只要存在抽象方法，就必须声明为抽象类
    abstract class myFirst 
    {
        int value_myFirst;
        public myFirst(int f)
        {
            value_myFirst = f;
        }
       
        //抽象方法没有方法体，以分号结尾。
        public abstract void f1();
       
        public void f2()
        {
            System.Console.WriteLine("myFirst.f2()!");
        }

        public virtual void f3()
        {
            System.Console.WriteLine("myFirst.f3()!");
        }
    }

    class mySecond : myFirst
    {
        int value_mySecond;

        public mySecond(int s)
            : base(s)
        {
            value_mySecond = s;
        }
       
        //覆盖基类抽象方法
        public override  void f1()  
        {
            System.Console.WriteLine("mySeconde.f1()!");
        }
        
        //覆盖基类一般方法    
        public new void f2()
        {
            System.Console.WriteLine("mySeconde.f2()!");
        }

        //覆盖基类虚拟方法
        public override void f3()
        {
            System.Console.WriteLine("mySecond.f3()!");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            //抽象类和接口不能声明对象
            //myFirst mf = new myFirst(1); 
            mySecond ms = new mySecond(2);
           
            ms.f1();  //mySeconde.f1()!
            ms.f2();  //mySeconde.f2()!
            ms.f3();  //mySecond.f3()!

            //这里向上转型采用强类型转换的方式
            ((myFirst)ms).f1();   //mySeconde.f1()!
            ((myFirst)ms).f2();   //myFirst.f2()!
            ((myFirst)ms).f3();   //mySecond.f3()!
           
        }
    }
}

=============================

C++示例

纯虚函数是在基类中只宣布某个虚函数的原型，并且为了明确通知编译系统，
该虚函数在基类中不再定义具体操作代码，而在函数原型结束分号的左侧写
"=0"标识。这个不包含任何代码的虚函数被成为纯虚函数。

抽象类是含有纯虚函数的类，这种类不能声明任何对象，其作用就是为它的
派生类提供一种规定输入数据和返回类型接口的模板。

从抽象类派生的派生类，必须对基类的纯虚函数进行覆盖；否则编译系统将
报错。

基类中虚函数被派生类覆盖，则派生类对象调用的是派生类中重新定义的函
数代码。
基类中虚函数没有被派生类覆盖，则派生类对象调用的是基类中定义的函数
代码。
基类的纯虚函数在其派生类中必须被覆盖。

#include "stdafx.h"
#include <iostream>
using namespace std;

class myFirst{   //抽象类
private:
    int value_myFirst;
public:
    myFirst(int f){
        value_myFirst = f;  
    }

 void f1(){            //一般函数
  cout<<"myFirst.f1()!"<<endl;
 }
 virtual void  f2(){   //虚函数
  cout<<"myFirst.f2()!"<<endl;
 }

 virtual void f3()=0;  //纯虚函数
};

class mySecond : public myFirst{
private:
    int value_mySecond;
public:
    mySecond(int s) : myFirst(s){
        value_mySecond = s;      
    }

 void f1(){         //覆盖基类一般函数
  cout<<"mySecond.f1()!"<<endl;
 }

 void f2(){         //覆盖基类虚函数
  cout<<"mySecond.f2()!"<<endl;
 }
 void f3(){         //覆盖基类纯虚函数
  cout<<"mySecond.f3()!"<<endl;
 }
};

int _tmain(int argc, _TCHAR* argv[])
{
 //myFirst *mf = new myFirst(1);  //抽象类不能创建对象
 mySecond *ms = new mySecond(1); 

 ms->f1();  //mySecond.f1()!
 ms->f2();  //mySecond.f2()!
 ms->f3();  //mySecond.f3()!

    //向上转型采用强类型转换
 ((myFirst *)ms)->f1(); //myFirst.f1()!
 ((myFirst *)ms)->f2(); //mySecond.f2()!
 ((myFirst *)ms)->f3(); //mySecond.f3()!

 return 0;
}

=============================

java示例

java提供了抽象方法的机制abstract method，这种方法不完整，仅有声明
没有方法体
abstract void f();
包含抽象方法的类叫抽象类，如果类中包含一个或多个抽象方法，则该类必
须被声明为抽象类，用abstract来修饰抽象类。
如果从一个抽象类继承，并创建这个新类的对象，必须给抽象基类中所有抽
象方法提供方法定义，否则，派生类也是抽象类，也用abstract修饰。

package com;

abstract class myFirst{
    int value_myFirst;
    public myFirst(int f){
        value_myFirst = f;  
    }
    public void f1(){
        System.out.println("myFirst.f1()!");   
    }
    public abstract void f2();    //抽象方法  
}

//继承采用extends关键字
class mySecond extends myFirst{
    int value_mySecond;
    public mySecond(int s){
        //传递给基类构造函数时，采用super关键字，而且必须是第一条语句。
        super(s); 
        value_mySecond = s;              
    }
    public void f1(){
        System.out.println("mySecond.f1()!");   
    }
   
    public void f2(){  //覆盖基类抽象方法
        System.out.println("mySecond.f2()!");    
    }  
}

//如果不实现基类抽象方法，那么此派生类也必须用abstract修饰
abstract class myThird extends myFirst{
    int value_myThird;
    public myThird(int t){       
        super(t); 
        value_myThird = t;              
    }
    public void f1(){
        System.out.println("myThird.f1()!");   
    }    
}

public class myCon{
    public static void main(String[] args){
       
        //myFirst mf = new myFirst(1); //抽象函数不能创建对象
        mySecond ms = new mySecond(1);
        //myThird mt = new myThird(1);
       
        ms.f1();  //mySecond.f1()!
        ms.f2();  //mySecond.f2()!
       
        ((myFirst)ms).f1();  //mySecond.f1()!
        ((myFirst)ms).f2();  //mySecond.f2()!
    }
}

关于抽象方法和抽象类java和C#比较类似；
而C++叫纯虚函数和抽象类。

四、接口
C++中的没有接口的概念，它本身就可以多继承。

java中接口interface比抽象类abstract更进了一步，可看做"纯粹的抽象类"。
它允许创建者为一个类建立其形式，方法名，参数列表，返回类型，但没有
任何方法体。接口中也可以包含成员函数，但是他们都是隐含的public和
final。

创建接口时用interface来代替class，前面可以有public，如果不加访问权
限，那么它就是默认的包访问权限。
接口中的方法默认为public。

类实现接口要用implements关键字。

接口便于实现多重继承的效果,此处不作具体讨论。

package com;

interface myFirst{
    int value_myFirst=1;   
    public void f1();
}

class mySecond implements myFirst{
    int value_mySecond;
    public mySecond(int s){       
        value_mySecond = s;              
    }
    public void f1(){
        System.out.println("mySecond.f1()!");   
    }
}

public class myCon{
    static void play(myFirst mf){
        mf.f1();  
    }
    public static void main(String[] args){
       
       
        //myFirst mf = new myFirst(1);
        mySecond ms = new mySecond(1);
       
        ms.f1();   //mySecond.f1()!      
        play(ms);  //向上转型 mySecond.f1()!
       
        ((myFirst)ms).f1(); ////向上转型 mySecond.f1()!
    }
}