C# 面向对象基础

面向对象编程的英文简称是OOP(Object Oriented Programming), 该项技术是目前运用

最广泛的程序化设计方法，几乎已经完全取代了过去的面向过程的编程。

C#从一诞生开始，就是为面向对象编程所准备的。

在C#中，类可以看成是一种数据结构，它自身封装了数据成员和函数成员等。

C# 类定义:

[附加声明][访问修饰符] class 类名称 [:继承和接口] 注：继承在前接口在后，用逗号分开。

访问修饰符：

public：它具有最高的访问级别，对访问公共成员没有限制。

private：它的访问级别最低，仅限于它的包含类。

protected：能在它的包含类或包含类的派生类中访问。

internal：只能在同一程序集的文件中。

protected internal：仅限于从包含类派生的当前程序集或类型。

public abstract：可以在任何地方访问，但不能实例化，只能继承。

public sealed：可以在任何地方访问，只能实例化，不能派生。

C# 字段:

字段实际上相当于类的变量，类的成员变量。

public class A
{
  public string name;  //类中字段必须定义成public类型，才能在类的外部访问。
  public int age;
}

C# 常量:

通常定义常量用关键字const。

public const int age = 30; //常量即不可变的量。

注：动态常量关键字为readonly，也称之为只读变量。程序运行时赋值，一旦赋值不能更改。好处是不限制定义常量类型。

C# 域:

域只能声明在类的内部，而不能声明在类的方法的内部。域分为实例域和静态域。

域也分公有域和私有域，私有域不能在外部被调用。私有域的关键字为readonly。

public readonly int age = 30; //声明私有域

C# 类的方法:

方法修饰符：

public：该方法可以在类的任何地方，包括外部被访问。

private：该方法仅能在类的内部被访问。

protected：该方法可以在类的内部或类的派生类的内部被访问。

internal：该方法可以在同一程序集中被访问。

abstract：表示该方法为抽象方法，没有执行方式。

sealed：该方法重用了继承的虚拟方法，但不能被它的派生类重用。

virtual：该方法能被包含类的派生类重用。

override：该方法重写继承的方法或抽象的方法。

extern：该方法能被另一种语言执行。

new：该方法隐藏了同名的继承方法。

class Program
    {
        public abstract class Compute  //定义一个抽象类
        {
            public virtual int Medhot(int x, int y) //一个虚拟方法，该方法能被包含类的派生类重用。
            {
                return x + y;
            }
        }
        public class Use : Compute //派生类
        {
            public override int Medhot(int x, int y) //重写Medhot方法
            {
                return base.Medhot(x, y);
            }
        }
        static void Main(string[] args)
        {
            Use use = new Use();
            Console.WriteLine(use.Medhot(2, 3));
            Console.ReadKey();
        }
    }

C# 类的属性:

类的属性提供比较灵活的机制来读取，编写或计算私有字段的值，可以像使用公用数据成员一样使用属性。

属性必须要由访问器进行读写，它的一般声明格式如下所示。

class Fruit
        {
            private string name;
            public string Name
            {
                get
                {
                    return name;
                }
                set
                {
                    name = value;
                }
            }
        }
        static void Main(string[] args)
        {
            Fruit fruit = new Fruit();
            fruit.Name = "Apple";
            Console.WriteLine(fruit.Name);
            Console.ReadKey();
        } 

C# 类的索引器:

跟类属性差不多，主要是用来数组操作。

class Student
        {
            private string[] Name = new string[10];
            public Student() //构造函数
            {
                for (int i = 0; i < 10; i++)
                {
                    Name[i] = i.ToString();
                }
            }
            public string this[int index]  //创建索引器
            {
                get
                {
                    string str;
                    if (index >= 0 && index < 10)
                    {
                        str = Name[index];
                    }
                    else
                    {
                        str = "null";
                    }
                    return str;
                }
                set
                {
                    if (index >= 0 && index < 10)
                    {
                        Name[index] = value;
                    }
                }
            }
        }
        static void Main(string[] args)
        {
            Student student = new Student();
            student[1] = "小张";
            student[3] = "小吴";
            student[7] = "小韩";
            for (int i = 0; i < 12; i++)
                Console.WriteLine(student[i]);
            Console.ReadKey();
        }

C# 类的构造函数和析构函数:

1、构造函数必须与类同名。

2、构造函数不能有返回类型。

3、当访问一个类时，它的构造函数最先被执行。

4、一个类可以有多个构造函数。

class Student
        {
            public static int x;    //静态函数可以直接访问
            public int y, m, n;
            static Student() //构造函数1  静态构造函数
            {
                x = 2;
            }
            public Student() //构造函数2
            {
                y = 3;
            }
            public Student(int M, int N)  //构造函数3
            {
                m = M;
                n = N;
            }
        }
        static void Main(string[] args)
        {
            Console.WriteLine("x=" + Student.x);
            Student stu1 = new Student();
            Console.WriteLine("y=" + stu1.y);
            Student stu2 = new Student(2, 3);
            Console.WriteLine("m={0} , n={1}", stu2.m, stu2.n);
            Console.ReadKey();
        }

类的析构函数的过程正好相反，它主要用于销毁类的实例，它不能带有参数，不能含有修饰符，不能被调用，且必须与类同名，

前面加”_“符号，析构函数通常会被自动执行。