面向对象——封装和继承

一、封装

目的：保护类，让类更加安全。

做法：让类里面的成员变量变为私有（即访问修饰符）的，做相应的方法或者属性去间接的操作成员变量

※访问修饰符

private 私有的              只能在该类中访问

protected 受保护的       只能在该类和它的子类中访问

public 公有的                在任何地方都可以访问

internal 内部的、默认的    程序集中可以访问，程序集就是命名空间

构造方法（函数）：

作用：造对象所要调用的方法，用来创建对象

　　    每一个类都有一个构造方法，不写也有只不过看不到而已

特殊性：写法特殊 （方法名=类名；没有返回值）

　　　　  执行时间特殊（创建对象时执行）

用途：可以对成员进行初始化

封装：
private 数据类型 _名字; --成员变量

public 默认一致 名字 --属性
{
　　get{ return _名字; }
　　set{ _名字 = value; }
}

属性可有多个，可以只放get或set

例：

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

namespace 封装
{
    class Program
    {
        static void Main(string[] args)
        {
            student s = new student();
            s.age = 25;
            s.name = "张三";
            Console.WriteLine(s.age+" "+s.name);
            Console.ReadLine();
        }
    }
}


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

namespace 封装
{
    class student
    {
        public student()
        {

        }
        /// <summary>
        /// 学号
        /// </summary>
        private string _code;

        public string code//属性
        {
            get { return _code; }
            set { _code = value; }
        }
        /// <summary>
        /// 姓名
        /// </summary>
        private string _name;

        public string name
        {
            get { return _name; }
            set { _name = value; }
        }
        /// <summary>
        /// 性别
        /// </summary>
        private string _sex;

        public string sex
        { 
            set 
            {
                if (value == "男")
                { _sex = "男"; }
                else if (value == "女")
                { _sex = "女"; }
                else
                { _sex = "错误"; }            
            }
            get { return _sex; }

        }
        /// <summary>
        /// 年龄
        /// </summary>
        private int _age;

        public int age
        {
            set
            {
                if (value >= 18 && value <= 150)
                {
                    _age = value;
                }
                else
                {
                    _age = 0;
                }
            }
            get { return _age; }
        }    
    }
}

类中不仅可以有成员变量和属性，还可以有成员方法

方法又分为，普通方法 静态方法

普通方法使用： 需要实例化对象，用对象点出来
静态方法使用： 直接用类名点出来，不需要实例化对象，只需声明时在访问修饰符后面加上static

 注：静态方法里面不能包含普通成员

       普通方法里面可以包含静态成员

用处：1.为了简便，连接数据库的时候，造连接对象类，使用静态属性直接返回连接对象。

　 　  2.两个类之间传递信息

　　   3.不允许创建对象的类（对创建对象的个数有限制）

class Program
    {
        static void Main(string[] args)
        {
            ZuHe zh = new ZuHe();

            //zh.name="张三"; //调用普通成员
            //ZuHe.zname = "五月天"; //调用静态成员
            ZuHe.Sing();

            Console.WriteLine(zh.Run());
            Console.ReadLine();
        }
    }


    class ZuHe
    {
        public string name="李四"; //普通成员，组合里面某个人的名字

        public static string zname = "李四"; //静态成员，组合名字

        public static string Sing() //静态方法
        {
            return "正在唱歌";
        }

        public string Run() //普通成员
        {
            return zname+"正在奔跑"; 
        }
    }

二、继承

子类可以继承父类的一切

特点：单继承   一个子类只能有一个父类  一个父类可以有多个子类

C#特殊点：所有类的祖先都是object

base关键字：在子类中代表父类对象，用法和this关键字相同 　　　　　　  

                   如果父类有构造方法，那么子类也要有构造方法，如果父类构造需要参数，那么子类构造也必须有相应的参数。 　　　　　　  

                   子类构造后面可以通过base调用父类的构造方法 　　　　　　  

                   public China(string m):base(m) {}