精华内容
下载资源
问答
  • 在派生类中调用基类方法

    千次阅读 2009-04-10 09:18:00
    base 关键字用于从派生类中访问基类的成员: 调用基类上已被其他方法重写的方法。... 示例: 在派生类中调用基类方法。 // base 关键字// 访问基类成员using System;public class BaseClass{ protected string _cl

    base 关键字用于从派生类中访问基类的成员:

    调用基类上已被其他方法重写的方法。
    指定创建派生类实例时应调用的基类构造函数。
    基类访问只能在构造函数、实例方法或实例属性访问器中进行。

    示例:

     

    在派生类中调用基类方法。
    // base 关键字
    // 访问基类成员
    using System;

    public class BaseClass
    {
        protected string _className = "BaseClass";

        public virtual void PrintName()
        {
            Console.WriteLine("Class Name: {0}", _className);
        }
    }

    class DerivedClass : BaseClass
    {
        public string _className = "DerivedClass";

        public override void PrintName()
        {
            Console.Write("The BaseClass Name is {0}");
            //调用基类方法
            base.PrintName();
            Console.WriteLine("This DerivedClass is {0}", _className);
        }
    }

    class TestApp
    {
        public static void Main()
        {
            DerivedClass dc = new DerivedClass();
            dc.PrintName();
        }
    }

    /**//*
    控制台输出:
    The BaseClass Name is BaseClass
    This DerivedClass is DerivedClass
    */
    在派生类中调用基类构造函数。
    // keywords_base2.cs
    using System;
    public class BaseClass
    {
        int num;

        public BaseClass()
        {
            Console.WriteLine("in BaseClass()");
        }

        public BaseClass(int i)
        {
            num = i;
            Console.WriteLine("in BaseClass(int {0})", num);
        }
    }

    public class DerivedClass : BaseClass
    {
        // 该构造器调用 BaseClass.BaseClass()
        public DerivedClass() : base()
        {
        }

        // 该构造器调用 BaseClass.BaseClass(int i)
        public DerivedClass(int i) : base(i)
        {
        }

        static void Main()
        {
            DerivedClass dc = new DerivedClass();
            DerivedClass dc1 = new DerivedClass(1);
        }
    }

    /**//*
    控制台输出:
    in BaseClass()
    in BaseClass(1)
    */

    注意点

    从静态方法中使用 base 关键字是错误的。
    base 主要用于面向对象开发的对态这方面,在示例2中有体现。
    this
    this 关键字引用类的当前实例。

    以下是 this 的常用用途:

    限定被相似的名称隐藏的成员
    将对象作为参数传递到其他方法
    声明索引器
    示例:

     综合示例。
    // this 关键字
    // keywords_this.cs
    using System;
    class Employee
    {
        private string _name;
        private int _age;
        private string[] _arr = new string[5];

        public Employee(string name, int age)
        {
            // 使用this限定字段,name与age
            this._name = name;
            this._age = age;
        }

        public string Name
        {
            get { return this._name; }
        }

        public int Age
        {
            get { return this._age; }
        }

        // 打印雇员资料
        public void PrintEmployee()
        {
            // 将Employee对象作为参数传递到DoPrint方法
            Print.DoPrint(this);
        }

        // 声明索引器
        public string this[int param]
        {
            get { return _arr[param]; }
            set { _arr[param] = value; }
        }

    }
    class Print
    {
        public static void DoPrint(Employee e)
        {
            Console.WriteLine("Name: {0}/nAge: {1}", e.Name, e.Age);
        }
    }

    class TestApp
    {
        static void Main()
        {
            Employee E = new Employee("Hunts", 21);
            E[0] = "Scott";
            E[1] = "Leigh";
            E[4] = "Kiwis";
            E.PrintEmployee();

            for(int i=0; i<5; i++)
            {
                Console.WriteLine("Friends Name: {0}", E[i]);
            }

            Console.ReadLine();
        }
    }

    /**//*
    控制台输出:
    Name: Hunts
    Age: 21
    Friends Name: Scott
    Friends Name: Leigh
    Friends Name:
    Friends Name:
    Friends Name: Kiwis
    */
    注意点

    由于静态成员函数存在于类一级,并且不是对象的一部分,因此没有 this 指针。在静态方法中引用 this 是错误的。
    索引器允许类或结构的实例按照与数组相同的方式进行索引。索引器类似于属性,不同之处在于它们的访问器采用参数。

    展开全文
  • 在派生类中实现与基类方法名相同的方法,返回值和特征标都一样,在派生类中就相当于覆盖基类的该方法。 #include &lt;iostream&gt; using namespace std; class Fish{ private: bool isFreshWaterFish; ...

    派生类覆盖基类方法

    在派生类中实现与基类方法名相同的方法,返回值和特征标都一样,在派生类中就相当于覆盖基类的该方法。

    #include <iostream>
    using namespace std;
    class Fish{
    private:
    	bool isFreshWaterFish;
    public:
    	Fish(bool isFreshWater):isFreshWaterFish(isFreshWater){}
    	void Swim(){
    		if(isFreshWaterFish){cout<<"Swim in lake"<<endl;}
    		else{cout<<"Swim in sea"<<endl;}
    	}
    } 
    class Tuna:public Fish{
    public:
    	Tuna():Fish(false){}
    	void Swim(){
    		cout<<"Tuna swim in sea"<<endl;
    	}
    }
    int main(){
    	Tuna myTuna;
    	myTuna.Swim();
    	return 0;
    }
    输出:
    Tuna swim in sea
    

    那么如何在main()调用基类实现的,但是被派生类覆盖的方法?
    需要使用作用域标识符(::)

    Tuna myTuna;
    myTuna.Fish::Swim();//调用基类中实现的方法
    myTuna.Swim();//调用派生类实现的方法
    

    那么又怎么在派生类中调用基类实现的方法?

    Fish::Swim();
    

    在派生类中隐藏基类的方法

    #include <iostream>
    using namespace std;
    
    class Fish{
    private:
    	bool isFreshWaterFish;
    public:
    	Fish(bool isFreshWater):isFreshWaterFish(isFreshWater){}
    	void Swim(){
    		cout<<"Swim in ..."<<endl;
    	}
    	void Swim(bool isFreshWater){
    		if(isFreshWaterFish){cout<<"Swim in lake"<<endl;}
    		else{cout<<"Swim in sea"<<endl;}
    	}
    } 
    class Tuna:public Fish{
    public:
    	Tuna():Fish(false){}
    	void Swim(){
    		cout<<"Tuna swim in sea"<<endl;
    	}
    }
    int main(){
    	Tuna myTuna;
    	myTuna.Swim();
    	//myTuna.Swim(false);
    	return 0;
    }
    
    

    其中myTuna.Swim(false);将会导致编译错误。由于派生类实现自己的Swim()方法,覆盖基类的Swim()方法以及重载方法。
    解决方案有:

    1. 使用作用域表示符myTuna.Fish::Swim();
    2. 使用关键字using解除对Fish::Swim()的隐藏
    class Tuna {
    	public:
    	using Fish::Swim;
    	void Swim(){
    		cout<<"Tuna swim in sea"<<endl;
    	}
    }
    
    1. 在派生类中实现基类所有重载的版本(Tuna类中覆盖Fish类)

    切除问题

    将一个派生类实例化对象,复制给其基类对象,编译器只复制基类所能承受的部分,这是一种无意间造成的裁剪数据,所以一般不要使用值传递,应该使用基类指针或者const引用的方式传递。

    展开全文
  • 一、在派生类中调用基类成员 在C#派生类中,我们可以使用base关键字调用基类中公有或者受保护成员。这些成员只能是构造函数、实例方法或者实例属性。 base关键字调用基类成员语法格式如下: base . ...

    一、在派生类中调用基类成员

    在C#的派生类中,我们可以使用base关键字调用基类中的公有或者受保护成员。这些成员只能是构造函数、实例方法或者实例属性。

    base关键字调用基类成员的语法格式如下:

    base . identifier或

    base[expression-list]注意:

    ?base关键字不能用在派生类的静态方法中。

    ?必须显式添加基类的构造函数。

    二、示例
      
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
     
    namespace Test
    {
        class Program
        {
            public class A                     // 基类
            {
                protected string name; // 受保护字段成员,可在当前类和派生类中访问
                protected int age;             // 受保护字段成员
                public A(string name, int age) // 实例构造函数
                {
                    this.name = name;
                    this.age = age;
                }
                public void Show()             // 公共方法
                {
                    Console.WriteLine("基类-name:{0} age:{1}",name,age);
                }
            }
            public class B : A                 // 这是派生类,以A作为基类
            {
                private int ID;                // 派生类的成员
                public B(int ID, string name, int age)
                    : base(name, age)          // 调用直接基类的实例构造函数
                {
                    this.ID = ID;
                    Console.WriteLine("派生类B的构造函数");
                }
                new public void Show() // 用new关键字隐藏基类中的同名方法
                {
                    Console.WriteLine("ID:{0}", ID);
                    Console.WriteLine("派生类B的Show方法");
                    base.Show();               // 调用基类的方法
                }
            }
            static void Main(string[] args)
            {
                // C#在派生类中调用基类成员-www.baike369.com
                B b = new B(100,"BaiXue",18);  // 创建类的实例
                b.Show();                      // 调用派生类B的方法
                Console.ReadLine();
            }
        }
    }

    运行结果:
     
    派生类B的构造函数
    ID:100
    派生类B的Show方法
    基类-name:BaiXue age:18

    转载于:https://www.cnblogs.com/melao2006/p/4239253.html

    展开全文
  • #include &lt;iostream&gt; using namespace std; /*有些基类的方法在派生...* 1: 直接在派生类中调用被覆盖的基类方法,如 Person::CheckPerson() ; * 2: 使用派生类对象调用被覆盖的基类方法,如 Tom.P...
    #include <iostream>
    using namespace std;
    
    /*有些基类的方法在派生类被覆盖,但有时我们需要调用基类的方法。
    * 这里提供了两种方式去调用基类被覆盖的方法(均使用作用域解析运算符::)。
    * 1: 直接在派生类中调用被覆盖的基类方法,如 Person::CheckPerson() ;
    * 2:  使用派生类对象调用被覆盖的基类方法,如 Tom.Person::CheckPerson();
    */
    class Person {
    protected: //只能在派生类内部访问protected成员,外部不可访问
    	bool man;
    public: // public权限,可被派生类访问
    	void CheckPerson();
    
    	Person(bool initValue) { //构造函数的重载,带初始值
    		man = initValue;
    		cout << "Person constructor" << endl;
    	}
    
    	~Person() {
    		cout << "~Person deconstructor" << endl;
    	}
    };
    
    void Person::CheckPerson() {
    	if (man)
    		cout << "Person is man" << endl;
    	else
    		cout << "Person is woman" << endl;
    }
    
    class Man: public Person {  //public继承,可访问基类public和protected权限的成员
    public:  
    	void CheckPerson(); //覆盖基类的方法
    	Man() : Person(true) {}; //利用初始化列表,对基类的成员进行初始化(基类重载构造函数需要初始化值)
    	~Man() {};
    };
    
    /*类Man继承了Person的public和protected成员,这里覆盖基类中的函数CheckPerson()*/
    void Man::CheckPerson() { //覆盖基类中的函数CheckPerson()
    	if (man) {
    		Person::CheckPerson();//使用作用域解运算符::,可调用被覆盖的基类方法
    		cout << "calss function is covered: man" << endl;
    	}
    	else {
    		cout << "calss function is covered: woman" << endl;
    	}
    }
    
    int main()
    {
    	Man Tom;
    	Tom.CheckPerson(); //派生类外部可调用继承的基类public成员
    	Tom.Person::CheckPerson(); //使用作用域解运算符::,可调用被覆盖的基类方法
    	//Tom.man = false;   //编译出错,外部不可修改继承的protected成员
    	return 0;
    }

    output: 

    Person constructor
    Person is man
    calss function is covered: man
    Person is man
    ~Person deconstructor

    展开全文
  • C#——如何在派生类中引发基类事件 下面的简单示例演示用于在基类中声明事件,以便也可以从派生类引发它们的标准方法。 此模式广泛用于 .NET 类库中的 Windows 窗体类。 创建可以用作其他类的基类的类时,应考虑到...
  • 但有些情况下,需要在派生类中引用基类事件,实现方法是,在基类中定义一个受保护的方法引用事件,然后在派生类中重写基类方法,利用base关键字实现间接调用基类事件。 (2)派生类调用基类事件。 class ...
  • 对于普通方法,在派生类中用"."+"方法名"的方式调用基类的方法,例如: 在基类中定义了一个do_something方法 #基类 func do_something(): print("parent:do something") 在子类中调用它: func a_...
  • 创建可用作其他类的基类的类时,应考虑如下事实:事件是特殊类型的委托,只可以从声明它们的类中调用派生类无法直接调用基类中声明的事件。尽管有时需要事件仅由基类引发,但大多数情形下,应该允许派生类调用...
  • base关键字,用于从派生类中访问基类的成员。换言之,是用来“访问基类的” 一 调用基类上已被其他方法重写的方法。 二 指定创建派生类实例时应调用的基类构造函数。  base使用通用规则: ①尽量少用或者不用...
  • 调用基类上已被其他方法重写的方法。 指定创建派生类实例时应调用的基类构造函数。 基类访问只能构造函数、实例方法或实例属性访问器中...通过使用 base 关键字,可以从派生类中调用基类上的 Getinfo 方法。...
  • //base 关键字用于从派生类中访问基类的成员: //调用基类上已被其他方法重写的方法。 //指定创建派生类实例时应调用的基类构造函数。 //基类访问只能构造函数、实例方法或实例属性访问器中进行。 using ...
  • C# 编程指南如何:引发派生类中的基类事件(C# 编程指南) 以下简单示例演示了在基类中声明可从派生类引发事件标准方法。此模式广泛应用于 .NET Framework 基类库中 Windows 窗体类。创建可用作其他类...
  • 具体方法见:C++中使用基类指针调用派生类中定义的方法 核心代码: A *p = new B; dynamic_cast<B*>(p)->func(); // cast A* to B* 不转换找不到的原因:基类空间内不存在该函数,虚表内也不存在。只存在...
  • 如何:引发派生类中的基类事件(C# 编程指南) 以下简单示例演示了基类中声明可从派生类引发的事件的标准方法。此模式广泛应用于 .NET Framework 基类库中的 Windows 窗体类。创建可用作其他类的基类的类时,...
  • 通过基类指针调用派生类中的方法动态绑定静态绑定作用域掩盖dynamic_cast<>动态转型的作用区分接口继承和实现继承 动态绑定 动态类型指“目前所指对象的类型”; 动态绑定是指执行期间(非编译期)判断所...
  •   基类指向派生类的指针即将派生类对象赋给基类指针,如果输出的话,调用的方法是基类的方法,输出的是基类在派生类中的成员(想要通过基类指针调用那些只有派生类才有的成员将会产生语法错误 ...
  • 阅读[url=http://blogs.msdn.com/ericlippert/]Eric Lippertblog[/url]时,我无意了解到了很多我以前所不熟悉知识,例如说一些语言特性,一些编程思想之;但更有趣,我了解到了很多他所负责产品中的...
  • 从VSTS自动生成的上面访问器代码来看,已经有私有字段及方法的封装,实际单元测试的访问器能见到受测的私有方法及字段(智能感知出得来),如基类的_ctlBillErrorTips,然而单元测试方法访问到_accessor._...
  • Q:C++:派生类中重定义基类的成员函数与虚函数区别哪里? A:这涉及到多态的问题。 比如说你有一个基类BASE,有一个派生类Derived继承自BASE 两个类都有一个叫做fun的方法 然后你创建一个子类对象,但是用父类的...
  • 所谓隐藏是指使用常规的调用方法,派生类对象访问这个函数时,会优先访问派生类中的这个函数,基类这个函数对派生类对象来说是隐藏起来。 但是隐藏并不意味这不存在或完全不可访问。通过 b->Base::func()访问...
  • C# 基类 派生类 方法隐藏 方法重写

    千次阅读 2014-08-30 23:03:02
    二者都是在派生类中定义了与基类中相同的方法,相同点派生类对象将执行各自的派生类中的方法,不同点,在向上转型后,重写基类方法的调用的是派生类的方法,而隐藏基类调用的是基类的方法,具体实验代码: ...
  • 从外部看来,派生类是一个与基类具有相同接口的新类,或许还会有一些额外的的方法和域 ...对基类的子对象初始化时至关重要的,而且也只有一种方法来保证这一点,那就是在派生类的构造器中调用基类的构造器,而基类的...
  • 关于如何在派生类的虚函数中调用被覆盖掉的同名基类的虚函数,即Java中的super在C++中的使方法 Posted on 2009-03-25 23:00 魔のkyo 阅读(89) 评论(0) 编辑收藏 引用 很久没写BLOG了,这是在设计实现中遇到的一...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,428
精华内容 571
关键字:

在派生类中调用基类的方法