C#面向对象编程（Object-Oriented Programming）

C#面向对象编程（Object-Oriented Programming）
1. OOP 面向对象分析
2. COD 面向对象设计
3. OCAD 面向对象分析与设计
4. 面向对象三特性：封装、继承、多态
5. 类是数据类型，包含字段、属性、方法、构造函数
6. 关键字this表示自己
7. 封装：主要是为了减少代码复用性，隐藏功能的实现，以及代码的安全性

修饰符：
private 私有属性，只能本类访问
protected 可继承，扩展到子类可以访问
Internal 一个项目下可以访问
public 任何人都可以访问
sealed 只能用于修饰类，为密封类，表示不能继承

小细节：访问参数必须一致

用一个类来说明封装，我定义了一个类pserson.cs
public class person
{
//定义委托
protected delegate void listenbackcall(string ss);
//添加事件
protected event listenbackcall listenevent;
//私有字段name
private string name;
//Nmae属性
public string Name{
get{return name;}
set{name=value;}
}

 int age;
 public int Age{
     get{return age;}
     set{age=value;}
 }
 //听属性
 public string Lis{
     set
     {
        listenevent(value);
    }
 }
 //构造函数
public person()
{
    age=1;
}
//构造函数
public person(string name,int age) :this()
{
    this.name=name;
    this.age=age;
    //绑定事件
    listenevent+=listen;
}
private void listen(string s)
{
    Console.WriteLine("hear：{0}",s);
}
//类方法
public void speak(string str){
    Console.WriteLine(str);
}

}

接着我定义一个类student.cs来说明继承

//student 继承类pserson
public class student:person{
public delegate void coursebackcall(string ss);
int id;
public int Id{
get{return id;}
private set{id=value;}
}
public student(string name,int age,int id):base(name,age)
{
this.id=id;
}
public void learn(string course,coursebackcall s)
{
s(course);
}
}

    static void Main(string[] args)
    {
        person p=new person("riven",18);
        person p1=new student("zhangs",23,1002);
        student s=new student("haha",233,1001);
        p1.speak("zhangs tall this is a test");
        s.Lis="i hear";
        s.learn("study",delegate(string study){
            Console.WriteLine("i can {0}!",study);
        });
        p.Lis="test";
    }

结果是：
F:\basis>dotnet run
牡丹开花了
玫瑰开花了
父类
玫瑰花开花啦实现了类flwing
花的description,这是子类方法
这是父类方法

同样用一个几个类来说明多态，说明之前先说明接口，以及抽象类。
接口的特点
1. 接口由Iterface关键字声明
2. 接口的方法不用实现只需声明
3. 只能声明为public
4. 接口允许多重继承
抽象类由abstract修饰,抽象类的特点:
① 抽象类只能做父类
② 抽象类不能实例化，既不能用new来产生属于抽象类的对象
③ 抽象类中除了抽象方法与普通方法不一样以外，其他的部分和普通类一样。即抽象类是普通类的特例，他特殊只是有抽象方法。所以它里面可以有字段，属性，普通方法。

3．抽象方法的特点
① 抽象方法是没有方法内容的，只有一个方法名和参数列表的方法。并以；结尾。
② 在方法的返回类型前加abstract
③ 抽象方法的内容由他的继承类根据继承类自身情况去写。重写这个方法时把abstract替换成override
注意：②③也是抽象属性的定义和实现的方法

多态的介绍：
定义一个接口Iflowered
interface Iflowered
{
string Name{get;set;}
void flowering();
}

定义了两个抽象函数 flw和flwing，定义两个类peony和rose。Peony继承flw和接口Iflowered，rose继承flwing和接口Iflowered

namespace basis
{
//抽象函数
abstract class flw{
public void getName(){
Console.WriteLine(“父类”);
}

    }
    abstract class flwing
    {
        abstract public void flwings();
        virtual public void Introduced(){
            Console.WriteLine("这是一个虚函数!");
        }
        virtual public void notAchieve(){
            Console.WriteLine("这是父类方法");
        }
    }

    //继承抽象类 flw 和 接口Iflowered
    class peony:flw,Iflowered
    {
        public string Name{get;set;}
        //实现抽象函数getName
        public new void getName()
        {
            Console.WriteLine(this.Name);
        }
        public peony(string name)
        {
            Name=name;
        }
        public  void flowering()
        {
            Console.WriteLine(Name+"开花了");
        }
    }

    //继承类flwing 和接口 Iflowered
    class rose:flwing,Iflowered
    {
        public string Name{get;set;}
        public rose(string name):base()
        {
            Name=name;
        }
        public void flowering()
        {
            Console.WriteLine(Name+"开花了");
        }
        public override void flwings()
        {
            Console.WriteLine(this.Name+"开花啦"+"实现了类flwing");
        }
        public override void Introduced(){
            Console.WriteLine("花的description,这是子类方法");
        }
    }

}

进行初始化：

static void Main(string[] args)
{
Iflowered ifl=new peony(“牡丹”);
ifl.flowering();
ifl=new rose(“玫瑰”);
ifl.flowering();
flw fl=new peony(“牡丹”);
fl.getName();
flwing flwi=new rose(“玫瑰花”);
flwi.flwings();
flwi.Introduced();
flwi.notAchieve();
}

结果：
F:\basis>dotnet run
牡丹开花了
玫瑰开花了
父类
玫瑰花开花啦实现了类flwing
花的description,这是子类方法
这是父类方法