继承与多态
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
{
///
/// 动物
/// 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
{
///
/// 继承的好处:继承为类与类之间指定关系,更大的提高了代码的重用率
/// ///
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();
//多态的实现:虚方法,抽象类,接口
}
}
}