抽象方法与虚方法

合集下载

面向对象分析与设计简答题

1、什么面向对象?面向对象不仅是以些具体的软件开发技术与策略，而且以一套关于如何看待软件系统与现实世界的关系，以什么观点来研究问题并进行求解，以及如何进行系统构造的软件方法学。

2、软件开发方法学的基本方法有哪些？1）软件工程和瀑布方法学2）新方法学：螺旋式、迭代式、递增式、合并式3）面向对象方法学：UML、RUP、XP3、为什么需要OOA OOD00A就是运用面向对象的方法进行需求分析，00A加强了对问题域和系统责任的理解，有利于人员之间的交流，对需求变化的适应性较强，很好的支持软件复用。

00D就是运用面向对象的方法进行系统设计，00D •符合人们习惯的思维方法，便于分解大型的复杂多变的问题；易于软件的维护和功能的增减；可重用性好；与可视化技术相结合，改善了工作界面。

4、从概念层次、规格层次、实现层次三个角度如何理解对象的概念？从概念层次来看，一个对象就是一系列的责任；从规格层次来看，一个对象是一系列可以被其他对象或该对象自己调用的方法；从实现层次来看，一个对象是一些代码和数据。

5、如何绘制类图和对象图？简述其步骤。

类图绘制：1发现类，找到备选类，确定候选类2关联分析，确定关联关系，多重性分析3职责分析4限定与修改，导航性分析，约束，限定符；对象图绘制：1发现类和对象2对其细化，分析，确定关系。

6、简述重定义方法与重载的区别。

重定义：1参数列表必须完全与被重写的方法相同2返回类型必须一直域被重写的方法的类型相同3访问修饰符的限制一定要大于被重写方法的访问修饰符4重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查性异常：重载：1必须有不同参数列表2可以有不同的返回类型，只要参数列表不同即可3可有不同访问修饰符4可抛出不同的异常。

7、简述抽象方法与虚方法的联系与区别虚方法有一个实现部分可以为子类实现有共同的方法，并为派生提供了覆盖该方法的选，抽象方法只是强制派生覆盖方法；抽象方法只能在抽象类中声明，而虚方法不是；抽象方法不能声明方法实体，虚方法可以；包含抽象方法的类不能实例化，但虚方法可以。

C#中Abstract与Virtual的区别和联系

C#中Abstract与Virtual的区别和联系一：联系、1 Virtual和Abstract都是用来修饰父类的，通过覆盖父类的定义，让子类重新定义注：如果用来修饰方法，前面必须添加public，要不然就会出现编译错误！原因：虚拟方法或抽象方法是不能私有的。

毕竟加上Virtual或Abstract就是让子类重新定义的，而private成员是不能被子类访问的二：区别1 Virtual修饰的方法必须有实现（没有内容，可以用一对空的大括号），即便它是在Abstract类中定义的方法，而Abstract修饰的方法一定不能实现。

2 Abstract方法只能在抽象类中声明，Virtual方法则不一定。

例如：public class Base1{public virtual void fun1 (){Console.WriteLine("A"); // virtual修饰的方法必须有实现}}public abstract class Base2{public abstract void fun2 (); // abstract 修饰的方法一定不能实现// 且只能在抽象类中声明public virtual void fun3 () {…}// abstract类中定义的virtual方法法必// 须有实现}3 无法创建Abstract类的实例，只能被继承无法实例化。

例如：Base2 base = new Base2(); //错误! 无法创建Abstract类的实例4 Virtual方法可以实现多态，而Abstract方法不可以5 Virtual的使用会有两种情况：情况1：在基类中定义了Virtual方法，但在派生类中没有重写该虚方法。

那么在对派生类实例的调用中，该虚方法使用的是基类定义的方法。

情况2：在基类中定义了Virtual方法，然后在派生类中使用override重写该方法。

那么在对派生类实例的调用中，该虚方法使用的是派生重写的方法。

C#中Abstract、Virtual和Override的使用及区别

C#中Abstract、Virtual和Override的使⽤及区别1. abstract 修饰符指⽰所修饰的内容缺少实现或未完全实现。

abstract修饰符可⽤于类、⽅法、属性、索引器和事件。

在类声明中使⽤abstract修饰符以指⽰某个类只能是其他类的基类。

标记为抽象或包含在抽象类中的成员必须通过从抽象类派⽣的类来实现。

(1)抽象类具有以下特性：1) 抽象类不能实例化。

2) 抽象类可以包含抽象⽅法和抽象访问器。

3) 不能⽤sealed修饰符修饰抽象类，因为这两个修饰符的含义是相反的。

采⽤sealed修饰符的类⽆法继承，⽽abstract修饰符要求对类进⾏继承。

4) 从抽象类派⽣的⾮抽象类必须包括继承的所有抽象⽅法和抽象访问器的实际实现。

5) 在⽅法或属性声明中使⽤abstract修饰符以指⽰⽅法或属性不包含实现。

(2)抽象⽅法具有以下特性：1) 抽象⽅法是隐式的虚⽅法。

2) 只允许在抽象类中使⽤抽象⽅法声明。

3) 因为抽象⽅法声明不提供实际的实现，所以没有⽅法体；⽅法声明只是以⼀个分号结束，并且在签名后没有⼤括号({ })。

(3)在抽象⽅法声明中使⽤static或virtual修饰符是错误的。

除了在声明和调⽤语法上不同外，抽象属性的⾏为与抽象⽅法⼀样。

在静态属性上使⽤abstract修饰符是错误的。

在派⽣类中，通过包括使⽤override修饰符的属性声明，可以重写抽象的继承属性。

publicabstractclassparent{protectedintx=100;protectedinty = 200;publicabstractvoidfunction();publicabstractintX {get; }publicabstractintY {get; }}publicclassnewperson:parent{publicoverridevoidfunction(){x++;y++;}publicoverrideintX{get{returnx+100; }}publicoverrideintYget{returny+100; }}}staticvoidMain(string[] args){newpersonp =newnewperson();Console.WriteLine(p.X);Console.WriteLine(p.Y);p.function();Console.WriteLine(p.X);Console.WriteLine(p.Y);Console.ReadKey();}2.virtual关键字⽤于修饰⽅法、属性、索引器或事件声明，并使它们可以在派⽣类中被重写。

虚方法

this和base关键字：this可以访问当前类中定义的字段,属性和方法，有没有this都可以访问，有this可以让IDE-VS编译器给出提示，另外当方法的参数跟字段重名的时候，使用this可以表明访问的是类中的字段，base可以调用父类中的公有方法和字段,有没有base都可以访问，但是加上base.IED工具会给出提示，把所有可以调用的字段和方法罗列出来方便选择
虚方法（虚函数，也叫重写函数）：把一个基类函数声明为virtual,就可以在任何派生类中重写该函数，在派生类中重写另外一个函数时，要使用override关键字显示声明。我们在子类里面重写虚函数之后，不管在哪里调用都是调用重写之后的方法
隐藏方法：如果签名（方法的参数，返回的数据类型，方法名）相同的方法在基类和派生类中都进行了声明，但是该方法没有分别声明为virtual和override，派生类就会隐藏基类方法。（要

多态的三种手段

多态的三种⼿段⽤virtual修饰的⽅法叫做虚⽅法虚⽅法可以在⼦类中通过override关键字来重写常见的虚⽅法：ToString() Equalsc#基础多态的三种⼿段多态的概念概念:让⼀个对象能够表现出多种的状态(类型)实现多态的3种⼿段：1、虚⽅法 2、抽象类 3、接⼝关于虚⽅法需要注意的⼏点：1.⽗类中如果有⽅法需要让⼦类重写，则可以将该⽅法标记为virtual2.虚⽅法在⽗类中必须有实现，哪怕是空实现。

3.虚⽅法⼦类可以重写（override），也可以不重写关于抽象⽅法注意的⼏点:1.需要⽤abstract关键字标记2.抽象⽅法不能有任何⽅法实现。

3.抽象成员必须包含在抽象类中。

4.由于抽象成员没有任何实现，所以⼦类必须将抽象成员重写。

5.抽象类不能实例化，抽象类的作⽤：抽象类的作⽤就是为了让⼦类继承。

6.抽象类中可以包括抽象成员，可以包括有具体代码的成员。

7. 还有抽象⽅法不能⽤static修饰1.接⼝中只能包含⽅法（属性、事件、索引器也都是⽅法）2.接⼝中的成员都不能有任何实现。

光说不做3.接⼝不能被实例化。

4.接⼝中的成员不能有任何访问修饰符。

（默认为public）5.实现接⼝的⼦类必须将接⼝中的所有成员全都实现。

6.⼦类实现接⼝的⽅法时，不需要任何关键字，直接实现即可。

7.接⼝存在的意义就是为了多态。

//1.虚⽅法⽤virtual修饰的⽅法叫做虚⽅法虚⽅法可以在⼦类中通过override关键字来重写常见的虚⽅法：ToString() Equals//1)、虚⽅法//步骤：//1、将⽗类的⽅法标记为虚⽅法，使⽤关键字 virtual，这个函数可以被⼦类重新写⼀个遍。

public class Employee{public virtual void DaKa(){Console.WriteLine("九点打卡");}}public class Manager : Employee{public override void DaKa(){Console.WriteLine("经理11点打卡");}}public class Programmer : Employee{public override void DaKa(){Console.WriteLine("程序猿不打卡");}}//抽象类1//2)、抽象类//当⽗类中的⽅法不知道如何去实现的时候，可以考虑将⽗类写成抽象类，将⽅法写成抽象⽅法。

c#复习资料2013(带答案)(总)

11.1、公共语言运行库即( )。

A、CRLB、CLRC、CRRD、CLS1.2、.NET平台是一个新的开发框架。

( )是.NET的核心部分。

A、C#B、.NET FrameworkC、D、操作系统1.3、项目文件的扩展名是( )。

A、csprojB、csC、slnD、suo1.4、利用C#开发应用程序，通常有三种类型，不包括( ) 。

A、控制台应用程序B、Web应用程序C、SQL程序D、Windows程序1.5、运行C#程序可以通过按 ( ) 键实现A、F2B、F5C、F8D、F91.6 C#中导入某一命名空间的关键字是( )。

A. usingB. useC. includeD. import1.7 C#语言程序执行时从( )的第一行开始A、Main( )B、classC、namespaceD、using1.6、简述面向对象程序设计的特点.P21.7、简述类与对象的关系.p322.1、下列标识符不合法的是: 。

A、abcB、abc123C、abc-1D、a3b2.2、转义字符不可以表示。

A、任何字符B、字符串C、字母D、小数点2.3、从值类型转换到引用类型称为____A、继承B、拆箱C、装箱D、转换2.4、下列值类型的数据精度最高的是 ____ 。

A、intB、floatC、decimalD、ulong2.5、在C#中，下列常量定义正确的是____A 、const double PI 3.14；B、const double PI=3.14;C、 define double PI 3.14;D、define double PI=3.14;2.6在C#中定义一个数组，正确的代码为____A、int arr=new int [5];B、int [] arr=new int [5];C、int arr =new int [ ];D、int [5] arr=new int [];2.7以下类型中，不属于值类型的是____。

抽象方法（abstractmethod）和虚方法（virtualmethod）,重载（ov。。。

抽象⽅法（abstractmethod）和虚⽅法（virtualmethod）,重载（ov。

1. 抽象⽅法 (abstract method)在抽象类中，可以存在没有实现的⽅法，只是该⽅法必须声明为abstract抽象⽅法。

在继承此抽象类的类中，通过给⽅法加上override关键字来实现此⽅法. 由于该abstract method (抽象⽅法)是没有实现的⽅法，所以在⼦类中必须使⽤override关键字来重写此⽅法抽象⽅法不提供⾃⾝的实现，并且强制⼦类重写2. 虚⽅法 (virtual method)2.1 虚⽅法，⼦类可以选择性重写此⽅法(⽤override关键字重写),也可以不重写. 它不像抽象⽅法，⼦类必须重写(如果⼦类不重写，那么⼦类也必须是抽象类)2.2 虚⽅法可以有实体，所以可以直接调⽤public virtual void Vt(){Console.WriteLine("this is virtual method");}2.3 虚⽅法可以实现多态。

⽽抽象⽅法不可以虚⽅法提供⾃⾝的实现，并且不强制要求⼦类重写3. 重载应该叫overload, 重写叫override重载 (overload)某个⽅法是在同⼀个类中发⽣重写 (override) 就是在⼦类中重写⽗类中的⽅法3.1 重写(override)是⽤于重写基类的虚⽅法, 这样在派⽣类中提供⼀个新的⽅法⽗类: public virtual string ToString(){return "a";}⼦类 public override string ToString() {return "b";}3.2 重载(overload)是提供⼀种机制，相同函数名通过不同的返回值类型以及参数列表来区分的机制public string ToString(){return "a";}public string ToString(int id){return id.ToString();}很明显的区别---函数特征：重写(override)的两个函数的函数特征相同, 或者说有相同的函数签名重载(overload)的两个函数的函数名虽然相同，但函数特征不同 (函数特征包括函数名，返回值类型, 参数的类型和个数)。

什么是抽象方法

什么是抽象方法
在面向对象编程语言中抽象方法指一些只有方法声明，而没有具体方法体的方法。

抽象方法一般存在于抽象类或接口中。

没有具体功能的实现，通过子类继承后重写方法来实现一定约束的类称之为抽象类，抽象类必须被abstract修饰。

抽象方法就是只有方法声明，没有方法体的方法。

抽象类的使用一般通过继承来实现。

抽象类：抽象类就是不能使用new方法进行实例化的类，即没有具体实例对象的类，抽象类有点类似于“模板”的作用,目的是根据其格式来创建和修改新的类，对象不能由抽象类直接创建，只可以通过抽象类派生出新的子类，再由其子类来创建对象，当一个类被声明为抽象类时，要在这个类前面加上修饰符abstract,在抽象类中的成员方法可以包括一般方法和抽象方法。

抽象方法：抽象方法就是以abstract修饰的方法，这种方法只声明返回的数据类型，方法名称和所需要的参数，没有方法体，也就是说抽象方法只需要声明而不需要事先，当一个方法为抽象方法时，意味着这个方法必须被子类的方法所重写，否则其子类的该方法仍然是abstract的，而这个子类也必须是抽象的，即声明为abstract。

两者联系：抽象类中不一定包含抽象方法，但是包含抽象方法的类一定要被声明为抽象类，抽象类本身不具备实际的功能，只能用于派生其子类，抽象类中可以包含构造方法，但是构造方法不能被声明为抽象，抽象类不能用final来修饰，即一个类不能既是最终类又是抽象类，abstract不能与private，static,final,native 并列修饰同一个方法。

虚方法（virtual）和抽象方法（abstract）的区别

虚⽅法（virtual）和抽象⽅法（abstract）的区别虚⽅法和抽象⽅法都可以供派⽣类重写，它们之间有什么区别呢？1. 虚⽅法必须有实现部分，抽象⽅法没有提供实现部分，抽象⽅法是⼀种强制派⽣类覆盖的⽅法，否则派⽣类将不能被实例化。

如：//抽象⽅法public abstract class Animal{public abstract void Sleep();public abstract void Eat();}//虚⽅法public class Animal{public virtual void Sleep(){}public virtual void Eat(){}}2. 抽象⽅法只能在抽象类中声明，虚⽅法不是。

其实如果类包含抽象⽅法，那么该类也是抽象的，也必须声明为抽象的。

如：public class Animal{public abstract void Sleep();public abstract void Eat();}编译器会报错：Main.cs(10): 'VSTest.Animal.Sleep()' is abstract but it is contained in nonabstract class 'VSTest.Animal'Main.cs(11): 'VSTest.Animal.Eat()' is abstract but it is contained in nonabstract class 'VSTest.Animal'3. 抽象⽅法必须在派⽣类中重写，这⼀点跟接⼝类似，虚⽅法不必。

如：public abstract class Animal{public abstract void Sleep();public abstract void Eat();}public class Cat : Animal{public override void Sleep(){Console.WriteLine( "Cat is sleeping" );}// we need implement Animal.Eat() here}编译器会报错：Main.cs(14): 'VSTest.Cat' does not implement inherited abstract member 'VSTest.Animal.Eat()'，因为我们没有实现抽象类中所有抽象⽅法。

第10单元使用虚方法和抽象方法实现多态

第10单元使用虚方法和抽象方法实现多态【能力目标】1．学会使用虚方法和覆盖技术实现多态；2．学会使用抽象方法和覆盖技术实现多态。

【学时】2学时多态是指两个或多个属于不同类的对象对同一个消息做出不同响应的能力。

使用虚方法实现多态例1：class A{public virtual void F(){Console.WriteLine("A.F");}}class B : A{public override void F(){Console.WriteLine("B.F");}}class Test{static void Main(string[] args){B b = new B();A a = b;//类型转换a.F();b.F();Console.ReadLine();}}例2：class A{public virtual void F(){Console.WriteLine("A.F");}}class B : A{public override void F(){Console.WriteLine("B.F");}}class C : B{public override void F(){Console.WriteLine("C.F");}}class Test{static void Main(string[] args){C c = new C();A a = c;B b = c;a.F();b.F();c.F();Console.ReadLine();}}例3：class Employee{protected string _name;public Employee() { }public Employee(string name){_name = name;}public virtual void StartWork(){Console.Write(_name + "开始工作：");}}class Manager:Employee{public Manager (string name):base(name) {}public override void StartWork(){base.StartWork();Console.WriteLine ("给员工下达任务");}}class Secretary:Employee{public Secretary (string name):base(name){}public override void StartWork(){base.StartWork();Console .WriteLine ("协助经理");}}class Seller:Employee{public Seller (string name):base(name){}public override void StartWork(){base.StartWork();Console .WriteLine ("销售产品");}}class Accountant: Employee{public Accountant(string name) : base(name) { } public override void StartWork(){base.StartWork();Console.WriteLine("管理公司财政");}}class Test{static void Main(string[] args){Employee[] emp = new Employee[5];emp[0] = new Manager("张三");emp[1] = new Secretary("李四");emp[2] = new Seller("王五");emp[3] = new Seller("马六");emp[4] = new Accountant("钱七");Console.WriteLine("早上8点，开始工作"); foreach (Employee e in emp){e.StartWork();}Console.ReadLine();}}使用抽象方法实现多态例1：抽象类不能实例化abstract class A{}class Test{static void Main(string[] args){A a =new A();//无法创建抽象类的实例Console.ReadLine();}}例2：抽象类可以被继承abstract class A{}class B : A{}class Test{static void Main(string[] args){B b =new B();Console.ReadLine();}}抽象类确定了子类的基本结构和意义，从而使程序框架更容易建立。

什么是抽象方法

什么是抽象方法
抽象方法是指在父类中声明但没有实现的方法，它只有方法的声明，而没有方
法体。

抽象方法的存在意味着该方法必须在子类中被实现，否则子类也必须声明为抽象类。

在Java中，使用关键字“abstract”来声明一个抽象方法，而在C++中，
使用纯虚函数来实现抽象方法的声明。

抽象方法的存在使得父类能够定义一些通用的行为，而具体的实现则交由子类
来完成。

这样一来，就能够实现多态性，即不同的子类可以根据自身的特点来实现相同的抽象方法，从而实现不同的行为。

另外，抽象方法也能够实现接口的规范，确保子类必须实现某些特定的方法，从而提高了程序的可靠性和可维护性。

在实际应用中，抽象方法通常与抽象类或接口一起使用。

抽象类是不能被实例
化的类，其中包含了抽象方法的声明，而具体的方法实现则由其子类来完成。

而接口则是一种特殊的抽象类，其中只包含了抽象方法的声明，而没有任何方法的实现。

通过使用抽象类和接口，程序设计者能够更好地组织和管理代码，提高代码的复用性和可扩展性。

除了实现多态性和接口规范外，抽象方法还能够提高程序的灵活性。

通过定义
抽象方法，程序设计者能够在不同的子类中实现不同的行为，从而更好地适应不同的需求。

这种灵活性使得程序更易于扩展和维护，能够更好地应对需求的变化。

总之，抽象方法是面向对象编程中的重要概念，它通过定义一些通用的行为，
使得程序能够更好地实现多态性、接口规范和灵活性。

通过合理地使用抽象方法、抽象类和接口，程序设计者能够更好地组织和管理代码，提高代码的可复用性和可扩展性，从而更好地满足不同的需求。

C#类和接口、虚方法和抽象方法及值类型和引用类型的区别

C#类和接口、虚方法和抽象方法及值类型和引用类型的区别1.C#类和接口的区别接口是负责功能的定义，项目中通过接口来规范类，操作类以及抽象类的概念！而类是负责功能的具体实现！在类中也有抽象类的定义，抽象类与接口的区别在于：抽象类是一个不完全的类，类里面有抽象的方法，属性，也可以有具体的方法和属性，需要进一步的专业化。

但接口是一个行为的规范，里面的所有东西都是抽象的！一个类只可以继承一个基类也就是父类，但可以实现多个接口PS：接口除了规范一个行为之外，在具体项目中的实际作用也是十分重要的，在面向对象的设计原则以及设计模式的使用中，无不体现作为一个接口的使用好处，最直接的就是设计原则中OCP（开放封闭原则），我们使用接口，而不需要关心他的具体实现，具体实现的细节变化也无关客户端（使用接口的类）的使用，对与扩展是开放的，我们可以另写一个接口的实现来扩展当前程序，而不影响上层的使用，但对修改是封闭的，即我们不能够再去修改接口的定义，当然这个“不能够”是指在规范原则上不应该这么做！2.抽象类和接口的区别答：抽象类（abstract class）可以包含功能定义和实现，接口（interface）只能包含功能定义抽象类是从一系列相关对象中抽象出来的概念，因此反映的是事物的内部共性；接口是为了满足外部调用而定义的一个功能约定，因此反映的是事物的外部特性分析对象，提炼内部共性形成抽象类，用以表示对象本质，即“是什么”为外部提供调用或功能需要扩充时优先使用接口3. C#语言中，值类型和引用类型有何不同?答：值类型和引用类型的区别在于，值类型的变量直接存放实际的数据，而引用类型的变量存放的则是数据的地址，即对象的引用。

值类型变量直接把变量的值保存在堆栈中，引用类型的变量把实际数据的地址保存在堆栈中，而实际数据则保存在堆中。

注意，堆和堆栈是两个不同的概念，在内存中的存储位置也不相同，堆一般用于存储可变长度的数据，如字符串类型;而堆栈则用于存储固定长度的数据，如整型类型的数据int(每个int变量占用四个字节)。

java虚类定义例子

java虚类定义例子在Java中，接口和抽象类是面向对象编程中非常重要的概念。

虚类（virtual class）是一种特殊的抽象类，它允许子类覆盖或实现其成员方法。

本文将介绍虚类的概念、虚方法与抽象方法的区别，并通过两个例子演示如何使用虚类实现多态和动物的继承关系。

1.虚类的概念与作用虚类是一种特殊的抽象类，它允许子类通过继承来实现多态。

多态是面向对象编程的核心思想之一，它使得父类对象可以以不同的方式进行实例化，从而表现出不同的行为。

虚类的主要作用是在继承关系中实现多态，让子类可以根据自己的需求覆盖或实现父类的成员方法。

2.虚方法与抽象方法的区别在Java中，虚方法是指在父类中声明，允许子类覆盖的方法。

子类可以通过重写（override）父类的虚方法来实现多态。

而抽象方法是指在父类中声明，但不提供方法体，要求子类必须覆盖的方法。

抽象方法不能直接实例化，必须与具体的方法一起构成一个完整的类。

3.示例：使用虚类实现多态以下是一个使用虚类实现多态的例子：```java// 父类Animalclass Animal {virtual void makeSound() {System.out.println("动物发出声音");}}// 子类Dogclass Dog extends Animal {void makeSound() {System.out.println("狗发出汪汪声");}}// 子类Catclass Cat extends Animal {void makeSound() {System.out.println("猫发出喵喵声");}}public class Main {public static void main(String[] args) {Animal animal = new Animal();animal.makeSound(); // 输出：动物发出声音Dog dog = new Dog();dog.makeSound(); // 输出：狗发出汪汪声Cat cat = new Cat();cat.makeSound(); // 输出：猫发出喵喵声}}```在这个例子中，我们定义了一个父类Animal，其中包含一个虚方法makeSound()。

C#多态性--关键字Abstract和Virtual

C#多态性--关键字Abstract和Virtual多态性意味着有多重形式。

在⾯向对象编程范式中，多态性往往表现为"⼀个接⼝，多个功能"。

多态性可以是静态的或动态的。

在静态多态性中，函数的响应是在编译时发⽣的。

在动态多态性中，函数的响应是在运⾏时发⽣的。

静态多态性在编译时，函数和对象的连接机制被称为早期绑定，也被称为静态绑定。

C# 提供了两种技术来实现静态多态性。

分别为：函数重载运算符重载动态多态性关键字： Abstract抽象⽅法：在基类中定义的并且必须在派⽣类中重写的⽅法，使⽤ abstract 关键字定义。

您不能创建⼀个抽象类的实例。

您不能在⼀个抽象类外部声明⼀个抽象⽅法。

通过在类定义前⾯放置关键字 sealed，可以将类声明为密封类。

当⼀个类被声明为 sealed 时，它不能被继承。

抽象类不能被声明为sealed。

1namespace FirstCode.EX12 {3abstract public class Shape4 {5abstract public int area();6 }7 }1namespace FirstCode.EX12 {3public class Rectangle : Shape4 {5public int width;6public int length;78public Rectangle(int a,int b)9 {10 width =a;11 length = b;12 }13public override int area()=>width*length;1415 }16 }1namespace FirstCode2 {3class Program4 {5static void Main(string[] args)6 {7 Rectangle rect1 = new Rectangle(2,3);8 Console.WriteLine("矩形的⾯积："+rect1.area().ToString());9 }10 }11 }关键字：Virtual虚⽅法：即为基类中定义的允许在派⽣类中重写的⽅法，使⽤virtual关键字定义。

纯虚函数和抽象类

纯虚函数和抽象类纯虚函数和抽象类定义注意抽象类不能创建对象,但是可以定义⼀个指针注意抽象类不能有任何成员结构, 成员函数必须协成纯虚函数,virtual 返回值函数名(参数列表)=0注意含有纯虚函数的类被称为抽象类。

抽象类只能作为派⽣类的基类，不能定义对象，但可以定义指针。

在派⽣类实现该纯虚函数后，定义抽象类对象的指针，并指向或引⽤⼦类对象。

1）在定义纯虚函数时，不能定义虚函数的实现部分；2）在没有重新定义这种纯虚函数之前，是不能调⽤这种函数的。

抽象类的唯⼀⽤途是为派⽣类提供基类，纯虚函数的作⽤是作为派⽣类中的成员函数的基础，并实现动态多态性。

继承于抽象类的派⽣类如果不能实现基类中所有的纯虚函数，那么这个派⽣类也就成了抽象类。

因为它继承了基类的抽象函数，只要含有纯虚函数的类就是抽象类。

纯虚函数已经在抽象类中定义了这个⽅法的声明，其它类中只能按照这个接⼝去实现。

抽象类实例计算图形⾯积#include <iostream>using namespace std;// 重点// ⾯向抽象类编程(⾯向⼀套预先定义好的接⼝编程)// 解耦合。

模块的划分class Figure // 抽象类{public:// 约定⼀个统⼀的界⾯(接⼝) 让⼦类使⽤，让⼦类必须去实现virtual void getArea() = 0; // 纯虚函数protected:private:};class Circle : public Figure {public:Circle(int a, int b) {this->a = a;this->b = b;}virtual void getArea() {cout << "圆的⾯积\t" << 3.14 * a * a << endl;}protected:private:int a;int b;};class Sanjiao : public Figure {public:Sanjiao(int a, int b) {this->a = a;this->b = b;}virtual void getArea() {cout << "三⾓形的⾯积\t" << a * b / 2 << endl;}protected:private:int a;int b;};class Squre : public Figure {public:Squre(int a, int b) {this->a = a;this->b = b;}virtual void getArea() {cout << "四边形的⾯积\t" << a * b << endl;}protected:private:int a;int b;};void PlayObj(Figure *base) {base->getArea(); // 会发⽣多态}int main() {// Figure f1; // 抽象类不能被实例化Figure *base = NULL;Circle c1(1, 2);Squre sq(1, 2);Sanjiao s1(2, 4);PlayObj(&c1);PlayObj(&s1);PlayObj(&sq);return0;}抽象类编程例⼦⼀计算程序员⼯资忘记了⼿动调⽤delete,让其调⽤析构函数⽐较好第⼆个有点错误, 不能说是抽象类#include <iostream>using namespace std;/*编写⼀个c++程序计算程序员⼯资(programer)1要求：能计算出初级程序员⼯资(junior_programer),中级程序员(mid_programer),⾼级程序员(Adv_progreamer) 2要求利⽤抽象类统⼀界⾯(⽅便程序拓展)，⽐如新增计算架构师architect的⼯资*/// 程序员抽象类class programer{public:virtual void getSal() = 0; // 抽象类接⼝};// 初级程序员class junior_programer: public programer{public:junior_programer(char *name, char *job, int sal) // 浅拷贝{this->name = name;this->job = job;this->sal = sal;}virtual void getSal() // 接⼝类实现{cout << "name = " << name << "\tjob = " << job << "\tsal = " << sal << endl;}private:char *name;char *job;int sal;};// 中级程序员class mid_programer: public programer{public:mid_programer(char *name, char *job, int sal) // 浅拷贝{this->name = name;this->job = job;this->sal = sal;}virtual void getSal() // 接⼝类实现{cout << "name = " << name << "\tjob = " << job << "\tsal = " << sal << endl;}private:char *name;char *job;int sal;};// ⾼级程序员class Adv_programer: public programer{public:Adv_programer(char *name, char *job, int sal) // 浅拷贝{this->name = name;this->job = job;this->sal = sal;}virtual void getSal() // 接⼝类实现{cout << "name = " << name << "\tjob = " << job << "\tsal = " << sal << endl;}private:char *name;char *job;int sal;};// 后来增加的架构师类class architect: public programer{public:architect(char *name, char *job, int sal) // 浅拷贝{this->name = name;this->job = job;this->sal = sal;}virtual void getSal() // 接⼝类实现{cout << "name = " << name << "\tjob = " << job << "\tsal = " << sal << endl;}private:char *name;char *job;int sal;};// 计算函数，简单框架void jisuan(programer *base){base->getSal();}// 引⽤void jisuan(programer &base){base.getSal();}int main(){junior_programer junior("张三", "初级", 5000);mid_programer mid("李四", "中级", 10000);Adv_programer adv("王五", "⾼级", 15000);// 系统扩展增加代码架构师⼯资architect arc("康总", "架构师", 30000);jisuan(&junior);jisuan(&mid);jisuan(&adv);jisuan(&arc);cout << endl;// 引⽤类型auto &i = junior;auto &j = mid;auto &k = adv;auto &l = arc;jisuan(i);jisuan(j);jisuan(k);jisuan(l);return0;}别⼈的的⽅式//编写⼀个c++程序计算程序员⼯资(programer)//1要求：能计算出初级程序员⼯资(junior_programer),中级程序员(mid_programer),⾼级程序员(Adv_progreamer) //2要求利⽤抽象类统⼀界⾯(⽅便程序拓展)，⽐如新增计算架构师architect的⼯资#include <iostream>#include <cstring>using namespace std;// 定义程序员类, 抽象类class Programer {virtual double getSal() = 0;};class Junior : Programer {public:Junior(char *name = NULL, char *job = NULL, double sal = 7000) {auto len = strlen(name);this->name = new char[len + 1];strcpy(this->name, name);len = strlen(job);this->job = new char[len + 1];strcpy(this->job, job);this->sal = sal;}virtual ~Junior() {delete[]name;delete[]job;sal = 0;name = NULL;job = NULL;cout << "j" << endl;}virtual double getSal() {cout << this->name << " : " << this->job << ": " << this->sal << endl; }public:char *name;char *job;double sal;};class Mid : public Junior {public:Mid(char *name = NULL, char *job = NULL, double sal = 10000): Junior(name, job, sal) {}virtual ~Mid() // 会默认调⽤⽗类的析构函数{cout << "m" << endl;}};// ⾼级的class Adv : public Junior {public:Adv(char *name = NULL, char *job = NULL, double sal = 10000): Junior(name, job, sal) {}virtual ~Adv() // 会默认调⽤⽗类的析构函数{cout << "Adv" << endl;}};void print(Junior &obj) {obj.getSal();}int main() {Junior j("张三", "初级", 5000);Mid m("李四", "中级", 10000);Adv a("王五", "⾼级", 15000);print(j);print(m);print(a);return0;}⾃⼰的另⼀种写法抽象类编程动物园类#if 0// main.cpp#define _CRT_SECURE_NO_WARNINGS #include <iostream>#include "Animal.h"#include "Dog.h"#include "Cat.h"#include "Dog.cpp"#include "Cat.cpp"#include "Animal.cpp"using namespace std;int main(void){letAnimalCry(new Dog);letAnimalCry(new Cat);#if 0Animal *dog = new Dog;letAnimalCry(dog);delete Dog;#endifreturn0;}#endif// -- Animal.h#if 0#pragma once#define _CRT_SECURE_NO_WARNINGS #include <iostream>using namespace std;class Animal{public://纯虚函数，让⼦类继承并且实现virtual void voice() = 0;Animal();virtual ~Animal();};//架构函数//让动物叫void letAnimalCry(Animal *animal);#endif// Animal.cpp#if 0#include "Animal.h"inlineAnimal::Animal(){cout << "animal().." << endl;}inlineAnimal::~Animal(){cout << "~Animal()..." << endl;}inlinevoid letAnimalCry(Animal *animal){animal->voice();// 需要⼿动调⽤delete 让其调⽤析构函数if (animal != NULL) {delete animal;}}#endif// Dog.h------------------------#if 0#pragma once#include "Animal.h"class Dog : public Animal{public:Dog();~Dog();virtual void voice();};#endif// Dog.cpp#if 0#include "Dog.h"inlineDog::Dog(){cout << "Dog().." << endl;}inlineDog::~Dog(){cout << "~Dog().." << endl;}inlinevoid Dog::voice(){cout << "狗开始哭了， 555" << endl;}#endif// Cat.h#if 0#pragma once#include "Animal.h"class Cat : public Animal{public:Cat();~Cat();virtual void voice();};#endif// Cat.cpp#if 0#include "Cat.h"inlineCat::Cat(){cout << "cat().." << endl;}inlineCat::~Cat(){cout << "~cat().." << endl;}inlinevoid Cat::voice(){cout << "⼩猫开始哭了，66666" << endl; }#endif动物园电脑类实例:#define _CRT_SECURE_NO_WARNINGS #include <iostream>using namespace std;//-------- 抽象层---------//抽象CPU类class CPU {public:// CPU();virtual void caculate() = 0;};//抽象的card类class Card {public:virtual void display() = 0;};//抽象的内存类class Memory {public:virtual void storage() = 0;};//架构类class Computer {public:Computer(CPU *cpu, Card *card, Memory *mem) { this->cpu = cpu;this->card = card;this->mem = mem;}void work() {this->cpu->caculate();this->card->display();this->mem->storage();}~Computer() {if (this->cpu != NULL) {cout << "~cpu" << endl;delete this->cpu;}if (this->card != NULL) {cout << "~card"<<endl;delete this->card;}if (this->mem != NULL) {cout << "~mem"<<endl;delete this->mem;}}private:CPU *cpu;Card *card;Memory *mem;};// --------------------------//-----------实现层----------//具体的IntelCPUclass IntelCPU : public CPU {public:virtual void caculate() {cout << "Intel CPU开始计算了" << endl;}};class IntelCard : public Card {public:virtual void display() {cout << "Intel Card开始显⽰了" << endl;}};class IntelMem : public Memory {public:virtual void storage() {cout << "Intel mem开始存储了" << endl;};class NvidiaCard : public Card {public:virtual void display() {cout << "Nvidia 显卡开始显⽰了" << endl;}};class KingstonMem : public Memory {public:virtual void storage() {cout << "KingstonMem 开始存储了" << endl;}};//--------------------------void test(){Computer *com1 = new Computer(new IntelCPU, new IntelCard, new IntelMem); com1->work();delete com1; // 如果定义⼀个指针不要忘记释放}//--------业务层-------------------int main() {//1 组装第⼀台intel系列的电脑#if 0CPU *intelCpu = new IntelCPU;Card *intelCard = new IntelCard;Memory *intelMem = new IntelMem;Computer *com1 = new Computer(intelCpu, intelCard, intelMem);com1->work();Card *nCard = new NvidiaCard;Memory* kMem = new KingstonMem;Computer *com2 = new Computer(intelCpu, nCard, kMem);com2->work();delete intelCpu;#endif// Computer *com1 = new Computer(new IntelCPU, new IntelCard, new IntelMem); // com1->work();// delete com1; // 这⾥不要忘记释放test();return0;}这个好好看看圆类#define _CRT_SECURE_NO_WARNINGS#include <iostream>using namespace std;//抽象的图形类class Shape{public://打印出图形的基本你属性virtual void show() = 0;//得到图形的⾯积virtual double getArea() = 0;virtual ~Shape() {}};//圆类class Circle :public Shapepublic:Circle(double r) {this->r = r;}//打印出图形的基本你属性virtual void show() {cout << "圆的半径是 " << r << endl;}//得到图形的⾯积virtual double getArea() {cout << "获取圆的⾯积" << endl;return this->r*this->r *3.14;}~Circle() {cout << "圆的析构函数。

什么是方法

方法方法又称成员函数（Member Function），集中体现了类或对象的行为。

方法同样分为静态方法和实例方法。

静态方法只可以操作静态域，而实例方法既可以操作实例域，也可以操作静态域--虽然这不被推荐，但在某些特殊的情况下会显得很有用。

方法也有如域一样的5种存取修饰符--public，protected，internal，protected internal，private，它们的意义如前所述。

方法参数方法的参数是个值得特别注意的地方。

方法的参数传递有四种类型：传值（by value），传址（by reference），输出参数（by output），数组参数（by array）。

传值参数无需额外的修饰符，传址参数需要修饰符ref，输出参数需要修饰符out，数组参数需要修饰符params。

传值参数在方法调用过程中如果改变了参数的值，那么传入方法的参数在方法调用完成以后并不因此而改变，而是保留原来传入时的值。

传址参数恰恰相反，如果方法调用过程改变了参数的值，那么传入方法的参数在调用完成以后也随之改变。

实际上从名称上我们可以清楚地看出两者的含义--传值参数传递的是调用参数的一份拷贝，而传址参数传递的是调用参数的内存地址，该参数在方法内外指向的是同一个存储位置。

看下面的例子及其输出：using System;class Test{static void Swap(ref int x, ref int y){int temp = x;x = y;y = temp;}static void Swap(int x,int y){int temp = x;x = y;y = temp;}static void Main(){int i = 1, j = 2;Swap(ref i, ref j);Console.WriteLine("i = {0}, j = {1}", i, j);Swap(i,j);Console.WriteLine("i = {0}, j = {1}", i, j);}}程序经编译后执行输出：i = 2, j = 1我们可以清楚地看到两个交换函数Swap()由于参数的差别--传值与传址，而得到不同的调用结果。

C#复习资料

一、选择题1.CLR是一种（）A．程序设计语言B。

运行环境 C.开发环境 D. API编程接口2.C#语言源代码文件的后缀名为（）A..c# B .cc C. .csp D. 。

cs3.构建桌面应用程序需要.NET提供的类库是（）A．ADO。

NET B.Windows Form C.XML D.ASP。

NET4.与C++等语言相比，C#的简单性主要体现在（)A．没有鼓励的全局函数 B.没有指针C。

不能使用未初始化的变量D。

解决了“DLL地狱"5.C＃中导入某一命名空间的关键字是（）A．using B。

use C。

import D。

include6.C#中程序的入口方法名是(）A．Main B。

main C.Begin ing二、简答题1.C#语言的主要优势有哪些?2.如何看待C#、CLR和.NET之间的关系?3.VS2010平台如何有效地实现各类应用程序的管理？4.最常见的C＃项目有哪几类？简述创建他们的基本操作步骤?第二章C＃语言基础一、选择题1。

C#中的值类型包括三种，它们是（）A．整型、浮点型、基本类型B。

数值类型、字符类型、字符串类型C。

简单类型、枚举类型、结构类型 D.数值类型、字符类型、枚举类型、2。

C#的引用类型包括类、接口、数组、委托、object和string。

其中object(）根类A。

只是引用类型的 B.只是值类型的C.只是string类型的D。

是所有值类型和引用类型的3.浮点常量有三种格式,下面（）组的浮点常量都属于double类型.A。

0.618034, 0。

618034D， 6.18034E-1 B.0。

618034, 0.618034F, 0.0618034E1 C.0。

618034, 0.618034f, 0.618034M D。

0.618034F, 0。

618034D，0。

618034M 4。

下面字符常量表示有错误的一组是（）A。

’\\’，’\u0027’，’\x0027’B。