#include<iostream>
using namespace std;
class CPerson
{
        protected:/*public*/
        /*virtual*/ void display()
        {
        cout<<"CPerson"<<endl;
        }
        public:
        void show()
        {
                display();
        }

};
class CStudent:public CPerson
{
public:
        void display()
        {
        cout<<"CStudent"<<endl;
        }
};
int main()
{
        CPerson *p=new CStudent();
        //********************重点看这里****************//
        //当基类中是public，没有virtual时
        p->display();//输出CPerson，发生了隐藏，对基类而言，原先的成员函数（display（））还存在
        p->show();//输出CPerson，这个可以用上面的理论解释，即show中调用的是CPerson的display（）
        //当基类中是public，有virtual时
        p->display();//输出CStudent，发生了覆盖，对基类而言，原先的成员函数被替换
        p->display();//输出CStudent，可以用上面的理论解释，即，替换后的成员还是CPerson的
        //当基类中是protected，没有virtual时，
        p->display();//错误，类外无法访问protected成员，（但其实发生了隐藏）
        p->show();//输出CPerson，show中的display（），是隐藏后的，因为只是隐藏，所以对基类而言，原先的d                  
　　　　　　　　　　 //isplay（）还存在，所以不是CStudent
        　　　　　　//当基类中是pritected，有virtual是
        p->display();//错误，类外无法访问protected成员，（但已经发生了覆盖），只是覆盖后的函数成员对CPe                     
　　　　　　　　　　　　　//rson而言，依然是protected的
        p->show();   //输出，CStudent，因为发生了覆盖和替换。
        return 0;
}

import java.util.*;
public class test extends quiz
{
        public static void  main(String []args)
        {
                quiz p3=new test();
                p3.display();//无论是public还是protected，都一样，因为是包内访问
                             //java没有virtual关键字，因此直接默认的就是覆盖而不是隐藏
                             //所以输出的是test;
        }
        public void add()
        {
                a++;
        }
        public/*protected*/ void display()
        {
          System.out.println("test");
        }

}

class quiz
{
        protected/*public*/ void display()
        {
        System.out.println("quiz");
        }

}