一、面向对象：创建一个对象，这个对象最终会帮你实现你的需求，尽管其中的过程非常曲折艰难。这也就是所谓的“你办事我放心”。

例如：

面向对象：折纸

爸爸开心地用纸折成了一个纸鹤；

妈妈不开心地用纸折成了一只小猪；

妹妹把纸变成了一朵玫瑰花。

纸作为一个对象，可以被折成纸鹤，小猪和玫瑰花，而不用关心是谁怎样折出来的。

面向对象三大特征：封装、继承、多态。

二、对象：现实中存在的事物，本质是类的实例，存在栈的一个变量。可以通过对象的属性（特征）和方法（行为）来描述这个对象。

例如：

蓝色妖姬这个对象

中文学名（属性）：玫瑰花（属性值）

科（属性）：蔷薇科（属性值）

颜色（属性）：蓝色（属性值）

方法（行为）：蓝色妖姬性喜阳光，耐寒、耐旱，适应性较强。

对象的初始化：创建好一个类的对象后，为这个对象的属性赋值的过程。

三、类：把具有相同属性和相同方法的对象进一步封装从而抽象出来的概念。类是个模型，根据类创建出来对象，并确定了对象应该具有的属性和方法。

语法：

[public] class 类名

{

　　字段；//字段的命名一般在前加下划线，如_name

　　属性；

　　方法；

}

1、类的实例化：创建这个类的对象的过程。其中类是不占内存而对象是占内存的。

例如：

//定义一个水果类

    public class Fruit
    {
        //字段：存储数据
        string _name; //水果的名字
        string _shape;//形状
        string _color;//颜色
        double _weight;//重量
        //方法
        public void output()//输出水果的数据
        {
            Console.WriteLine("{0}是{1}形的，颜色是{2}色，平均重量为{3}克。", this._name, this._shape, this._color, this._weight);
        }

    }

    class Program
    {
        static void Main(string[] args)
        {
            Fruit apple = new Fruit();  //类的实例化
            apple._name = "苹果";
            apple._shape = "圆";
            apple._color = "无";
            apple._weight = 250;

            apple.output();
            Console.ReadKey();
         }
    }  //输出结果：苹果是圆形的，颜色是红色，平均重量为250克。

2、属性：对字段进行再处理，限定对字段的赋值和取值，不让外界轻易访问到字段，以达到保护字段的作用。所以一般属性是public而字段是private的，让字段只能在当前类访问。字段是不存储数据的，因为它会把数据返回给字段。

1）属性的本质就是两个方法，一个是get(),用来取值；一个是set()，用来赋值。

例如：

//把上面的水果类加入属性对字段进行保护

 public class Fruit
    {
        //字段
        string _name;
        //属性
        public string Name
        {
            get { return _name; } //当输出属性值时，执行get方法。当对get()操作时，对字段的值操作，因为此时字段已被赋值。
            set { _name = value; } //当给属性赋值时，首先执行set方法。当对set()操作时，应对value操作。
        }
        string _shape;
        public string Shape
        {
            get { return _shape; }
            set { _shape = value; }
        }
        string _color;
        public string Color    //当水果的颜色输入为无的时候，限定_color的值为红
        {
            get { return _color; }
            set {
                if (value =http://www.mamicode.com/="无")
                {
                    value = "http://www.mamicode.com/红";
                }
                _color = value;
            }
        }
        double _weight;
        public double Weight  //当水果的重量输入小于0时，限定_weight的值为10
        {
            get {
                if (_weight < 0)
                {
                    return _weight = 10;
                }
                return _weight;
            }
            set { _weight = value; }
        }
        //方法
        public void output()
        {
            Console.WriteLine("{0}是{1}形的，颜色是{2}色，平均重量为{3}克。", this.Name, this.Shape, this.Color, this.Weight); //当有属性时，访问的是属性而不是字段，可以与上一个例子进行比较
        }

    }

    class Program
    {
         static void Main(string[] args)
        {
            Fruit apple = new Fruit("苹果", "圆", "无", 250); //实例化对象
            apple.Name = "苹果"; //访问的是属性，此时字段已被保护
            apple.Shape = "圆";
            apple.Color = "无";
            apple.Weight = 250;

            apple.output();
            Console.ReadKey();
         }
    }//输出结果：苹果是圆形的，颜色是红色，平均重量为250克。

2）因为属性不一定都有get()和set()这两种方法，所以又分为：

a、可读可写属性：既有get()又有set()。

b、只读属性：只有get()。

c、只写属性：只有set()。

3、静态类和非静态

静态类：当你想要把你的类当作工具类去使用，也就是会经常使用时，比如说console类。

1）静态类中只允许有静态成员，不能访问实例成员；

2）调用静态成员是，通过类名.静态成员来访问，调用简单，不用创建对象；

3）静态类在整个项目中实现资源共享，因为静态存储区域谁都可以访问；

4）当全部运行程序都结束的时候，静态类才会释放资源。因为存在垃圾回收器（GC）。

非静态类：

1）非静态类中既可以有实例成员，又可以有静态成员；

2）调用实例成员时，通过对象名.实例成员来访问；

3）实例化可以自动销毁。

4、构造函数：是一种特殊的方法，用来创建对象，可以在函数中对对象进行初始化，也就是给对象的每个属性依次赋值。

1）构造函数的名称要跟类的名称一样，修饰符必须是public；

2）构造函数没有返回值；

3）构造函数可以进行重载；

4）创建对象时执行构造函数；

5）类中会有个默认的无参数的构造函数，当写了个新的构造函数时，默认的会被替代。

例如：

    public class Fruit
    {
        //字段
        string _name;
        //属性
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
        string _shape;
        public string Shape
        {
            get { return _shape; }
            set { _shape = value; }
        }
        string _color;
        public string Color
        {
            get { return _color; }
            set {
                if (value =http://www.mamicode.com/="无")
                {
                    value = "http://www.mamicode.com/红";
                }
                _color = value;
            }
        }
        double _weight;
        public double Weight
        {
            get {
                if (_weight < 0)
                {
                    return _weight = 10;
                }
                return _weight;
            }
            set { _weight = value; }
        }

        //构造函数
        public Fruit(string name, string share, string color, double weight)
        {
            this.Name = name;
            this.Shape = share;
            this.Color = color;
            this.Weight = weight;
        }
        //构造函数的重载
        public Fruit(string name, string share):this(name ,share , "" ,0)  //通过:this()调用本类的构造函数
        {

        }
        //方法
        public void output()
        {
            Console.WriteLine("{0}是{1}形的，颜色是{2}色，平均重量为{3}克。", this.Name, this.Shape, this.Color, this.Weight);
        }

    }

    class Program
    {
         static void Main(string[] args)
        {
            Fruit apple = new Fruit("苹果", "圆");//调用重载构造函数
            //Fruit apple = new Fruit("苹果", "圆", "无", 250); //调用构造函数，想让大家了解构造函数的重载所以先注释掉

            apple.output();
            Console.ReadKey();
         }
    }//输出结果：苹果是圆形的，颜色是色，平均重量为克。（注意这个是重载构造函数）

5、析构函数

1）命名跟类名一样；

2）当程序结束时进行，可以帮助我们马上释放资源(释放对象)；

3）不带修饰符或参数；

4）不能被调用，它是被动被编译器调用的；

5）一个类只能有一个解构器，不能被重载或是继承（这点跟构造函数不同）；

语法：

~class()

{

　　// Cleaning up code goes here

}

6、关键字new

1）在内存中开辟一块空间；

2）在内存空间创建对象；

3）调用对象的构造函数对对象进行初始化（也因此构造函数的修饰符必须是public）。

7、关键字this

1）代表当前类的对象；

2）在类中显示调用本类的构造函数，语法  ：this()。

参考网址：http://www.cnblogs.com/paper/archive/2009/07/31/1535998.html

C#面向对象（初级）