面向对象的一点简易理解

简单面向对象套路

public class Classfather
{
    public string name { get; set; }
    public Classfather(string _name)
    {
        Console.WriteLine("调用了父类的构造方法");
        name = _name;
    }
    virtual public void fatherMethod()
    {
        Console.WriteLine("父类方法 myname is "+name);
    }
}

public class Classson:Classfather
{
    //我们称之为接力传递
    //父子类之间继承 构造函数 参数通过下面这种方式接力传递到父类的
    public Classson(): base( "father")
    {
        Console.WriteLine("调用了子类的构造方法");
    }
    public Classson(string _name):base("father->"+_name)//_name接力传递
    {
        Console.WriteLine("调用了子类的构造方法");
        //name = _name;
    }


    //new   会把父类的方法废掉，父类的同名方法从此与他无关 以子类为主 你可以写
    //跟父类名字一样参数不一样的方法，相当与重载
    //用override关键字：
    //方法重写，父类必须要有同名方法并且带virtual关键字
    //并且重写的时候要遵循父类同名方法的参数

    //如果在fatherMethod方法中写fatherMethod();会造成死循环 导致堆栈溢出
    //但是如果想在Classson中访问Classfather的fatherMethod方法怎么办呢^_^
    //用base.fatherMethod();就行啦
    //this关键字相当于当前实例本身
    //base关键字相当于被继承的父类
    //在一个类中方法同名参数不同叫重载
    //父类与子类中方法重名叫重写(并且参数也要一样^_^)

    //此方法注释后 也能调fatherMethod 只不过是父类的 ，加new关键字 则强行覆盖父类方法
    public override void fatherMethod()
    {
        Console.WriteLine("子类继承的---父类的方法 myname is" + name);
        base.fatherMethod();
    }

   
    public void sonNewMethod()
    {
        Console.WriteLine("子类的新方法----");
    }
}

public void OOPTest()
{

    //实例化时先执行父类构造方法，然后执行子类构造方法
    Classfather c11 = new Classson();// ("zhangsan ");// ("c111");
    //注意了 此处执行是执行的子类方法 引用是父类引用类型 ，最基础c++里面向对象关键所在 也就这点
    c11.fatherMethod();
    ((Classson)c11).sonNewMethod();
    //输出true
    Console.WriteLine("c11 is Classfather: " + (c11 is Classfather));
    //输出true  由此可以提前确定类型 决定了你能否调用某函数 以免强制转换类型错误
    //网上说叫什么协变 逆变 
    Console.WriteLine("c11 is Classson: " + (c11 is Classson));

    //输出false
    Classfather c22 = new Classfather("");
    Console.WriteLine("c22 is Classson: " + (c22 is Classson));

    Console.WriteLine("-------------------------------");
    Classson c33 = new Classson();
    c33.fatherMethod();
    //输出true
    Console.WriteLine("c33 is Classson: " + (c33 is Classson));
    //输出true
    Console.WriteLine("c33 is Classfather: " + (c33 is Classfather));

    //fatherMethod()
    //xxx c33 = new Classson();
    //不管前面的引用是何类型父类还是子类 只认实例化对象 new Classson();
    //如果子类复写了fatherMethod() c33.fatherMethod() 则调用子类，未复写则自动调用父类

    //至于能不能调用 代码提示能不能出来 那是另一回事了涉及到前面说的协变逆变 强转类型，这句切记
    //所谓设计模式也就是玩这些个东西

    //以上充分体现了面向对象宽范围兼容窄范围的思想
}

两个互不相干的cls（哪怕在同一命名空间） 要想访问对方的成员 ，那个成员必须是public

如果是不同命名空间 或者项目 要想在其他的项目中 实例化那个cls，那个cls必须是public

要养成面向对象编程的习惯
到处都要用的变量 放到外面作为成员，
不要所有的业务逻辑全都一股脑写成一个个的方法堆起
不要访问级别 继承的什么都不管 全部写成 javascript函数形式的东西
这样的话跟oop就有点脱节了
可能开始不太习惯 但是你会发现这会给你设计程序带来莫大的好处

一个面向对象的例子

这些都是oop的基本常识 但是只要运用得当 也可以让你的程序运行得更好，别太在乎那些花哨的设计模式 并不是那些东西没用，只是别贸然模仿。时隔今日 又来这篇博文上添砖加瓦。上次张翔同学说不知道什么情况下新建一个类 什么情况下拓展，一时我也不知如何回答他。上周参考了以前的报价软件代码思想做出一个例子 正巧可以做说明：这里有个功能 要做各种报表导出。 然后就建一个 报表导出基类：

class ReportExport
    {
        string reportName;
        string reportFullName;
        ProjectAdapter ada;
        //初始化模板名字 文件保存目录 和适配器
        public ReportExport(string _reportName, string _reportFullName)
        {
            reportName = _reportName;
            reportFullName = _reportFullName;
            ada = MyApp.Instance.AdapterFlyWeight.GetProjectAdapter();
        }

        //进行数据适配
        public virtual void AdaptiveToData()
        {
            dataModels = new List<BaseModel>();
            templateNames = new List<string>();
            sheetNames = new List<string>();
        }

        protected List<BaseModel> dataModels;
        protected List<string> templateNames;
        protected List<string> sheetNames;
        
        //进行导出动作
        public virtual bool Export()
        {
            ada.ExoprtToFile(dataModels, templateNames, sheetNames, reportFullName);
            return true;
        }
    }

 然后我有个特定的名字叫甲方文件 的报表 继承这个基类

class ReportJiafang:ReportExport
    {
        public ReportJiafang(string  reportJiafangFullName)
            : base("甲方文件报表",reportJiafangFullName)
        { }

        public override void AdaptiveToData()
        {
            base.AdaptiveToData();
            dataModels.Add(App.Instance.CurrentProject);
            dataModels.Add(App.Instance.CurrentProject);

            templateNames.Add("甲方文件报表汇总表");
            templateNames.Add("甲方文件报表明细表");

            sheetNames.Add("甲方文件总表11");
            sheetNames.Add("甲方文件明细表22");
        }
    }

 你看我初始化的时候 自动调用基类的构造方法 名字默认传“甲方文件报表” ，因为从类的名字上已经体现了，然后只需要传保存文件路径通过base传递给基类构造函数。然后是通过 AdaptiveToData进行数据适配处理 ，不同的报表是不一样的。所以这里需要对方法进行重写。然后调用的时候：

ReportJiafang rpt =new ReportJiafang("d:\\aaa.xlsx");

                    rpt.AdaptiveToData();
                    rpt.Export();

 你看继承和面向对象编程就是有这个威力 ，对同类型的工作进行归纳放到基类处理。而在外部调用又实现了保证接口和流程的统一性。而让子类又能够拥有各自的细节化处理。你如果用面向过程的思维方式来编程 是不是要low很多 特别是处理这种问题的时候。 是不是体现了一种辩证与统一的思想。有位大佬说过，世界是电脑运行的内存 ，类是模板 不占空间， 实例化后就是具体的对象 要在现实世界占空间，接口就是技能，他有开车的技能 那么他实现接口。感觉还是很形象化的。还有某些规律跟世界的运转规律不谋而合 ，比如普创接地系统的联动控制机制 站控如果点了手动则意思代表脱离 不再受中央控制，跟web的css样式表 ，类的virtual方法重新 都是同样的理念。还有U3d里面的3d对象树结构 然后自上而下的 属性影响 数据分配 ，WPF里的数据绑定 logicTree ，virtualTree，也都是类似理念，就像这个社会自上而下的 节点分配一样。

结构设计随想

c#的项目引用 ，项目依赖 ，以前从没想过这个问题。只能上层依赖下层的 或者一个上层依赖多个下层 ，也就是我们平常在项目上做的 右键 添加引用。生成解决方案时 编译时自下而上的编译 就这么个过程。但是不能反向引用 ，下层 怎么在不引用上层的情况下 与上层交互 或者操纵上层的东西 ，也就是所谓的解耦合（把代码分到上下层不同项目就叫解耦合 没网上说的那么高深）通过最近看的一些代码包括s-manager的一些代码 ，感觉中心思想都是在围绕这个做文章。一般能想到的最基础的就是下层弄个接口叫 Ixxx  ，上层去实现 ，上层实例化下层对象的时候 关联上对应实现了接口的对象  ，这样下层对象调用的时候就不会出现调用不到，就这样就实现了控制反转 ，另外加上事件订阅 面向对象的父子类继承虚方法机制 一起撑起整个结构，虽然没见过java 所谓吹过去吹过来的所谓的IOC 也就是指这个套路吧。包括以前李思瑶写的那些，相对来说事件订阅还粗暴简单一点。不要怕把大对象放到一个地方感觉很大的样子放那感觉不是太好 其实只是个引用 根本没啥空间，集中放那比如一个固定的全局的数组里 为的就是有个丝线头在那  ，到用的时候有个抓头，如果各不同对象都继承了统一接口 ，都知道逆变协变 同一父类那到时会存的引用拿出来用的话就能够达到归一统一化，那些框架 和结构设计套路 也就是这么来的而已 ，利用了我刚刚说的这一系列面向对象特性， 并没什么神秘的。

 

一个例子

经过这么多年浸淫，看了一些设计，再怎么也还是有点长进，早就理解到c#面向对象的世界里 一个引用就是一丝线像个挂钩一样 就这样牵出来抓到调用的把柄。比如我想以窗体为基础加一个静态方法输出消息，立即就想到写个静态方法，但是通过一路c++过来的深刻理解 静态方法是没有实例的，于是很自然的想到放一个当前实例的静态变量 静态方法里间接调用。只需要注意初始化时机即可 在窗体载入时初始化 保证调用的时候有东西，这样各处都可以调用了。就这样几句简单的结构就成了：

public partial class Form1 : Form
{
    public static Form1 f1;
    

    private void Form1_Load(object sender, EventArgs e)
    {
        f1 = this;

        //userControl11.bindEvent(this);
    }

    public static void ShowMsg(string msg){
        f1._ShowMsg(msg);
    }

    private void _ShowMsg(string msg){
        this.Invoke(new Action(()=>{
            this.label2.Text = msg;
        }));
    }

    private void btn_test_Click(object sender, EventArgs e)
    {
        Form1.ShowMsg("showmsg test...");
    }
}

又一个例子

窗体有很多子控件，当主窗体想触发某些订阅（定义了自己代码）了的控件动作时，那么就可以简单的直接使用c#自带的 事件和订阅 发布来处理，如果还想降低耦合 子控件在底层项目里怎么办呢，像s-manager里一样 底层项目定义Ixxx  主窗体实现接口 ，子控件初始化时把实现了接口的窗体自己传过去 ，子控件自己订阅并写事件自定义代码：

位于library项目的代码

public interface Iform
{
    EventHandler<MyArgs> MyEvent { get; set; }
}

public class MyArgs:EventArgs
{
    public string data { get; set; }
}

public partial class UserControl1 : UserControl
{
    public UserControl1()
    {
        InitializeComponent();
    }

    public void bindEvent(Iform f1)
    {
        f1.MyEvent += new EventHandler<MyArgs>((sender, args) =>
        {
            label1.Text = args.data;
        });
    }
    private void UserControl1_Load(object sender, EventArgs e)
    {

    }
}

拖动用户控件到主项目，主窗体的代码：

public partial class Form1 : Form, Iform
{
    

    private void Form1_Load(object sender, EventArgs e)
    {

        userControl11.bindEvent(this);
    }
    public EventHandler<MyArgs> MyEvent
    {
        get;
        set;
    }
    private void btn_test_Click(object sender, EventArgs e)
    {
        MyEvent(this,new MyArgs(){ data= "userevent subscrip test..."});
    }
}

 又一个例子

比如我们想让整个解决方案所有地方都调用一个叫ShowMsg的函数 起到中枢控制作用或直接展示信息，那么毫无疑问这个函数只能放在底层，但是上层有winform窗体我们想让ShowMsg能把信息展示到上层窗体，怎么做呢，还是只能在接口上做文章，上层继承接口把自己的实例传下去，这样调用 Logger.GetInstance().AppendMsg("loginfo test..."); 无论上下层 何处都可以进行日志记录。注意在开始的时候设置处理接口SetCurrentProc

library项目代码

public interface Iform
{
    void AppendMsg(string msg);
}

public class Logger
{
    private static Logger loger;
    private Logger()
    {

    }
    public static Logger GetInstance()
    {
        if (loger == null)
            loger = new Logger();
        return loger;
    }

    Iform f1;
    public void SetCurrentProc(Iform _f1)
    {
        f1 = _f1;
    }
    public void AppendMsg(string msg){
        if (f1 != null)
            f1.AppendMsg(msg);
    }
}

上层项目窗体代码

public partial class Form1 : Form, Iform
{
    public void AppendMsg(string msg)
    {
        this.Invoke(new Action(() => {
            this.label2.Text = msg;
        }));
    }
    private void Form1_Load(object sender, EventArgs e)
    {
        Logger.GetInstance().SetCurrentProc(this);
    }
   
    private void btn_test_Click(object sender, EventArgs e)
    {
        Logger.GetInstance().AppendMsg("loginfo test...");
    }
}