虚方法,重写————继承、多态、面向对象!

1、 this 不能直接调用 非static成员
class A
{
static public void M1()
{
Hello(); // 错误 在static成员中不能

直接调用非static成员
A a=new A();
a.Hello();
}
public void Hello()
{
F1 =10;
M1();
A.M1();
this.M1() //错误 不能调用
}
}

2、 静态类不能new;
静态类中不能声明非静态成员。

3、sealed 密闭类不能被继承

Fromwork

4、Paint 重绘控件
private void panel1_Paint(object

sender, PaintEventArgs e)
{
Graphics g = e.Graphics;
// g.Dispose();
}
重绘控件 不用释放。

5、画一个圆
g.DrawEllipse(Pens.Blue, 20, 50, 60, 80);

//椭圆 (边框颜色,左上角坐标(20,50

),宽度为60,高为80);
g.DrawRectangle(Pens.Blue, 20, 50, 60,

80);

6、int.Parse()与int.TryParse()
int i = -1;
bool b = int.TryParse(null, out i);
执行完毕后,b等于false,i等于0,而不是等于-1

,切记。
int i = -1;
bool b = int.TryParse("123", out i);
执行完毕后,b等于true,i等于123;

7、virtual 虚方法 与override(重写) 连用
class A
{
public virtual void M1()
{ }
}
class B:A
{
public override void M1()
{
Console.WriteLine("213");
}
}
Virtual关键字表示方法,使用Virtual关键字修

饰的方法,必须有实现{},子类可以重写

(override),也可以不重写。

注:方法重写时,方法签名必须与父类中的虚方法

完全一致,否则重写不成功,其中包括“返回值”

8、多态实例(面向对象)  virtual ,  override

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

namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("请输入姓名");
Person p = new Person();
p.Name = Console.ReadLine();
Console.WriteLine("请输入性别");
p.Sex = Console.ReadLine();
PersonBase pb = null;
if (p.Sex == "1")
{
pb = new Man(p);
}
else {
pb = new Woman(p);
}
pb.Show();
//Console.WriteLine();
Console.ReadLine();
}
}

class Person
{
public string Name { get; set; }
public string Age { get; set; }
public string Sex { get; set; }

}

class PersonBase
{
protected string Name;
public PersonBase(Person model)
{
this.Name = model.Name;
}
public virtual void Show()
{
Console.WriteLine(string.Format("{0}是人",Name));
}
}

class Man:PersonBase
{
public Man(Person model):base(model) { }
public override void Show()
{
Console.WriteLine(string.Format("{0}是男人", Name));
}
}

class Woman : PersonBase
{
public Woman(Person model):base(model) { }
public override void Show()
{
Console.WriteLine(string.Format("{0}是女人", Name));
}
}
}

时间: 2024-10-13 01:00:05

虚方法,重写————继承、多态、面向对象!的相关文章

多态,虚方法重写,抽象类,接口

简而言之就是龙生九子,各有不同 有了继承,才有了多态 1.虚方法 virtual重写 override 父类中的方法,在子类中并不适用,那么子类需要自主更改继承的方法或者是属性,那父类中加了virtual关键字的方法才可以被子类重写 子类重写父类的方法使用的是override关键字 using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace 多态 { public

虚方法重写

控制台程序 class Program { static void Main(string[] args) { DerivedType derivedInstance = new DerivedType(); string line; while ((line = Console.ReadLine()) != null) { Console.WriteLine("----"); } } } public class BadlyConstructedType { protected st

面向对象--多态、虚方法重写、抽象类、接口

多态: 一个父类有多个子类,每个子类都不尽相同 有了继承,才有了多态 虚方法:关键字 virtual 重写  override 父类中的方法在子类中并不适用,那么子类需要自主更改继承的方法或是属性, 父类中加了virtual关键字的方法才可以被子类重写,子类重写父类的方法使用的是override关键字 fly.cs中: namespace 多态 { public class fly { public virtual string fling() { return "拍翅膀飞"; } }

java的方法重写 ,多态和关键字 instanceof和final

package cn.pen; /*final 是一个java的关键字,用于修饰局部变量.属性.方法.类,表示最终的意思. final修饰类表示最终类,无法被继承.public final class Penguin{} final修饰符方法,方法就不能被重写.所以final修饰的是最终子类或最终类 final 修饰属性,经常和static搭配使用,形成静态常量.静态常量不能被改变 修饰变量final 修饰基本数据类型 ,表示a中的内容(值)不能被改变final int a = 10; fina

【继承与多态】C++:继承中的赋值兼容规则,子类的成员函数,虚函数(重写),多态

实现基类(父类)以及派生类(子类),验证继承与转换--赋值兼容规则: 子类对象可以赋值给父类对象(切割/切片) 父类对象不能赋值给子类对象 父类的指针/引用可以指向子类对象 子类的指针/引用不能指向父类对象(可以通过强制类型转换完成) #include<iostream> using namespace std; class People    //父类或者基类 { public:     void Display()     {         cout << "_na

oc-继承(inherit) 方法重写 继承与组合

重写:

面向对象:继承、抽象类、抽象方法、虚方法

1.继承什么是继承?目的:代码重用public class 子类:父类{ }父类 基类 被继承的类子类 派生类 需要继承的类 父类构造函数的继承创建子类对象时,先调用父类构造函数,再调用子类构造函数默认调用父类无参构造函数如果子类有无参构造函数,要求父类也有无参构造函数如果调用父类的有参构造函数,显式用base调用 public 子类(参数列表)base(实参)实参:要调用的父类的有参构造函数的参数列表{} base:父类对象(父类实例) 2.抽象abstract 抽象方法:访问修饰符 abst

浅谈C# 多态的魅力(虚方法,抽象,接口实现)

浅谈C# 多态的魅力(虚方法,抽象,接口实现) 分类:             asp.net             C#              2014-02-08 11:29     786人阅读     评论(0)     收藏     举报 浅谈C# 多态的魅力(虚方法,抽象,接口实现) 前言:我们都知道面向对象的三大特性:封装,继承,多态.封装和继承对于初学者而言比较好理解,但要理解多态,尤其是深入理解,初学者往往存在有很多困惑,为什么这样就可以?有时候感觉很不可思议,由此,面向

《转》 浅谈C# 多态的魅力(虚方法,抽象,接口实现)

前言:我们都知道面向对象的三大特性:封装,继承,多态.封装和继承对于初学者而言比较好理解,但要理解多态,尤其是深入理解,初学者往往存在有很多困惑,为什么这样就可以?有时候感觉很不可思议,由此,面向对象的魅力体现了出来,那就是多态,多态用的好,可以提高程序的扩展性.常用的设计模式,比如简单工厂设计模式,核心就是多态. 其实多态就是:允许将子类类型的指针赋值给父类类型的指针.也就是同一操作作用于不同的对象,可以有不同的解释,产生不同的执行结果.在运行时,可以通过指向基类的指针,来调用实现派生类中的方

C# 多态(虚方法,抽象,接口实现)

浅谈C# 多态的魅力(虚方法,抽象,接口实现) 前言:我们都知道面向对象的三大特性:封装,继承,多态.封装和继承对于初学者而言比较好理解,但要理解多态,尤其是深入理解,初学者往往存在有很多困惑,为什么这样就可以?有时候感觉很不可思议,由此,面向对象的魅力体现了出来,那就是多态,多态用的好,可以提高程序的扩展性.常用的设计模式,比如简单工厂设计模式,核心就是多态. 其实多态就是:允许将子类类型的指针赋值给父类类型的指针.也就是同一操作作用于不同的对象,可以有不同的解释,产生不同的执行结果.在运行时