C++和java的多态性比较

C++子类类型的指针赋值给父类类型的指针。如father* fason = new son(3);

Java子类类型的引用赋值给父类类型。如father fason = new son();

共同点：

不能访问子类新增的成员。

区别：

C++必须在父类方法中加上virtual，否则即使子类重写了父类的方法，fason->print()依然调用的是父类的方法。

Java与C++不同，只要子类重写了父类的方法，fason.print()调用的就是子类的方法。

//C++多态实现的必要条件：virtual+重写
#include "iostream"
using namespace std;
class father{
public:
	int f;
	father(){
		f = 0;
	}
	//java则不需要virtual
	//virtual void print(){
	void print(){
		//必须有virtual,father* fason = new son(3);fason->print();才会调用子类的，
		//但若此时子类没有定义（重写）print()，则还是访问父类的，而且输出的也是父类的f值
		
		cout<<"f = "<<f<<endl;
	}
};

class son:public father{
public:
	int f;
	son(int x):father(){
		f = x;
	}
	void print(){//为了实现多态性，不止父类需要virtual，这里也必须重写方法
		cout<<f<<endl;
	}
	void prt(){
		cout<<"hello"<<endl;
	}
};

int main(){
	father* fason = new son(3);
	fason->print();
	//fason->prt();
	return 0;
}

/**
 * 子类只需重写父类的成员即可。
 */
package t;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Collections;

class father{
	public int f = 0;
	public void print(){
		System.out.println("f = "+f);
	}
	
}
class son extends father{
	public int f = 3;//f覆盖
	public void print(){//覆盖
		System.out.println(f);
	}
}

class sont extends father{
	
	public void print(){
		System.out.println(f);//f继承，方法覆盖
	}
}

public class Test{       
  
	public static void main(String[] args) throws Exception {       	 	
    	
    	father fason = new son();
    	fason.print();//输出儿子的数据
    	
    	father fa = new father();
    	fa.print();
    	
    	father fasont = new sont();
    	fasont.print();
    	
        
    }   
}