一、继承
把公有的数据或方法放在父类中,在子类中放不同的属性,子类继承父类例子:
class DiRen
{
public void AI()
{
Console.WriteLine("这是敌人公有的AI方法");
}
}
class Boss:DiRen
{
public void Attack()
{
Console.WriteLine("Boss正在进行攻击");
}
}
Boss boss = new Boss();
boss.AI();
描述:Boss类继承DiRen类,所以能调用DiRen类中的AI方法
如果方法或字段是私有的,则不能调用
DiRen diren;
diren = new Boss();
父类声明的对象可以用子类去构造
但不能使用子类中的方法,如: diren.Attack(); 需要使用强制转换
Boss boss = (Boss)diren;
boss.Attack();
DiRen diren = new DiRen();
用父类构造的对象无法强制转换为子类,如:Boss boss = (Boss)diren;
二、虚方法
父类中关键字: virtual 放在访问修饰符后面子类中关键字: override
有共同的方法但方法中体现的代码不同可以使用虚方法,在子类中重写方法
注意: 我们在子类中重写的虚方法,不管在哪调用,都是使用的重写后的方法
前提: 用子类创建的对象调用虚方法,是用的重写后的方法
用父类创建的对象调用虚方法,还是用的父类中原有的虚方法
例子: class DiRen
{
public void AI()
{
Move();
Console.WriteLine("这是敌人公有的AI方法");
}
public virtual void Move()
{
Console.WriteLine("这是公有的Move方法");
}
}
class Boss:DiRen
{
public void Attack()
{
Move();
Console.WriteLine("Boss正在进行攻击");
}
public override void Move()
{
Console.WriteLine("这是子类中的Move方法");
}
}
调用父类中的Move:
DiRen diren = new DiRen();
diren.AI(); 这里显示的就是父类中Move方法
调用子类中的Move:
Boss boss = new Boss();
boss.Attack(); 这里显示的就是子类中Move方法
三、隐藏方法 (一般很少使用)
1、介绍在子类中声明和父类中方法名一样的方法,而且没有使用虚方法的关键字
父类中的方法就被隐藏了,可以在子类方法前加 new 关键字
2、区别
虚方法是重写后是原来的方法不存在了,用子类创建的对象只能调用重写后的方法
隐藏方法是把方法隐藏了,原来的方法还在
例子: class DiRen
{
public void AI()
{
Move();
Console.WriteLine("这是敌人公有的AI方法");
}
public void Move()
{
Console.WriteLine("这是公有的Move方法");
}
}
class Boss:DiRen
{
public void Attack()
{
Move();
Console.WriteLine("Boss正在进行攻击");
}
public int void Move()
{
Console.WriteLine("这是子类中的Move方法");
}
}
调用父类中的Move:(调用隐藏方法)
DiRen diren = new Boss();
diren.AI(); 这里显示的就是父类中Move方法
调用子类中的Move:
Boss boss = new Boss();
boss.Attack(); 这里显示的就是子类中Move方法
四、 this 和 base 关键字 (有没有都可以,有可以让IDE给出提示)
this :可以通过 this 访问当前类中的字段、属性和方法base : base 只能访问父类中的属性和方法
五、抽象类
抽象类不能实例化,可以包含普通函数和抽象函数抽象函数只有函数定义没有函数体,抽象函数本身也是虚拟的Virtual(虚函数)
关键字: abstract
例子:
abstract class Bird
{
private float speed;
public void Eat();
public abstract void Fly();
}
如果有抽象函数,那么这个类也是抽象类
class Crow:Bird
{
public override void Fly()
{
Console.WriteLine("乌鸦在飞行");
}
}
如果一个子类继承了一个抽象类,就必须要重写该抽象方法!
Bird crow = new Crow();
crow.Fly();
虽然抽象类不能构造一个对象,但是可以声明一个对象在用子类去构造
Bird crow 声明
new Crow() 构造
六、密封类和密封方法
1、介绍C#允许把类和方法声明为 sealed ,对于类,表示不能继承该类
对于方法,表示不能重写该方法
2、使用
防止某些不需要继承或重写的类和方法导致代码混乱!
3、密封方法
class DiRen
{
public virtual void Move()
{
Console.WriteLine("这是公有的Move方法");
}
}
class Boss:DiRen
{
public sealed override void Move()
{
Console.WriteLine("这是子类中的Move方法");
}
}
只能在重写的方法前加 sealed ,表示这个方法不能被重写了
七、子类的构造方法
1、在子类中调用父类的默认构造函数(无参)class BassClass
{
public BassClass()
{
Console.WriteLine("bass class 无参的构造函数");
}
}
class DerivedClass:BassClass
{
public DerivedClass():base()
{
Console.WriteLine("这个是DerivedClass无参的构造函数");
}
}
关键字: :base()
如果构造一个对象,会先调用父类的,然后调用子类的构造函数
2、调用有参的构造函数
class BassClass
{
private int x;
public BassClass(int x, int y)
{
this.x = x;
Console.WriteLine("x赋值完成");
}
}
class DerivedClass:BassClass
{
private int y;
public DerivedClass(int x, int y):base(x,y)
{
this.y = y;
Console.WriteLine("y赋值完成");
}
}
关键字: base( 类型 参数)
如果构造一个对象,会先调用父类的,然后调用子类的构造函数
八、修饰符
1、public和private用于修饰类中的字段和方法
private 私有的 表示这个字段或方法只能在该类内部中访问
public 公有的 表示这个字段或方法可以通过声明的对象访问
public class...
可以通过声明别的项目的类来访问该类
2、protected
protected 应用于类型和内嵌类型的所有成员
只有派生的类型能访问该项
class BassClass
{
protected int z;
}
class DerivedClass:BassClass
{
public DerivedClass()
{
base.z = z;
}
}
当没有继承时 protected 与 private 一样,
有继承时表示可以在子类中使用 protected 修饰的字段
3、static
static 可以用来修饰字段和方法
修饰字段和方法时叫做(静态字段)和(静态方法)
注意:
使用 static 修饰的成员只能通过类名访问
通过类构造出来的对象中不包含静态成员
使用: 可以通过 类名. 的形式直接访问
例子:
class ClassXyz
{
public static int z;
}
ClassXyz.z = 100;
注意:
你可以构造一个对象来访问类中的方法或字段,但字段的值或方法中的方法体不一样
但静态成员是唯一的,给它赋值或写上方法体后,所有对象使用都是一样的效果!
九、接口
接口不能有构造函数,不能有字段,也不允许运算符重载接口定义中不允许声明成员的修饰符,接口成员都是公有的
实现:定义了一个接口后,调用该接口叫实现
1、接口的名称一般用I开头
2、声明
interface IFly
{
void Fly();
void MethodA();
}
接口中的函数类似于抽象类,只有函数定义没有函数体
3、派生的接口
interface IA
{
void Method1();
}
interface IB:IA
{
void Method2();
}
class Bird :IB
{
public void Method1()
{
}
public void Method2()
{
}
}
当IB继承IA后,Bird继承IB就会有IB和IA中的方法
十、区别隐藏方法和虚方法
Son a = new Son();Father b = a; 相当于 Father b = new Son();
F表示隐藏方法
G表示虚方法
a.F(); 通过父类声明的对象,使用父类的隐藏方法
b.F(); 通过子类声明的对象,使用子类的隐藏方法
a.G(); 使用子类中的虚方法
b.G(); 使用子类中的虚方法
只要用子类构造了,不论父类对象还是子类对象调用都是使用重写后的虚方法!!
而隐藏方法是父类声明对象用父类中的方法,子类声明对象用子类中的方法!!
如果一个虚方法在子类中没有添加 override 关键字,就说明没有被重写
而是被隐藏了!