前言： 完全是我在学习过程中记录的笔记，只不过分享一下让很多刚开始学习.net编程的人能够很快的学会C#语言
- 继承
(1) 继承中有两大重点
1)构造方法的执行
2)里氏转换原则
->子类对象可以直接赋值给父类对象
->指向子类对象的父类对象可以强制转换为对应的子类对象
class MyBase
{
}
class MySub:MyBase
{
}
class Program
{
static void Main(string[] args)
{
MySub msub = new MySub();
//里氏转换原则第一条
MyBase mBase = msub;
//里氏转换原则第二条
MySub msub1 = (MySub)mBase;
MyBase m = new MyBase();
m = new MySub();
MySub mm = (MySub)m;
}
}
- is运算符
(1) 语法: 变量 is 类型 返回值是一个bool值
(2)如果变量可以转换为指定类型，则为true,否则为false
(3)如果在判断is运算符的时候对象中也有父类对象
Person[] p = { ch, am, ko, new Person() };
if(p[i] is 父类)
{
//
}
//应该放在最后，由于所有的对象都来源于父类，因此在循环中这个判断永远为真，参考下面的案例
- as运算符
(1) 使用is运算符很多情况是为了实现下面的方法
子类 subObj;
if(instance is 父类)
{
subObj=(子类)instance;
}
else
{
subObj=null;
}
(2) 举例说明：
class MyBase
{
}
class MySub : MyBase
{
}
class Program
{
static void Main(string[] args)
{
MySub ms = new MySub();
MyBase mb = ms;
//is用法
//MySub m;
//if (mb is MySub)
//{
// m = (MySub)mb;
//}
//else
//{
// m = null;
//}
//as用法
MySub m = mb as MySub;
if (m == null)
{
Console.WriteLine("不能转换");
}
else
{
Console.WriteLine("可以转换");
}
}
}
- 一个关于继承和里氏转换原则的用法
(1) 父类只能访问父类的成员
(2)子类可以访问父类和子类的成员
(3)父类如果需要访问子类中的方法，这要考虑多态
- 多态
(1) 多态就是多种状态
(2)同一个函数在不同对象里有不同的实现
1)对象没变，在不同的环境中充当不同的角色
->写一个父类，写一个子类
->让子类和父类有一个相同的方法
->new一个子类对象
->调用这个方法
->将其转换为父类对象在调用这个方法
(3)隐藏基类方法，多态实现的案例
class Child
{
public void Play()
{
Console.WriteLine("和同学玩等");
}
}
class Adult : Child
{
public new void Play()
{
Console.WriteLine("玩游戏等");
}
}
class Program
{
static void Main(string[] args)
{
#region ----多态1的实现
//Adult adt = new Adult();
//adt.Play();
////第一种写法
////Child ch = adt;
////ch.Play();
////第二种写法
//(adt as Child).Play();
#endregion
Child ch = new Adult();
ch.Play();
Adult ad = (Adult)ch;
ad.Play();
}
}
隐藏基类方法
1)隐藏基类方法使用new来引导子类方法
2)保证子类和父类有同样的方法
3)具体在使用的时候，对象被赋予什么类型，就调用谁定义的方法
class MyBase
{
private string name = "杨总监";
public string Name
{
get { return name; }
set { name = value; }
}
public void Func()
{
Console.WriteLine("我是父类");
}
}
class MyClass:MyBase
{
public new string Name
{
get { return "韩迎龙"; }
}
public new void Func()
{
Console.WriteLine("我是一个类");
}
}
class MySub:MyClass
{
public new void Func()
{
Console.WriteLine("我是子类");
}
}
class Program
{
static void Main(string[] args)
{
MySub ms = new MySub();
ms.Func(); //我是子类
((MyClass)ms).Func(); //我是一个类
((MyBase)ms).Func(); //我是父类
MyClass m = new MyClass();
MyBase mb = m;
Console.WriteLine(m.Name); //韩迎龙
Console.WriteLine(mb.Name); //杨总监
}
}
(5) 重写基类方法
1)USB接口的小案例
->有一个标准的方法
->方法由具体的对象来实现
->实际使用的时候，动作是一样的做，但是具体的过程有实现这个方法的对象的决定
2)如何写
->写一个父类和子类
->子类与父类有相同的方法
->在父类方法前面加上一个virtual
->在子类方法前面加上override
->在使用过程中，new出子类对象，那么无论是什么类型调用方法的时候均执行子类实现的方法
class myBase
{
public virtual void Func()
{
Console.WriteLine("我是父类提供的方法");
}
}
class MySub : myBase
{
public override void Func()
{
Console.WriteLine("我是子类重写的方法");
}
}
class Program
{
static void Main(string[] args)
{
MySub ms = new MySub();
ms.Func();
myBase mb = ms;
mb.Func();
//输出结果都是：我是子类重写的方法
Console.ReadKey();
}
}
(6) USB接口的案例代码
class Deal
{
public virtual void USB()
{
Console.WriteLine("USB协议的接口");
}
}
class iPhone5S:Deal
{
public override void USB()
{
Console.WriteLine("假设只能充电");
}
}
class UDisk:Deal
{
public override void USB()
{
Console.WriteLine("传输数据");
}
}
class Program
{
static void Main(string[] args)
{
Console.WriteLine("请选择要使用的电子原件：1代表iPhone5S,2代表u盘");
Deal deal = null;
switch (Console.ReadLine())
{
case "1":
deal = new iPhone5S();
break;
case"2":
deal = new UDisk();
break;
default:
Console.WriteLine("没有使用任何可用原件");
break;
}
if (deal != null)
{
deal.USB();
}
}
}
(7)利用重写基类方法的多态可以实现父类访问子类的方法
1)父类定义虚方法，由子类去实现
2)如果父类指向子类调用这个方法，那么实现的具体代码就是父类指向的那个子类所提供的方法
(8)有关new与override
new则隐藏，over则重写
隐藏看类型，重写只管新
(9)重写的一点说明
1)父类virtual,子类可以不将其重写，还是可以隐藏的
2)如果不喜欢在被重写，可以使用sealed将其变为密封的
3)无论是重写还是隐藏，都是对子类的"直系"类进行处理
class MyBase
{
public virtual void Func()
{
Console.WriteLine("MyBase");
}
}
class MySub : MyBase
{
public new void Func()
{
Console.WriteLine("隐藏MySub");
}
}
class MySubSub : MySub
{
public override void Func() //这样写是错误的
{
Console.WriteLine("隐藏MySub");
}
}
class Program
{
static void Main(string[] args)
{
}
}