黑马程序员_面向对象的三个基本特征

面向对象的理解

面向对象和面向过程都是一种编程思想，面向对象是相对于面向过程而言的，面向过程是面向对象的基础。

面向过程：完成任务由具备相应功能的函数，强调的是行为过程，完成这项任务是怎样做的！

面向对象：完成任务由具备相应功能的实例对象，强调的是具备相应功能的实例对象，完成这项任务的结果是什么！

面向对象编程的重要的组成要素：类和对象

类：类是用来描述事物的，类是抽象的概念，仅仅是模板，类不占内存

对象：对象是这类事物存在的个体，描述对象就是描述对象的行为和特征，对象占内存。

属性的作用：属性是为了保护与之相对应的字段的，保证对字段的读取和赋值符合要求，允许外部访问的变量一般要声明为属性，属性的本质是方法。

一、封装：将一段实现指定功能的代码包装起来，方便使用。

　　封装是面向对象的特征之一，是对象和类概念的主要特性。封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。一旦定义了一个对象的特性，则有必要决定这些特性的可见性，即哪些特性对外部世界是可见的，哪些特性用于表示内部状态。在这个阶段定义对象的接口。通常，应禁止直接访问一个对象的实际表示，而应通过操作接口访问对象，这称为信息隐藏。事实上，信息隐藏是用户对封装性的认识，封装则为信息隐藏提供支持。封装保证了模块具有较好的独立性，使得程序维护修改较为容易。对应用程序的修改仅限于类的内部，因而可以将应用程序修改带来的影响减少到最低限度。

二、继承：子类可以调用父类方法，实现了资源复用。

　　继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。这也体现了大自然中一般与特殊的关系。继承性很好的解决了软件的可重用性问题。比如说，所有的Windows应用程序都有一个窗口，它们可以看作都是从一个窗口类派生出来的。但是有的应用程序用于文字处理，有的应用程序用于绘图，这是由于派生出了不同的子类，各个子类添加了不同的特性。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 继承
{
    #region 人类，父类。
    class Person
    {
        private string name;

        protected string Name
        {
            get { return name; }
            set { name = value; }
        }

        private char sex;

        protected char Sex
        {
            get { return sex; }
            set { sex = value; }
        }

        private int age;

        protected int Age
        {
            get { return age; }
            set { age = value; }
        }

        public Person(string name, char sex, int age)
        {
            this.Name = name;
            this.Sex = sex;
            this.Age = age;
        }
    } 
    #endregion

    #region 老师类，继承（派生）于人类，子类。
    class Teacher : Person
    {
        private int year;

        public int Year
        {
            get { return year; }
            set { year = value; }
        }

        private int salary;

        public int Salary
        {
            get { return salary; }
            set { salary = value; }
        }

        public Teacher(string name, char sex, int age, int year, int salary)
            : base(name, sex, age)
        {
            this.Year = year;
            this.Salary = salary;
        }

        public void SayHello()
        {
            Console.WriteLine("我是{0}，当了{1}年老师，我的月薪是{2}。", Name, Year, Salary);
        }
    } 
    #endregion

    #region 学生类，继承（派生）于人类，子类。
    class Student : Person
    {
        private string hobby;

        protected string Hobby
        {
            get { return hobby; }
            set { hobby = value; }
        }

        private int classID;

        protected int ClassID
        {
            get { return classID; }
            set { classID = value; }
        }

        public Student(string name, char sex, int age, string hobby, int classID)
            : base(name, sex, age)
        {
            this.Hobby = hobby;
            this.ClassID = classID;
        }

        public void SayHello()
        {
            Console.WriteLine("我是{0}，我是{1}孩，今年{2}岁，爱好是{3}，在{4}班。", Name, Sex, Age, Hobby, ClassID);
        }
    } 
    #endregion

    class Program
    {
        static void Main(string[] args)
        {
            Student s = new Student("张三", '男', 18, "踢足球", 3);
            s.SayHello();
            Teacher t = new Teacher("王老师", '女', 30, 5, 8000);
            t.SayHello();
            Console.ReadKey(true);
        }
    }
    //输出结果：
    //我是张三，我是男孩，今年18岁，爱好是踢足球，在3班。
    //我是王老师，当了5年老师，我的月薪是8000。
}

三、多态：同一种表现形式实现不同的方法。

　　多态性是指允许不同类的对象对同一消息作出响应。比如同样的加法，把两个时间加在一起和把两个整数加在一起肯定完全不同。又比如，同样的选择编辑-粘贴操作，在字处理程序和绘图程序中有不同的效果。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 隐式隐藏父类方法
{
    class Father
    {
        public void Write()
        {
            Console.WriteLine("In the Father.");
        }
    }
    class Son : Father
    {
        //父类与子类方法名、参数（签名）、类型相同
        
        //public void Write()              
        //使用new   显式隐藏基类方法  最好加上new，别人看代码的时候知道父类有一个同名方法。
        //不使用new 隐式隐藏基类方法
        public new void Write()
        {
            Console.WriteLine("In the Son.");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Father f1 = new Father();
            f1.Write();

            Son s1 = new Son();
            s1.Write();

            Father f2 = s1;
            f2.Write();
            Console.ReadKey(true);
        }
        //输出结果:
        //In the Father.
        //In the Son.
        //In the Father.
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 重写父类方法
{
    class Father
    {
        public virtual void Write()
        {
            Console.WriteLine("In the Father.");
        }
    }
    class Son : Father
    {
        public override void Write()
        {
            Console.WriteLine("In the Son.");
        }
    }
    class Program
    {
        //new 则隐藏，over则重写，
        //隐藏看类型，重写只顾新！
        //                  ——蒋坤
        static void Main(string[] args)
        {
            Father f1 = new Father();
            f1.Write();

            Son s1 = new Son();
            s1.Write();

            Father f2 = s1;
            f2.Write();
            Console.ReadKey(true);
        }
        //输出结果：
        //In the Father.
        //In the Son.
        //In the Son.
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 多态USB的例子
{
    class Standard
    {
        public virtual void USB()
        {
            Console.WriteLine("USB标准。");
        }
    }
    class Phone : Standard
    {
        public override void USB()
        {
            Console.WriteLine("充电中");
        }
    }
    class Light : Standard
    {
        public override void USB()
        {
            Console.WriteLine("灯亮了");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            while (true)
            {
                Console.WriteLine(@"请选择插入的USB设备：
1.手机
2.灯");
                string select = Console.ReadLine();
                Standard s;
                switch (select)
                {
                    case "1": s = new Phone(); break;
                    case "2": s = new Light(); break;
                    default: s = null; break;
                }
                if (s != null)
                {
                    s.USB();
                }
                else
                {
                    Console.WriteLine("输入有误，请重新输入：");
                }
                Console.ReadKey(true);
                Console.Clear();
            }
        }
    }
}