ASP.Net 基础知识

对象的特性：唯一性，抽象性，继承性，多态性

唯一性：每个对象都有自身唯一的标识，通过这种标识，可找到相应的对象。

抽象性：抽象性是指将具有一致的数据结构（属性）和行为（操作）的对象抽象成类。

继承性：继承性是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系。

多态性：多态性是指相同的操作或函数、过程可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态性。

构造函数的作用：实例化对象，初始化数据        

注意：如果类里面没有定义构造函数，编译器也会产生一个空构造函数，每一个类都会赋上一个默认值，如果类里 面定义了私有构造函数，这个类将不能实例化。

抽象类(abstract)：

　　　1）抽象类可以包含抽象方法和实例方法；抽象类可以没有抽象方法，但有抽象方法的类一定是抽象类。

　　　2）抽象方法声明时没有实现体，类似于接口中声明的方法。

　　　3）抽象方法必须在派生类中通过override重载来实现，这点也类似于接口，但不同的是实现接口的方法不用 override。

抽象类作用：抽象类实际意义就是说，派生类去实现抽象类定义的方法。

注意：用abstract修饰的抽象函数没有方法体，只能在子类继承父类的时候，在子类里面重写(overload)函数抽象类提供多个派生类共享基类的公共定义，它既可以提供抽象方法，也可以提供非抽象方法。抽象类不能实例化 ，

必须通过继承由派生类实现其抽象方法，因此对抽象类不能使用new关键字，也不能被密封。如果派生类没有实 现所有的抽象方法，则该派生类也必须声明为抽象类。另外，实现抽象方法由overriding方法来实现。

接口(interface)：接口把一组公共方法和属性组合起来 ，以封装特定功能的一个集合。通过类可以实现接口，这样类就支持接口所有的属性和方法。

注意：接口只能对方法和属性进行定义，不能实现方法体，只能由支持它的类实现。接口中的成员不能用访问符修饰，如public,private，它的成员默认为public。　　

　　public interface IMyinterface
　　{
　　　　void Dosomething();//方法成员
　　　　int MyAttribute//属性成员
　　　　{
　　　　　　get;//这里只能定义这个属性是否为只读
　　　　　　set;
　　　　}
　　}

.NET提供了三种不同的接口实现方式，分别为隐式接口实现、显式接口实现、混合式接口实现

public class MyClass
　　{
　　public void SomeMethod()
　　{
　　// 利用接口的方式声明一个Myinplement对象
　　IMyInterface iObj = new MyInplement();
　　iObj.MethodA();
　　// 利用类的方式声明一个Myinplement对象
　　MyInplement obj = new MyInplement();
　　obj.MethodB();
　　}
　　}
　　public class MyInplement : IMyInterface
　　{
　　#region IMyInterface Members
　　///
　　/// 利用隐式接口实现方式实现接口中的方法
　　///
　　public void MethodA()
　　{
　　Console.WriteLine("a");
　　}
　　///
　　/// 利用隐式接口实现方式实现接口中的方法
　　///
　　public void MethodB()
　　{
　　Console.WriteLine("B");
　　}
　　#endregion
　　}
　　public interface IMyInterface
　　{
　　void MethodA();
　　void MethodB();
　　}

重载特点：方法名称必须相同、参数列表必须不同、返回值类型可以不同

public int Sum(int x,int y)

public int Sum(int x,int y,int z)

public double Sum (Double x,Double y)

重写特点：重写是指具有父子关系的两个类，子类重写父类中的方法，但是要求，父类中的方法必须是抽象的或虚方法，子类才可以重写，其它无修饰的方法不可以重写，可以继承或覆盖。

　　//重写
    public class tests
    {
        public virtual string GetName() {
            return "name";
        }
    }
    public class tests2:tests {
        public override string GetName()
        {
            return "NAME";
        }
    }
 　　//覆盖子类方法
    public class tests
    {
        public virtual string GetName() {
            return "name";
        }
    }
    public class tests2:tests {
        public new string GetName()
        {
            return "NAME";
        }
    }

base关键字：用于从派生类中访问基类的成员，调用基类上已被其他方法重写的方法。

注意：基类访问只能在构造函数、实例方法或实例属性访问器中进行，从静态方法中使用 base 关键字是错误的。

//实例：
public class Person
{
    protected string ssn = "444-55-6666";
    protected string name = "John L. Malgraine";

    public virtual void GetInfo()
    {
        Console.WriteLine("Name: {0}", name);
        Console.WriteLine("SSN: {0}", ssn);
    }
}
class Employee : Person
{
    public string id = "ABC567EFG";
    public override void GetInfo()
    {
        // Calling the base class GetInfo method:
        base.GetInfo();
        Console.WriteLine("Employee ID: {0}", id);
    }
}

class TestClass
{
    static void Main()
    {
        Employee E = new Employee();
        E.GetInfo();
    }
}

    //指定创建派生类实例时应调用的基类构造函数。
    public class BaseClass
    {
        int num;
        public BaseClass() {
            Console.WriteLine("in BaseClass()");    
        }
        public BaseClass(int i) {
            num = i;
            Console.WriteLine("in BaseClass(int i)");
        }
        public int GetNum() {
            return num;
        }
    }

    public class DerivedClass : BaseClass { 
        public DerivedClass():base(){
        
        }
        public DerivedClass(int i) : base(i) { 
        
        }
    }

virtual(虚方法)：virtual 关键字用于修饰方法、属性、索引器或事件声明，并且允许在派生类中重写这些对象 。

注意：virtual 修饰符不能与 static、abstract, private 或 override 修饰符一起使用。

private：私有成员只有在声明它们的类和结构体中才是可访问的。

public：公共访问是允许的最高访问级别。

protected：受保护成员在它的类中可访问并且可由派生类访问。

internal：只有在同一程序集的文件中，内部类型或成员才是可访问的。

const：关键字用于修改字段或局部变量的声明。它指定字段或局部变量的值是常数，不能被修改。

readonly： 关键字是可以在字段上使用的修饰符。当字段声明包括 readonly 修饰符时，该声明引入的字段赋值只能作为声明的一部分出现，或者出现在同一类的构造函数中。

const以及readonly的区别:

　　1）const、readonly和static readonly定义的常量，指定初始值后(包括在构造函数内指定的初始值) 将不可更改，可读不可写；

　　2）const定义时必须指定初始值，而readonly定义时可以不进行初始化(MS建议在定义时初始值),同时也可以在构造函数内指定初始值，并以构造函数内指定的值为准

　　3）const和static readonly定义的常量是静态的，只能由类直接访问；而readonly定义的常量是非静态的，只能由实例对象访问； 

　　4）static readonly常量，如果在构造函数内指定初始值，则必须是静态无参构造函数；

　　5）const是编译时常量，readonly是运行时常量；cosnt较高效，readonly较灵活

abstruct和interface的区别：

　　1）抽象类可以有构造方法，接口中不能有构造方法。

　　2）抽象类中可以有普通成员变量，接口中没有普通成员变量

　　3）抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。

　　4.）抽象类中的抽象方法的访问类型可以是public，protected，但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。

　　5） 抽象类中可以包含静态方法，接口中不能包含静态方法

　　6） 一个类可以实现多个接口，但只能继承一个抽象类。

out和ref：
　　1）使用ref型参数时，传入的参数必须先被初始化。对out而言，必须在方法中对其完成初始化。

　　2）使用ref和out时，在方法的参数和执行方法时，都要加Ref或Out关键字。以满足匹配。

　　3）out适合用在需要retrun多个返回值的地方，而ref则用在需要被调用的方法修改调用者的引用的时候。

　　注意：ref是有进有出，而out是只出不进。