周口航迪科技网站建设公司怎么样,用火车采集器发布信息时 如何获取网站栏目id,济南计算机培训机构哪个最好,网络科技公司一般都是骗文章目录 封装访问修饰符静态类和静态方法静态构造函数 继承继承原则sealed修饰符里氏替换原则继承中的构造函数 多态接口接口的实例化 抽象类和抽象方法抽象类和接口的异同 虚方法同名方法new覆盖的父类方法继承的同名方法 运行时的多态性编译时的多态性 照理继承封装多态应该… 文章目录 封装访问修饰符静态类和静态方法静态构造函数 继承继承原则sealed修饰符里氏替换原则继承中的构造函数 多态接口接口的实例化 抽象类和抽象方法抽象类和接口的异同 虚方法同名方法new覆盖的父类方法继承的同名方法 运行时的多态性编译时的多态性 照理继承封装多态应该是学习笔记中最先学习的。但是本系列不是面向新手的基础的继承封装多态的概念应当是要被掌握的。而本文需要讲述C#中的一些继承封装多态的特性。
部分摘自C#学习笔记二— 封装、继承、多态
封装
封装就是将类的属性和方法封闭起来外部成员不可直接调用只能通过预留的接口访问。
访问修饰符
在之前引用对象介绍class的时候我们已经介绍过 访问修饰符主要分为四种
public同一程序集中的任何其他代码或引用该程序集的其他程序集都可以访问该类型或成员。(public属性可被继承)private只有同一 class 或 struct 中的代码可以访问该类型或成员。(private属性不可被继承)protected只有同一 class 或者从该 class 派生的 class 中的代码可以访问该类型或成员。(只有该类和其子类可访问internal同一程序集中的任何代码都可以访问该类型或成员但其他程序集中的代码不可以。 换句话说internal 类型或成员可以从属于同一编译的代码中访问。
我们可以用访问修饰符来定义类的访问类型 默认当类未定义访问修饰符时访问级别是internal。而其内的成员的未定义访问修饰符时默认未private。
class Manager // 在命名空间中定义默认为internal可被同一程序集的另一个代码文件访问
{class Parent // 在类中定义的成员类默认为private不可被同一程序集的另一个代码文件访问{}
}注意在命名空间中类的访问修饰符只能为internal或public因为其他访问修饰符在命名空间中访问不了也就没有定义的必要了
静态类和静态方法
使用static修饰符定义的类被称为静态类。静态类基本上与非静态类相同但存在一个差异静态类无法实例化。 换句话说无法使用 new 运算符创建类类型的变量。 由于不存在任何实例变量因此可以使用类名本身访问静态类的成员。
例如如果你具有一个静态类该类名为 UtilityClass并且具有一个名为 MethodA 的公共静态方法如下面的示例所示
static class UtilityClass
{public static int a 1;public static void MethodA() { }
}
static void main(){UtilityClass.MethodA();
}使用静态类我们不用实例化对象而是直接调用类中的public方法。其内部成员只能是静态的。而实际上其实普通类也可以通过类名访问静态成员 无法继承无法实例化静态类的主要目的是提供一个容器来组织和管理相关的静态成员。
静态构造函数
当我们第一次访问静态类的时候会调用一次静态构造函数。而第二次之后不会因此起到了一个初始化的功能。
static class UtilityClass
{public static int a 1;public static void MethodA() { }static UtilityClass(){Debug.Log(我是静态类的静态构造函数);}
}
class NormalClass
{public static void MethodA() { }static NormalClass(){Debug.Log(我是普通类的静态构造函数);}public NormalClass(){Debug.Log(我是普通类的实例构造函数);}
}
void Start()
{UtilityClass.MethodA(); // 我是静态类的静态构造函数NormalClass.MethodA(); // 我是普通类的静态构造函数UtilityClass.MethodA(); // 无NormalClass.MethodA(); // 无//UtilityClass u new UtilityClass(); 错误静态类无法实例化NormalClass n new NormalClass(); // 我是普通类的实例构造函数
}而如果单独实例化一次普通类
void Start()
{NormalClass n new NormalClass(); // n.MethodA(); 错误实例化对象无法访问静态方法// 先后输出两行// 我是普通类的静态构造函数// 我是普通类的实例构造函数
}继承
继承就是在已存在的类基础上建立一个新类保留原有类的属性和方法同时又可以增加新的内容。 已存在的类称为基类或父类继承的类称为派生类或子类。
继承原则
在C#中只有classstructinterface可以继承其中class可以继承唯一的父类和其他任意数量的接口类。struct和interface只能继承接口类。 每一层继承可以添加一些可被继承的方法给下一层。也有一些成员不可被继承。其关系请看上面写的访问修饰符。
当访问类中的成员时就是逐级向上访问的如果子类和父类有同名成员优先访问子类成员。
sealed修饰符
使用sealed修饰符是为了让该类不能再被继承
sealed class Father{
}class Son:Father{ //错误不可被继承
}密封类的目的是不希望一些最底层的类被继承加强面向对象的规范性结构性和安全性。
里氏替换原则
任何基类可以出现的地方派生类一定可以出现。从继承的角度来看子类是在父类的基础上扩充的自然比父类要全面。另一方面要遵循里氏替换原则子类中定义的一些方法也需要父类可用。
看个例子
//基类
public class Mouse
{public void Dig(){Debug.Log(打洞);}
}
//派生类
public class MouseSon : Mouse
{public void Dig(){Debug.Log(不会打洞);}
}
static void main()
{Mouse m1 new Mouse();m1.Dig(); // 打洞MouseSon m2 new MouseSon();m2.Dig(); // 不会打洞与父类方法重名时优先访问该类中的方法
}
老鼠的儿子不会打洞就违反了里氏替换原则。这种情况下父类能用的时候子类是不能用的子类无法替换父类。
通常里氏替换原则有两种基本要求
可以用子类对象代替父类对象父类容器包含子类对象时与1实现相同
//基类
public class Mouse
{public void Dig(){Debug.Log(打洞);}
}
//派生类变异老鼠儿子可以飞
public class MouseSon : Mouse
{public void Fly(){Debug.Log(飞);}
}
static void main()
{Mouse m1 new Mouse();m1.Dig(); // 打洞MouseSon m2 new MouseSon();m2.Dig(); // 打洞m2.Fly(); // 飞Mouse m3 new MouseSon();m3.Dig(); // 打洞// m3.Fly(); 老鼠爸爸不能飞
}继承中的构造函数
当子类继承父类之后如果要在子类定义构造方法要么父类中不定义任何构造方法要么父类定义一个无参数的构造方法
class Parent
{// 父类无构造方法或定义下列无参数构造方法//public Parent()//{//Debug.Log(我是Parent);//}
}
class Son : Parent
{public Son(){Debug.Log(我是Son);}
}但是如果父类中定义了带参数构造方法且没有定义无参数构造方法则子类中定义构造方法无论是否带参数都报错。除非使用base关键字定义传回对应参数
class Parent
{public Parent(int i){Debug.Log(我是Parent);}
}
class Son : Parent
{public Son(int i) : base(i){Debug.Log(我是Son);}
}总的来说子类的构造方法和父类的构造方法参数数量必须是对应的。如果父类构造方法至少接受一个参数那么相应的子类构造方法需要接受参数并调用父类构造方法。 多态
接口
定义接口时我们需要用interface关键字定义标准的接口命名格式需要在开头加上大写的I代表interface。 接口可以包含方法、属性、索引器、事件。不能包含任何其他的成员例如常量、字段、域、构造函数、析构函数、静态成员。
interface IHuman
{// 接口中不允许任何显式实现void Name();void Age();public int Make { get; set; }public string this[int index]{get;set;}
}当继承接口时也需要实现接口的所有方法一个接口同样可以继承其他的接口当一个接口继承多个其他接口后这个接口被称为派生接口其他接口被称为基接口。一个继承了派生接口的类不仅需要实现派生接口中的所有方法也需要实现基接口中的所有方法
interface IBaseInterface
{void BaseMethod();
}
interface IEquatable : IBaseInterface
{bool Equals();
}
public class TestManager : IEquatable
{bool IEquatable.Equals(){throw new NotImplementedException();}void IBaseInterface.BaseMethod(){throw new NotImplementedException();}
}接口的定义一般用于通用的行为当多个类都需要实现这些行为并且每个类实现该行为的方法都需要重写时接口是十分必要的。
接口的实例化
在学习过程中我本以为接口是无法实例化的但事实上网络上很多博客的说法是错误的C#中的接口是可以实例化的 接口不能被直接实例化。它的成员通过实现该接口的任何类或者结构来实现。MSDN public class SampleClass : IControl, ISurface
{void IControl.Paint(){System.Console.WriteLine(IControl.Paint);}void ISurface.Paint(){System.Console.WriteLine(ISurface.Paint);}
}SampleClass sample new SampleClass();
IControl control sample;
ISurface surface sample;// The following lines all call the same method.
//sample.Paint(); // Compiler error.
control.Paint(); // Calls IControl.Paint on SampleClass.
surface.Paint(); // Calls ISurface.Paint on SampleClass.// Output:
// IControl.Paint
// ISurface.Paint如上所示当一个类继承了某接口我们可以将这个类的实例隐式转换为改接口的实例。这个接口实例包含了object基类的四大方法和自身接口的方法如果我们调用接口方法会发现接口实例的方法指向的是类重写的方法。这种方法的好处在于当一个类继承的接口拥有同名方法时我们可以通过实例化接口来区分同名方法的调用。 当然也可以对未实现该接口的类显式转换为该接口当然这并没有什么用运行时是会报错的。 抽象类和抽象方法
抽象类和抽象方法的定义关键字是abstract抽象方法必须要在抽象类中定义并且抽象方法必须是public的。但是抽象类和接口一样不能被实例化需要实现抽象类中所有的方法重写抽象方法的关键词是override抽象类也无法使用sealed进行修饰因为它就是用于继承的目的才会被创建。
abstract class Parent
{protected int age 1; public Parent() { }abstract public void callName();abstract public void callAge();
}
class Child : Parent
{public Child():base(){}public override void callName(){throw new NotImplementedException();}public override void callAge(){Debug.Log(age);}
}抽象类毕竟也是类比较特殊的是虽然抽象类不可实例化但它可以拥有一些实例化特性例如属性或者构造方法等是可以不用abstract修饰的。子类也可以像继承了正常类一般使用。 如果一个抽象类继承了接口那么它也需要实现接口中的方法但是抽象类可以以抽象方法的形式来实现它 abstract class Parent:IHuman{protected int age 1;public Parent() { }abstract public void callName();abstract public void callAge();public void Name(){throw new NotImplementedException();}abstract public void Age();}抽象类可以实现一些具体的方法也可以拥有具体的属性除了可实现抽象方法外其他的和普通的类也没有什么区别。
抽象类和接口的异同
相同点抽象类和接口都需要继承来实现都不可以被直接实例化继承了它们的子类都需要实现其中的抽象接口方法继承了接口的还需要实现其中的属性和索引器等 不同点抽象类不可实例化接口可以通过继承类的类型转换来间接实例化抽象类可以有具体方法接口只能定义函数头 网络上许多博客都把接口当做一个特殊的类但我看来接口就是接口类就是类这两个是完全不同的东西。甚至有些博客说什么“接口与抽象类的区别还有接口不能继承其他类抽象类可以。”接口本来就不是类只能继承接口怎么继承类
虚方法
使用virtual关键字来修改方法法、属性、索引器或事件声明并使它们可以在派生类中被重写。 静态属性不可使用virtual修饰符 class Animal{public virtual void Eat(){Debug.Log(吃素);}}class Lion:Animal{public override void Eat(){Debug.Log(吃肉);}}class Sheep:Animal{}虚方法与使用抽象方法的区别在于虚方法可以在任何类中使用无论是普通类还是抽象类。而使用虚方法我们可以灵活地决定是否需要在父类定义虚方法而子类是否需要重写这个虚方法这些都是自行决定的不会有强制要求。正如同上述的例子当需要重写时就用override重写虚方法不需要就直接继承即可。此外virtual关键字必须声明函数主体这也意味着它无法用在接口或者抽象方法中。 Lion lion new Lion();lion.Eat(); // 吃肉Sheep sheep new Sheep();sheep.Eat(); // 吃素Animal Cow new Animal();Cow.Eat(); // 吃素Animal Tiger new Lion();Tiger.Eat(); // 吃肉同名方法
在子类中可以使用一些同名的方法主要是两种情形下
覆盖父类方法时继承的类和接口存在相同的方法名定义时
new覆盖的父类方法
举个例子 class Animal{public void Eat(){Debug.Log(吃素);}}class Lion:Animal{public new void Eat() // 是否使用new关键字都会覆盖使用new来指示这是我们有意覆盖父类方法{Debug.Log(吃肉);}}class Sheep:Animal{}根据上面继承的结构图运行时会从子类到父类逐级查找方法而子类new的同名方法覆盖了父类的方法则会直接执行子类的方法。如果子类无定义则使用父类的方法 Lion lion new Lion();lion.Eat(); // 吃肉Sheep sheep new Sheep();sheep.Eat(); // 吃素Animal Cow new Animal();Cow.Eat(); // 吃素Animal Tiger new Lion();Tiger.Eat(); // 吃素继承的同名方法
现在有一个如下的接口
interface IEat
{void Eat();
}现在我们有一个sheep类它同时继承了Animal和IEat定义如下 class Wolf : Animal, IEat{public void Eat(){Debug.Log(吃肉);}}void Start(){Wolf wolf new Wolf();wolf.Eat(); // 吃肉IEat eat wolf;eat.Eat(); // 吃肉}我们发现上述情况下Eat()方法被同时重写了Wolf类中的Eat方法覆盖了Animal类中的Eat方法而同时也重写了接口的Eat方法。当出现同名方法时说明会同时覆写这些方法。而如果我们指定准确的方法名的话 class Wolf : Animal, IEat{public void Eat(){Debug.Log(吃肉);}void IEat.Eat(){base.Eat();}}void Start(){Wolf wolf new Wolf();wolf.Eat(); // 吃肉IEat eat wolf;eat.Eat(); // 吃素}通过指明接口名可以准确定义不同方法。 运行时的多态性
细心的读者可能发现了当我们用override重写虚方法时 Animal Tiger new Lion();Tiger.Eat(); // 吃肉而当我们覆盖原来的方法时 Animal Tiger new Lion();Tiger.Eat(); // 吃素在运行时除了逐级向上查找要执行的方法属性之外还会检查它是否是重写了virtual关键字使用父类容器装子类对象时如果虚方法已经被子类重写了那么则会执行重写的方法。对于虚方法的执行只会执行第第一个查找到的overrider方法talk is cheap看看下面的例子 class Animal{public virtual void Eat(){Debug.Log(吃素);}}class Lion:Animal{public override void Eat(){Debug.Log(吃肉);}}class Tiger : Lion{public new void Eat(){Debug.Log(吃兔子);}}void Start(){Animal tiger new Tiger();tiger.Eat(); // 吃肉}上述例子中Eat()执行的是吃肉而非吃兔子如果逐级上查的话第一个查找到的应当输出吃兔子。但是由于基类Aniaml的Eat()是一个虚方法所以执行的是逐级查找到的第一个被override重写的Eat()方法所以是输出吃肉。 class Tiger : Lion{public override void Eat() // 如果使用override再次重写{Debug.Log(吃兔子);}}void Start(){Animal tiger new Tiger();tiger.Eat(); // 吃兔子Lion tiger new Tiger();tiger.Eat(); // 吃兔子}如果再次使用override重写才会显示吃兔子有意思的是尽管Lion类中的方法并不是virtual我们还是重写了基类Animal的虚方法。 class Lion:Animal{public sealed override void Eat(){Debug.Log(吃肉);}}class Tiger : Lion{public override void Eat() // 重写报错Eat方法已经被密封了{Debug.Log(吃兔子);}}如果我们不希望Tiger类在继承Lion后还重写Eat()方法我们应当用sealed关键字来密封这个基类方法保证它不会在继承Lion了之后再重写 编译时的多态性
在程序中我们也需要用到一些同名但是不同参数的方法这是为了方便使用同一个方法在不同情况下进行处理。我们称为重载overload例如 void Start(){HumanEat(吃点啥呢 ?);}string HumanEat(Animal meat) { return ; }int HumanEat(Animal meat, Vegetable fruit) { return 1; }void HumanEat(Vegetable vegetable) { }同样是人同样是吃东西但是不同的人吃的东西会不一样素食主义者只吃素大部分人荤素都吃肉食主义者只吃肉。甚至有的时候我们需要函数的返回值也要做出区分。当我们需要调用HumanEat方法又需要具体区分重载是最好的选择这样同一个函数就可以有灵活的调用而不是把全部情况放在一个函数里每多出一个情况就重写原来函数或是定义n多个方法搞得光记个函数名都头大。 总结本节的概念有点多但每一个知识点都有其存在的意义例如如果我们想要一个可以不用实例化直接从命名空间调用的工具类就应该使用静态类。使用静态类的静态构造函数保证初始化时的唯一调用。当使用不同的父类考虑继承的模式。当使用多态时考虑什么情况下应当使用什么样的多态如果我们想要一个只有结构定义而没有具体实现且不被实例化的基类就需要抽象类当我们需要灵活的可继承的功能重写就需要接口。当我们需要多种情况下同种方法的实现就需要重载。如果希望多态性的体现虚方法会优于覆盖方法。所有的面向对象特性都应当在实际使用时慎重考虑设计时细心思考根据经验来进行程序的设计。
