C#继承和多态

继承与多态

base关键字

1.用于从派生类中访问基类成员

2.指定创建派生类实例时应调用的基类构造函数

new 覆写

virtual 定义虚方法，在子类中可以去改变这个方法

override 重写，将父类中的方法重写为子类中的方法，不能修改访问修饰符

多态：一个方法在不同子类中所实现不同，这个特征叫多态

抽象类：对一系列类的抽象

1.抽象类不能直接实例化

2.抽象方法不能有方法体

3.抽象方法只能写在抽象类里

4.非抽象类继承抽象类时，抽象类中的所有抽象方法必须实现

5.属性也可以定义为抽象的，属性本身也是方法

接口:是对功能约束的一种类型

类是接口的实现者

1.类的继承只能是单继承，接口的继承可以是多继承

2.不允许有字段定义与具体方法的实现

3.定义方法时，访问修饰符默认就是public，也值能是public，所以public不需要写

sealed 密封的，不允许被继承

sealed class密封类，不允许再被继承的类

sealed override 来修饰方法，说明这个方法不允许在这个类的子类中被重写

一般的方法都是在编译是决定：早绑定

多态的方法在运行时绑定：晚绑定

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace ConsoleApplication1

{

/// <summary>

/// 动物

/// </summary>

class Animal

{

private double height = 0;

protected double Height

{

get { return height; }

set { height = value; }

}

protected double weigth = 0;

protected double Weigth

{

get { return weigth; }

set { weigth = value; }

}

//***************构造函数***************************

public Animal()

{

Console.WriteLine("父类");

}

public Animal(double height, double weight)

{

this.height = height; ;

this.weigth = weight;

}

//操作

public void Sleep()

{

Console.WriteLine("animal sleep...");

}

//吃

public void Eat()

{

Console.WriteLine("animal eat...");

}

}

//在动物的基础上多了新的特点

//猪

class Pig:Animal

{

int legs = 4;

public int Legs

{

get { return legs; }

set { legs = value; }

}

//操作

public void Run()

{

Console.WriteLine("pig running...80km/h");

}

public void Show()

{

//this.Run();//当前

//base.Sleep();//base是个类的父类

Console.WriteLine("身高{0}\t体重{1}\t腿{2}",Height,Weigth,Legs);

}

//****************构造函数**********************

public Pig()

{

Console.WriteLine("子类");

}

//写子类的构造函数时可以调用父类的构造函数

//:base(实参)

public Pig(double height,double weight,int legs):base(height,weight)

{

//this.Height = height;

//this.weigth = weight;

this.legs = legs;

}

}

//鸟

class Bird:Animal

{

public int wings=2;

public void Fly()

{

Console.WriteLine("bird fly...");

}

public Bird()

{

Console.WriteLine("奥特曼不坑爹");

}

public Bird(double height, double weight, int wings) : base(height, weight)

{

this.wings = wings;

}

}

class Human

{

string name;

public string Name

{

get { return name; }

set { name = value; }

}

public Human()

{

}

public Human(string name)

{

this.name = name;

}

public void Speak()

{

Console.WriteLine("my name is {0}",name);

}

//virtual 定义虚方法，在子类中可以去改变这个方法

public virtual void Walk()

{

Console.WriteLine("坑爹啊");

}

}

class Student : Human

{

string stuNum;

public Student()

{

}

public Student(string stuNum,string name):base(name)

{

this.stuNum = stuNum;

}

//在子类中写了一个新的Speak()方法（new可省），遗弃了基类中的Speak方法

//new 覆写

public new void Speak()

{

Console.WriteLine("姓名{0}\t学号{1}",Name,stuNum);

}

// override 重写，将父类中的方法重写为子类中的方法

//多态：一个方法在不同子类中所实现不同，这个特征叫多态

public override void Walk()

{

Console.WriteLine("pig run！");

}

}

class Teacher : Human

{

public override void Walk()

{

//base.Walk();

Console.WriteLine("teacher walk");

}

}

class Program

{

/// <summary>

/// 继承的好处：继承为类与类之间指定关系，更大的提高了代码的重用率

/// </summary>

/// <param name="args"></param>

static void Main(string[] args)

{

//Pig p = new Pig(10, 120, 7);

//p.Eat();//父类的

//p.Run();//子类的

//p.Show();

//Pig pp = new Pig();

//Bird b = new Bird();

//b.Sleep();

//Student stu = new Student("2012.12.21", "我不是奥特曼");

//stu.Speak();

//Human h = stu;

//h.Speak();

//h.Walk();

//Teacher th = new Teacher();

//h = th;

//h.Walk();

//****************************

Human h2 = new Student();

h2.Walk();

h2 = new Teacher();

h2.Walk();

//多态的实现：虚方法，抽象类，接口

}

}

}