C#面向对象

一、面向对象的核心概念

(一)抽象——面向对象的根基

讲到抽象，不得不涉及到现代科学技术的基础——数学。

数学是一门抽象的科学，面对着纷繁复杂的世间万物，数学不理会各种事物的独特特性，而只抽取它们在数量上的特性，深刻揭示了“世间万物”在数量上表现出的共同规律，抽象正是数学的本质特征。

数学的一个分支——离散数学是计算机科学的根基之一，因此，计算机科学从诞生之日起，就与数学有着密不可分的联系，抽象思维也是计算机科学的主要思维方法之一。

在使用面向对象的方法设计一个软件系统时，首先就要区分出现实世界中的事物所属的类型，分析它们拥有哪些性质与功能，再将它们抽象为在计算机虚拟世界中才有意义的实体——类，在程序运行时，由类创建出对象，用对象之间的相互合作关系来模拟真实世界中事物的相互关联。

在从真实世界到计算机虚拟世界的转换过程中，抽象起了关键的作用。

(二)面向对象的三大基本特性

1.封装

封装的类=数据+对此数据所进行的操作（即算法）

通俗的说，封装就是：包起外界不必需要知道的东西，只向外界展露可供展示的东西。

2.继承

真实世界中，事物之间有着一种派生关系，比如“食品”这一大类中包括“水果”这一子类，而“苹果”又包含在“水果”这一子类中。

在计算机世界中，以面向对象的观点不仅将上述事物抽象为类，而且将事物之间的派生关系也一并模拟出来，这种关系称为“继承”。

在面向对象软件系统中，继承除了模拟现实世界中事物关系这一作用，还是一个“重用已有代码而又不破坏已有代码”的方法。

3.多态

在代码中本应使用某一具体子类的地方使用较为抽象的基类对象，这种方法所带来的好处是多态的代码具有“变色龙”的特性，即在不同的条件下，同样代码可以完成不同的功能。

二、类与对象

（一）类是面向对象编程的基本单元。

（二）字段即变量，方法即函数。

（三）类中可以包含 

字段，属性，方法，索引器，结构体，构造函数，析构函数

函数分为变量函数（字段的保护），行为函数。

实例方法：对象可以调用，类不能调用。

方法的重载：1.同名2.参数类型不同或个数不同。

（三）传值与传址

传值引用：整形变量，浮点型变量，结构体，日期时间（存储在栈空间）

传址引用：字符串，数组，类。（存储在堆空间）

例题：小狗——类的传址引用

class dog
    {
        public string name;
        public void bark()
        {
            Console.WriteLine("汪汪，我的名字叫"+name);
        }
    }

 static void Main(string[] args)
        {
            dog a = new dog();
            dog b = new dog();

            a.name = "旺财";
            b.name = "守家";
            a.bark();
            b.bark();

            //将a的引用地址复制给c，a和c将同时控制同一个对象；
            //c将对象属性改变后，a指向的也是一个改变后的对象。
            dog c = a;           
            c.name = "大黄";
            a.bark();

            //将b的引用地址复制给a和c，a、b、c、控制同一个对象;
            //a、b原来指向的对象没有地址指向它，无法被调用，称为垃圾。
            a = b;
            c = b;              
            a.bark();
            b.bark();
            c.bark();

总结： 类的类赋值是指向同一个对象。

 例题：狗咬狗——方法的重载

   class dog
        {
            public string name;
            public int HP = 100;
            public void bark()  //实现一个说话的方法
            {
                Console.WriteLine("汪汪，我有个好听的名字叫：{0}", this.name);
            }

            public void bite(dog dg, int blood)  //实现一个咬的方法
            {
                Console.WriteLine("{0}开始攻击{1}", name, dg.name);
                dg.HP -= blood;  //另一个狗血量减10
                Console.WriteLine(name + "的血量：" + HP + dg.name + "的血量：" + dg.HP);
            }
        }

        static void Main(string[] args)
        {
            //实例化一个狗的类
            dog a = new dog();
            dog b = new dog();

            a.name = "旺财";
            b.name = "来福";
            a.bark();
            //重载狗咬狗的函数
            a.bite(b,10);
            b.bark();
            b.bite(a, 10);
            Console.ReadKey();

        }

例题：属相字段保护——学生信息

属性的作用：保护字段，对字段的取值与赋值进行限定；
说明：属性往往被声明在字段的下方，并且将字段私有化；

        /*
         * 类中可以存放的成员
         * 字段，属性，方法，索引器，结构，
         * 
         * this关键字表示：类中的对象
         */

        /*  new 关键字
         * 1）在内存中开辟空间，创建对象。
        /* 2）对对像进行初始化，将各个属性值赋值。
         * 3） 可以用来隐藏基类中同名的成员。
　　　　　*　4）new 约束指定泛型类声明的任何类型参数都必须是公有的无惨构造函数。
         * 
         * 属性的作用：保护字段，对字段的取值与赋值进行限定；
         * 说明：属性往往被声明在字段的下方，并且将字段私有化；
         * 
         */

        static void Main(string[] args)
        {
            //将student类实例化构造函数的写法
            student zsstudent = new student("张三", "男", 12, "洛阳", "123");
            //实例化另一个student类，未使用构造函数
           //需要给类的一个一个给属性赋值，写法十分麻烦。
            student lsstudent = new student();
            lsstudent.Name = "李四";
            lsstudent.Sex = "女";
            lsstudent.Age = 18;
            lsstudent.Address = "青岛";
            lsstudent.Tel = "110";
            zsstudent.Write();

            lsstudent.Write();
            Console.Read();
        }
    }
    public class student
    {
           /*通过设置private，在本类之外无法直接操作该类的字段，
        必须通过调用该类的函数（称为变量函数）来访问，起到保护字段的作用*/
        private string name;
        public string Name
        {
            get { return name; }   //get 可以对取值进行限定
            set { name = value; }   //set 可以对赋值进行限定
        }

        private string sex;    
        public string  Sex
        {
            get { return name; }   //get 可以对取值进行限定
            set { name = value; }   //set 可以对赋值进行限定
        
        }
        private int age;
        public int Age
        {
            get
            {
                if (age > 0 && age < 120)
                {
                    return age;
                }
                else
                {
                    return 0;
                }
            }
            set
            {
                age = value;
            }
        }
        private string address;
        public string Address
        {
            get { return address; }
            set { address = value; }
        }
        private string tel;
        public string Tel
        {
            get { return tel; }
            set { tel = value; }
        }
        /*构造函数
         * 构造函数默认有一个无惨的
         * 构造函数可以有重载
         * 初始化类成员，
         */

       //  this关键字表示：类中的对象
        public student(string name, string sex, int age, string address, string tel) 
        {
            this.Name = name;
            this.Sex = sex;
            this.Age = age;
            this.Address = address;
            this.Tel = tel;

        }

        //这是一个无参的构造函数
        public student()
        {

        }
        //如果系统中没有指定析构函数，那么编译器有GC来决定什么时候进行释放资源;
            /*
           * 析构函数
           * 销毁一个类的实例的方法成员， 析构函数不能有参数，
           * 不能有任何访问修饰符，不能被调用
           */
        ~student()
        {
            Console.WriteLine("我是析构函数，看我什么时候调用！");
            //在使用完当前类的时候会调用；

            Console.ReadKey();
        }
        public void Write()  //输出一段话
        {
            Console.WriteLine("我叫{0},性别{1}今年{2}岁了,住址{3},电话{4}", this.Name, this.Sex, this.Age, this.Address, this.Tel);     
        }
    }