2.0 面向对象 类与实例(关键字)、封装、继承、多态(虚方法,抽象类,抽象方法,接口)...

一切事物皆为对象，对象是可以看到、感觉到、听到、触摸到、尝到、或闻到的东西。 对象是一个自包含的实体，用一组可识别的特性和行为来标识。面向对象编程(Object-Oriented Programming): 其实就是针对对象来进行编程。

面向对象的语言必须满足三大特性：封装、继承、多态

一、类与实例

　　定义:具有相同属性和功能的对象的抽象的集合，是对象的一种表现形式;实例化就是创建对象的过程(new)，实例就是一个真实的对象。

　　修饰符和关键字:

分类名称	修饰符/关键字	概述	实例使用
属性修饰符	[Serializable]	按值将对象封送到远程服务器。在按值封送对象时，就会创建一个该对象的副本，并将其序列化传送到服务器。 任何对该对象的方法调用都是在服务器上进行的。
	[STAThread]	是Single-Threaded Apartment单线程套间的意思，是一种线程模型（线程模式用于处理组件在多线程的环境里并行与并互的方式），套间线程(STAThread)模式中接口跨线程传递必须被调度(Marshal)，不调度直传肯定会失败！而MTA或FreeThread模式中的接口可以不经调度直接传递。这种调度在特定的环境中非常影响性能(可有几百倍之差)。如VB里只支持STAThread模式。FreeThread模式的组件会在里面表现成和跨进程一样慢！线程模式是微软的COM基础中的极其重要的概念。一定要吃透！
	[MTAThread]	是MultiThreaded Apartment多线程套间的意思，同上也是一种线程模型。
访问修饰符	private	只有包含该成员的类可以使用,作用于类成员。
	protected	只有包含该成员的类以及派生类可以存取，作用于类成员。
	internal	只有当前工程(程序集)可以存取，作用于程序集及以内。
	public	存取不受限制，任何地方都可以访问，作用于程序集及以内。
类修饰符	abstract	抽象类。指示一个类只能作为其它类的基类。
	sealed	密封类。指示一个类不能被继承。理所当然，密封类不能同时又是抽象类，因为抽象总是希望被继承的。
成员修饰符	abstract	指示该方法或属性没有实现。
	sealed	密封方法。可以防止在派生类中对该方法的override（重载）。不是类的每个成员方法都可以作为密封方法密封方法，必须对基类的虚方法进行重载，提供具体的实现方法。所以，在方法的声明中，sealed修饰符总是和override修饰符同时使用。
	delegate	委托。用来定义一个函数指针。C#中的事件驱动是基于delegate + event的。
	event	声明一个事件。
	extern	指示方法在外部实现。
	override	重写。对由基类继承成员的新实现。
	readonly	指示一个域只能在声明时以及相同类的内部被赋值。
	static	指示一个成员属于类型本身，而不是属于特定的对象。即在定义后可不经实例化，就可使用。
	virtual	指示一个方法或存取器的实现可以在继承类中被覆盖。
	new	在派生类中隐藏指定的基类成员，从而实现重写的功能。 若要隐藏继承类的成员，请使用相同名称在派生类中声明该成员，并用 new 修饰符修饰它。
	const	指定该成员的值只读不允许修改。
其他关键字	this	关键字只能在方法内使用，包括构造方法，用来指代当前类本身的对象，关键字只能访问实例成员
	base	base关键字的中文意思是超级的，使用base关键字可以在子类中引用父类部分的内容。
	typeof	获取某一类型的 System.Type 对象，不能重载 typeof 运算符。eg：typeof(int)	View Code using System; namespace OperatorTest{ public class OperatorTestClass{ public static void Main(string[] args){ Console.WriteLine(typeof(int)); Console.WriteLine(typeof(Int32)); Console.WriteLine(typeof(string)); Console.WriteLine(typeof(double[])); } } }
	as	通过引用转换或装箱转换将对象转换成引用指定类型，若失败则返回NULL	Object ob1 = "My";  Object ob2 = 5; string a = ob1 as string; 成功a为"My"，失败a为NULL
	is	动态的检查运行时对象类型是否和给定的类型兼容,它返回一个布尔值，表示能否通过引用转换、装箱转换或拆箱转换	if(1 is int){}

　　类的声明：[修饰符] class 类名{}

　　类的实例化：类名 实例名 = new 类名()   ---实例化时调用默认无参构造方法，若编写了构造方法默认无参构造方法将失效

　　构造方法(构造函数)：就是对类进行初始化,构造方法与类同名,无返回值(也不需要void), 在 new 时候调用. 声明: [修饰符] 类名(参数列表){}

　　方法重载：创建同名的多个方法，但参数类型或个数(参数列表)不同，提供了函数的扩充能力。

　　字段和属性: 属性是一个方法或一对方法(get、set),适合于以私有字段的方式使用方法调用的场合。

二、封装

　　定义:封装是一种把代码和代码所操作的数据捆绑在一起，使这两者不受外界干扰和误用的机制;可理解为一种用做保护的包装器，以防止代码和数据被包装器外部所定义的其他代码任意访问。

　　说明:1.良好的封装能够减少耦合2.类内部的实现可以自由地修改3.类具有清晰的对外接口.

　　委托和事件： ---委托是对函数的封装,可以当作给方法的特征指定一个名称;事件是委托的一种特殊形式,当发生有意义的事情时,事件对象处理通知过程.(有篇博客深入研究)

 　  封箱和拆箱:实际就是引用类型和object类型(引用类型)之间相互转换;封箱实例:object obj = "str" //隐式封箱;拆箱实例: String s = (String)obj //显示拆箱;

　　属性和索引器:

属性	索引器
访问修饰符 返回类型 属性名{get{//取值代码 return 属性值}set{ //赋值代码}}	访问修饰符 返回类型 this[索引列表]{ get{return 属性值;} set{}}
定义:有效地封装数据,方便地操作数据	定义:是一种特殊的类成员，它能够让对象以类似数组的方式来存取，使程序看起来更为直观，更容易编写
允许调用方法，如同公共数据成员	允许调用对象上的方法，如同对象是一个数组
可通过简单的名称进行访问	可通过索引器进行访问
可以为静态成员或实例成员	必须为实例成员
其get访问器没有参数	其get访问器具有与索引器相同的形参表
其set访问器包含隐式value参数	除了value参数外，其set访问器还具有与索引器相同的形参表

三、继承   -------被继承者:父类,超类,基类；继承者:子类,派生类

　　定义:继承是指一个对象从另一个对象中获得属性的过程,继承与封装可以互相作用，是一种 类与类之间强耦合的关系。

　　　　优点：1.使得所有子类公共的部分都放在了父类，使得代码得到了共享，避免了重复(子类拥有父类 非private的属性和功能)。2.使得 修改或扩展 继承而来的实现 都较为容易(方法重写等).

　　　　缺点：1.父类变，则子类不得不变；2.会破坏包装，父类实现细节暴露给了子类。增大了两个类之间的耦合性。

　　　　注意事项:1.子类构造方法的书写：在子类的构造方法内部必须调用父类的构造方法，为了方便程序员进行开发，如果在子类内部不书写调用父类构造方法的代码时，则子类构造方法将自动调用父类的默认构造方法。而如果父类不存在默认构造方法时，则必须在子类内部使用base关键字手动调用。子类构造方法的参数列表和父类构造方法的参数列表不必完全相同;2.子类的构造过程：在构造子类时由于需要父类的构造方法，所以实际构造子类的过程就显得比较复杂了。

四、多态-----分为静态多态(方法重载)和动态多态(建立在继承和方法重写基础上)

　　定义:同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。

　　virtual(虚)方法: 被virtual修饰的是一个可被覆盖的基类方法，在派生类中用override覆盖该方法。（不能为private方法）

 

View Code

public class Animal
{
    …
    public virtual void EatFood()
    {
        Console.WriteLine(“animal在吃食物”);
    }
    …
}
public class Cow : Animal
{
    …
    public override void EatFood()
    {
        Console.WriteLine(“Cow在吃食物”);
    }
    …
}
class Program{…
    static void Main(string[] args)
{…
       Animal animal1;
        animal1 = new Cow();
        animal1.EatFood();
…}
-----输出: Cow在吃食物

　　抽象类:是特殊的类(对象)，只是不能被实例化，但可以包括抽象方法，这是普通类所不能的。抽象类可以派生自抽象类(只可继承一个)，可以覆盖基类的抽象方法也可以不覆盖，如果不覆盖，则其派生类必须覆盖它们,必须用abstract修饰，不能用密封(sealed)来修饰。

　　抽象方法:是一个没有方法体的方法(行为),但不能实现，只能声明于抽象类中，派生类必须覆盖(实现)它们,必须用abstract修饰,本身是虚方法，不能在修饰。

View Code

    class MyClass1
    {
        public void Method1()
        {
            Console.WriteLine("wo shi yi ban de lei");
        }
    }
    abstract class MyAbs : MyClass1 
    {
        public abstract void AbMethod1();
    }
    class MyClass : MyAbs
    {
        public override void AbMethod1()
        {
            Console.WriteLine("wo shi bei ji cheng hou chong xie de lei");
        }
    }
    class MyClient
    {
        public static void Main()
        {
            MyClass mc = new MyClass();
            mc.Method1();
            mc.AbMethod1();
        }
    }

　　接口:是单个或一组行为(属性、方法、事件、索引器)，只是不能被实例化，不能加访问修饰符，所有成员都是抽象(虚)的,可以继承多个接口

 

View Code

   
    interface IInterface1
    {
        void Method1();
    }
    interface IInterface:IInterface1
    {
    }
    abstract class MyAbs : IInterface
    {
        public void Method1()
        {
            Console.WriteLine("wo shi xian le bei jie kou ji cheng de jie kou");
        }
    }
    class MyClass : MyAbs
    {
    }
    class MyClient
    {
        public static void Main()
        {
        MyClass mc = new MyClass();
        mc.Method1();
        }
    }

 

　　　　　　抽象类继承接口时必须实现接口，可处理为virtual方法和抽象方法

View Code

public abstract class AbsTest
{    
     public virtual void Test()    
    {        
        Debug.WriteLine("Test");   
    }    
     public abstract void NewTest();
}
public interface ITest
{    
     void Test();    
     void NewTest();
}

 

 

转载于:https://www.cnblogs.com/wenmaoyu/p/3159805.html