程序设计选择接口还是选择基类？那个更适合。

最新推荐文章于 2020-03-01 15:33:39 发布
最新推荐文章于 2020-03-01 15:33:39 发布
阅读量713 收藏
点赞数
分类专栏： C#.NET 文章标签： .NET 设计 继承
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dengjc2011/article/details/78676838
版权

接口VS基类，应该如何选择哪？

首先判断类之间关系（业务关系），代码重用性，接口与基类区别，代码是否可重编译。

1、类之间关系 如是is_a 关系的那选择基类，如苹果属于水果类吗 ？ 是的 那应选择基类方式来已继承方式。

2、代码重用性，如果各个类中有重复方法过程，那就最好选择基类继承方式来减少重复代码复制。

3、接口与基类，继承区别：子类只能继承一个基类，但可以实现多个接口。

4、接口如有修改变化那实现子类将会强迫实现接口中的变化，而基类方式不一定要强迫子类去修改，可不重新编译源代码。

实例代码如下：

    

/// <summary>
    /// 激光雷达数据解析基类
    /// </summary>
    public abstract class  ReadLidarDataBase
    {

        /// <summary>
        /// 文件存放路径
        /// </summary>
        public string FilsPath { get; set; }

        /// <summary>
        /// 最小数据高度（千米）
        /// </summary>
        public double MinDataHeight { get; set; }
        /// <summary>
        /// 最大数据度度（千米）
        /// </summary>
       public double MaxDataHeight { get; set; }

        /// <summary>
        /// 查询结果类型
        /// </summary>
        public  RadarDataType RadarType { get; set; }

        /// <summary>
        /// 查询时间
        /// </summary>
        public DateTime QueryTime { get; set; }

        /// <summary>
        /// 解析后数据列表
        /// </summary>
        public List<LidarDataItem> _radarbaselist = new List<LidarDataItem>();


        /// <summary>
        /// 错误信息
        /// </summary>
        public string ErorStr { get; set; }

        /// <summary>
        /// Char 数据中的最大值（正常取数据数据列表中最大值）
        /// </summary>
        public double CharvisualMap_MaxValues { get; set; }
        /// <summary>
        /// 加载数据 
        /// </summary>
        /// <param name="filspath"></param>
        /// <param name="radartype"></param>
        /// <param name="queryTime"></param>
        public  virtual void LoadData(string filspath, RadarDataType radartype, DateTime queryTime)
        {
            FilsPath = filspath;
            RadarType = radartype;
            QueryTime = queryTime;
             
        }

        /// <summary>
        /// 前台显示EChar结果 
        /// </summary>
        /// <returns></returns>
        public virtual string RadarCharts()
        {
            try
            {
                StringBuilder sbxdata = new StringBuilder();
                sbxdata.Append("[ ");
                StringBuilder sbydata = new StringBuilder();
                sbydata.Append("[ ");
                StringBuilder sbdata = new StringBuilder();
                sbdata.Append("[ ");
                List<double> whereheight = new List<double>();

                var hlist = from s in _radarbaselist
                            where whereheight.Contains(s.Height)
                            select s;
                var querywhereheight = _radarbaselist.Where(p => p.Height <= MaxDataHeight && p.Height >= MinDataHeight);

                var query = querywhereheight.GroupBy(p => p.DataTime);

                List<double> queryHeight = querywhereheight.Select(p => p.Height).Distinct().ToList();
                double maxvalues = 0;
                if (CharvisualMap_MaxValues == 0)
                {
                    maxvalues = Math.Ceiling(querywhereheight.Max(p => p.Valeu));

                }
                else
                {
                    maxvalues = CharvisualMap_MaxValues;
                }
                queryHeight.Sort();
                int x = 0;
                int y = 0;
                foreach (var itemtime in query)
                {
                    DateTime dt = itemtime.Key;
                    if (x == 0)
                    { sbxdata.Append("'" + dt.ToString("dd日HH时mm分") + "'"); }
                    else
                    { sbxdata.Append(",'" + dt.ToString("dd日HH时mm分") + "'"); }
                    var hlistitme = itemtime.OrderBy(p => p.Height);
                    y = 0;
                    foreach (var item in hlistitme)
                    {
                        sbdata.Append("[" + x + "," + y + "," + item.Valeu + "],");
                        y++;
                    }
                    x++;
                }
                sbxdata.Append(" ]");
                var data = sbdata.ToString();
                if (data.Length > 0)
                {

                    data = data.Remove(data.Length - 1, 1);
                }
                data = data + " ]";
                //Ydata
                for (int i = 0; i < queryHeight.Count; i++)
                {
                    if (i == 0)
                    {
                        sbydata.Append(queryHeight[i]);
                    }
                    else
                    {
                        sbydata.Append("," + queryHeight[i]);
                    }
                }
                sbydata.Append("]");
                // end Ydata
                string result = "";
                StringBuilder sb = new StringBuilder();
                sb.Append("  {");
                sb.Append("tooltip: {");
                sb.Append("          },");
                sb.Append(" grid: {");
                //sb.Append("    right: 10,");
                sb.Append("    bottom : 10,");
                sb.Append("     left: '50'");
                sb.Append(" },");
                sb.Append(" title: {");
                sb.Append("text: '" + this.QueryTime.ToString("yyyy年MM月dd日HH点  ") + RadarDataTypeNamecs.GetRadarDataTypeName(this.RadarType) + "',");
                sb.Append("top: 20,");
                sb.Append("left: 'center'");
                sb.Append(" },");
                sb.Append("  xAxis: {");
                sb.Append("     type: 'category',"); // splitNumber:10
                sb.Append("     splitNumber:80,"); // splitNumber:10
                sb.Append("   data: " + sbxdata.ToString());
                sb.Append("},");
                sb.Append(" yAxis: {");
                sb.Append("   name: '高度(km)',");
                sb.Append("   nameLocation: 'middle',");
                sb.Append("   nameGap: 60,");
                sb.Append("   type: 'category',");
                sb.Append("   data: " + sbydata.ToString());
                sb.Append("},");
                sb.Append("  visualMap: {");
                // sb.Append("  type: 'piecewise',");
                sb.Append("     min: 0,");
                sb.Append("  max: " + maxvalues + ",");
                sb.Append("  calculable: true,");
                sb.Append("  realtime: false, ");
                sb.Append("  x: 'right',");
                // sb.Append("    splitNumber: 6,");   
                sb.Append("    inRange: {");
                sb.Append("        color: [ '#0066FF', '#00FF99',  '#FFFF00', '#FF0000', '#FF0000', '#FF0000']");
                sb.Append("     }");
                sb.Append("  },");
                sb.Append(" series: [{");
                sb.Append("     name: '值',");
                sb.Append("      type: 'heatmap',");
                sb.Append("      data: " + data + ",");
                sb.Append("      itemStyle: {");
                sb.Append("          emphasis: {");
                sb.Append("              borderColor: '#333',");
                sb.Append("              borderWidth: 1");
                sb.Append("          }");
                sb.Append("      },");
                sb.Append("       progressive: 1000,");
                sb.Append("       animation: false");
                sb.Append("    }]");
                sb.Append("};");
                result = sb.ToString();
                return result;
            }
            catch (Exception ex)
            {

                return "";
            }
        }

    }
子类 1： 
 public class LidarData_ZKGD : ReadLidarDataBase
    {

        List<DateTime> _listDatatime = new List<DateTime>();
        
        public LidarData_ZKGD()
        {
            MinDataHeight = 0.2;
            MaxDataHeight = 5.01;
        }

        /// <summary>
        /// 加载数据
        /// </summary>
        public override void LoadData(string filspath, RadarDataType radartype, DateTime queryTime)
        {
            base.LoadData(filspath, radartype, queryTime);
            string datapath = FilsPath + @"//" + RadarType.ToString() + "_" + QueryTime.ToString("yyyyMMddHH") + ".txt";
            if (!File.Exists(datapath))
            {
                ErorStr = "文件不存在";
                return;
            }
            using (StreamReader fs = new StreamReader(datapath))
            {
                string linestri = "";
                int row = 0;
                while ((linestri = fs.ReadLine()) != null)
                {
                    if (row == 0) //头
                    {
                        ResolveHeadData(linestri);
                    }
                    else
                    {
                        double dataheight = 0;
                        var rowllist = ResolveRowData(RadarType, linestri, ref dataheight);
                        if (dataheight >= MinDataHeight && dataheight <= MaxDataHeight)
                        {
                            _radarbaselist.AddRange(rowllist);
                        }
                    }
                    row++;
                }
            }
            if (_radarbaselist.Count == 0)
            {

                ErorStr = "数据为空";

            }
            //测试代码
            //string datapath2 = FilsPath + @"//" + "vag_" + QueryTime.ToString("yyyyMMddHH") + ".txt";
            //using (StreamWriter sr = File.CreateText(datapath2))
            //{
            //    foreach (var item in _radarbaselist)
            //    {
            //        string s = item.DataTime + " " + item.Height + " " + item.Valeu;
            //        sr.WriteLine(s);
            //    }
            //}
        }

      
        /// <summary>
        /// 解析头数据
        /// </summary>
        /// <param name="headstr"></param>
        /// <returns></returns>
        bool ResolveHeadData(string headstr)
        {
            string[] arrstr = headstr.Split(',');
            if (arrstr.Length < 2) //空数据
            {
                return false;
            }
            else
            {
                //从第二数据开始
                for (int i = 1; i < arrstr.Length; i++)
                {
                    string dt = arrstr[i];
                    if (dt.Length > 0)
                    {
                        DateTime dtime;
                        if (DateTime.TryParse(dt, out dtime))
                        {
                            _listDatatime.Add(dtime);
                        }
                        else
                        {
                            return false;
                        }
                    }

                }
                return true;
            }
        }

        /// <summary>
        /// 解析行数据
        /// </summary>
        /// <param name="headstr"></param>
        /// <returns></returns>
        List<LidarDataItem> ResolveRowData(RadarDataType datatype, string datarowstr, ref double height)
        {
            List<LidarDataItem> listdatarows = new List<LidarDataItem>();
            string[] arrstr = datarowstr.Split(',');
            if (arrstr.Length == 0) //空数据
            {
                return null;
            }
            else if (arrstr.Length - 2 != _listDatatime.Count)
            {
                return null;
            }
            else
            {
                //高度
                height = double.Parse(arrstr[0]);
                //从第二数据开始
                for (int i = 1; i < arrstr.Length; i++)
                {
                    if (arrstr[i].Length > 0)
                    {
                        DateTime datatime = _listDatatime[i - 1];
                        string dt = arrstr[i];
                        double values;
                        if (double.TryParse(dt, out values))
                        {
                            ///Console.WriteLine("datatime={0},height={1},valel={2}", datatime, height, values);
                            listdatarows.Add(new LidarDataItem() { DataTime = datatime, DataType = datatype, Height = height, Valeu = values });
                        }
                        else
                        {
                            return null;
                        }
                    }
                }

            }
            return listdatarows;
        }

      


    }
子类2： 

public class LidarData_LD : ReadLidarDataBase
    {
        public LidarData_LD()
        {
            MinDataHeight = 0.1;
            MaxDataHeight = 3.1;
            CharvisualMap_MaxValues = 2;
        }

        /// <summary>
        /// 加载数据 
        /// </summary>
        public override void LoadData(string filspath, RadarDataType radartype, DateTime queryTime )
        {
            base.LoadData(filspath, radartype, queryTime);
            LoadData();
        }

        void LoadData()
        {
            var filepathlist = LoadDataFileName();
            foreach (var item in filepathlist)
            {
                using (StreamReader fs = new StreamReader(item))
                {
                    string linestri = "";
                    int row = 0;
                    LidarDataItem HeadData = new LidarDataItem();
                    double bgheight = 15; //15米  
                    while ((linestri = fs.ReadLine()) != null)
                    {
                        if (row == 0) //头
                        {
                            ResolveHeadData(linestri, ref HeadData);
                        }
                        else if (row >= 7)
                        {
                            double dataheight = 0;
                            var datarow = ResolveRowData(RadarType, linestri, HeadData, bgheight);
                            //if (dataheight >= MinDataHeight && dataheight <= MaxDataHeight)
                            {
                                _radarbaselist.Add(datarow);
                            }
                            bgheight += 15;
                        }
                        row++;
                    }
                }
                if (_radarbaselist.Count == 0)
                {

                    ErorStr = "数据为空";

                }

            }

            测试代码
            //string datapath2 = FilsPath + @"//" + "vag_" + QueryTime.ToString("yyyyMMddHH") + ".txt";
            //using (StreamWriter sr = File.CreateText(datapath2))
            //{
            //    foreach (var item in _radarbaselist)
            //    {
            //        string s = item.DataTime + " " + item.Height + " " + item.Valeu;
            //        sr.WriteLine(s);
            //    }
            //}
        }

        /// <summary>
        /// 加载数据文件 
        /// 如：2017-10-10 08:00数据，开始时间是2017-10-9 08:00 到2017-10-10 08:00文件
        /// </summary>
        /// <returns></returns>
         List<string> LoadDataFileName()
        {
            List<string> FilePathList = new List<string>();

            //开始时间  QueryTime 
            DateTime bgtime = QueryTime.AddDays(-1);
            DateTime endtime = QueryTime;
            while (bgtime <= endtime)
            {
                string datapath = FilsPath + bgtime.ToString("yyyyMM") + "\\";
                string getfilename = "HF" + bgtime.ToString("yyyyMMddHH");///HF2017112408
                DirectoryInfo dataDir = new DirectoryInfo(datapath);
                if (dataDir.Exists)
                {
                    foreach (var item in dataDir.GetFiles())
                    {
                        string filename = item.Name;
                        string filenametime = filename.Split('.')[0];
                        if (getfilename == filenametime)
                        {
                            FilePathList.Add(item.FullName);
                        }
                    }

                }
                else
                {
                    ErorStr = datapath + "数据目录不存在";
                }
                if (FilePathList.Count == 0)
                {
                    ErorStr = datapath + "数据目录下无文件";
                }
                bgtime = bgtime.AddHours(1);
            }
            return FilePathList;
 
        }


        /// <summary>
        /// 解析头数据
        /// </summary>
        /// <param name="headstr"></param>
        /// <returns></returns>
        bool ResolveHeadData(string headstr,ref LidarDataItem dt )
        {
           
            string[] arrstr = headstr.Split(';');
            if (arrstr.Length < 2) //空数据
            {
                return false;
            }
            else
            {
                dt.Latitude = arrstr[1];
                dt.Longitude = arrstr[2];
                dt.DataTime =DateTime.Parse( arrstr[3]);
                return true;
            }
        }

        /// <summary>
        /// 解析行数据
        /// </summary>
        /// <param name="headstr"></param>
        /// <returns></returns>
        LidarDataItem  ResolveRowData(RadarDataType datatype, string datarowstr, LidarDataItem headdata,double height)
        {
             LidarDataItem  listdatarows =new  LidarDataItem();
            string[] arrstr = datarowstr.Split(';');
            if (arrstr.Length == 0) //空数据
            {
                return null;
            }
            else
            {
                string strvalues="";
                switch (datatype)
                {
                    case RadarDataType.depol:
                        strvalues = arrstr[3];
                        break;
                    case RadarDataType.extin355:
                        strvalues = arrstr[0];
                        break;
                    case RadarDataType.extin532:
                        strvalues = arrstr[1];
                        break;
                    case RadarDataType.extin1064:
                        strvalues = arrstr[2];
                        break;
                    case RadarDataType.kly:
                        strvalues = arrstr[4];
                        break;
                    default:
                        break;
                }
                double values;
                if (double.TryParse(strvalues, out values))
                {
                    listdatarows.DataTime = headdata.DataTime;
                    listdatarows.DataType = datatype;
                    listdatarows.Height = height/1000; //千米
                    listdatarows.Valeu = values;
                    listdatarows.Longitude = headdata.Longitude;
                    listdatarows.Latitude = headdata.Latitude;
                }
                else
                {
                    return null;
                }

            }
            return listdatarows;
        }
       
      
    }


      

会飞的鱼_dengjc
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python程序设计：ipwhois模块与pprint模块.pptx
06-12
ipwhos.lPWhoi是包装RDAP和Legacy' Whoi查找的基类。 Ipwhois模块 Ipwhois安装 Socket模块 网络通信 Socket：低层网络接口(每个BSD API)。 socket.socket(family, type)：创建并返回一 个新的socket对象。 socket....
Java接口、基类、抽象类详解（图解接口、继承和实现、基类和抽象类的区别等）——Java基础系列
代码之狐的博客
12-30 1554
用简单的图例解答接口、基类、抽象类之间这些概念和区别，丰富和夯实Java基础知识
[C++] - 纯虚函数 & 抽象基类 & 接口类
浮生的博客
03-01 488
翻译自：https://www.learncpp.com/cpp-tutorial/126-pure-virtual-functions-abstract-base-classes-and-interface-classes/ 1.纯虚函数和抽象基类 C++允许我们创建一种特别的虚函数：纯虚函数(pure virtual function)(或者叫抽象函数abstract functio...
抽象基类与接口区别
he138060的博客
06-21 586
抽象基类与接口区别　联系　使用范围详解抽象基类与接口，共性与个性的选择 C#中的抽象基类(Abstract Class)和接口(Interface)都实现了面向对象中的继承机制，它们通过定义抽象方法匀实现了对继承类的功能上的约束，那么在如何在恰当的场景选择恰当的继承机制是我们在设计中经常会遇到的问题，我们先来对比两者之间的区别与联系。 相同点 都可以被继承。 本身都不能被实例...
C# 关于接口与基类的理解（二者的区别）
weixin_30595035的博客
04-22 387
接口（接口的名称一般用大写字母I开头的）是把公共实例（非静态）方法和属性组合起来，以封装特定功能的一个集合。（其实，接口简单理解就是一种约定，使得实现接口的类或结构在形式上保持一致） 注意：使用接口可以使程序更加清晰和条理化，这就是接口的好处，但并不是所有的编程语言都支持接口，C#是支持接口的。注意，虽然在概念上，C#接口类似于COM接口，但他们的底层结构是不同的。那么，我们来看一下如何声...
Java程序的设计思想
12-22
java程序设计要满足SOLID+2七大原则，，，，。 　一、开-闭原则：对扩展开放，对修改关闭，即我们如果要设计一个程序，需要想到该程序可能变化的部分，使以后程序变化时不需要修改已存在的代码，而是应该直接加入新...
程序设计课程作业：基于QT的通讯录管理系统.zip
08-03
Qt是一个用标准C++编写的跨平台开发类库，它对标准C++进行了扩展，引入了元对象系统、信号与槽、属性等特性，使应用程序的开发变得更高效。 Qt类库中大量的类以模块形式分类组织的，包括基本模块和扩展模块等。一个...
面向对象C++编程及可视化程序设计资料
06-01
方便读者更顺利地掌握一个完整的应用程序的开发方法及相关知识点 突出重点 偏重应用：本书对常用的知识点都配有应用实例 通过实例 突出重点应用 通俗易懂 方便自学：本书中的函数代码和例题代码都配有详细的功能...
程序设计作业： p2p聊天系统 qt写的界面 C++实现.zip
最新发布
08-03
Qt是一个用标准C++编写的跨平台开发类库，它对标准C++进行了扩展，引入了元对象系统、信号与槽、属性等特性，使应用程序的开发变得更高效。 Qt类库中大量的类以模块形式分类组织的，包括基本模块和扩展模块等。一个...
使用接口还是基类
sxfcct的专栏
12-18 1355
使用接口还是继承，关键是看使用方的需求。 如果要使用的对象是使用方的组成部分，则使用基类，继承方式 如果和使用方关系不大，只是辅助作用完成计算，通知，获取数据之类，用接口
如何选择抽象基类与接口 区别
记事本
09-07 858
抽象基类与接口，共性与个性的选择 C#中的抽象基类(Abstract Class)和接口(Interface)都实现了面向对象中的继承机制，它们通过定义抽象方法匀实现了对继承类的功能上的约束，那么在如何在恰当的场景选择恰当的继承机制是我们在设计中经常会遇到的问题，我们先来对比两者之间的区别
接口与基类
欢迎来到我的博客！我是一名拥有10年以上经验的系统架构师。在这个博客中，我将与大家分享我在C#、JavaScript、Python、Docker、SQL和Rust等领域的知识与经验。 作为一名技术爱好者，我相信技术的力量可以改变世界。
06-14 1503
为什么在设计时，一定要定义接口和执行接口的基类，而不是直接定义基类。其中的理由有很多，有一点解释可以确定：二八原则 在分析过程中，你可以预见到80%的公共行为，甚至会更多。这些行为可以放在基类中完成。 但是就算是你的遇见性再强，总是有你不能看到的地方是没有包含在那80%里面的，剩下的部分就需要你重新定义执行方法。 不管这些新的执行方法的执行方式与之前定义的基类有多大的不同，这都没有什么
接口、基类、子类
面朝大海，春暖花开
10-28 1296
1、定义一个接口 interface BaseInterfa { void GetLogion(); void RetureLogion(); }
c#中接口和基类的问题
bmob的博客
05-17 2404
c#中接口和基类的问题（按照程序运行顺序显示代码）程序入口namespace duojic { class Program { static void Main(string[] args) { myinterface jk = new myfunction(); int a=jk.add(1, 2);
C#应该设计基类还是接口
陈云佳的专栏
06-04 789
未完待续
基类和接口
iteye_721的博客
08-20 215
接口在java编程中有极大的作用,对团队来说,更是不可或缺的部分。 接口中的方法往往是“哑”方法，即，在接口中，只有方法的声明，没有方法的具体实现。 接口和内部类为我们提供了一种将接口与实现分离的更加结构化的方法。 复用代码的其中一种形式是 客户端程序员遵循该接口来编写他们自己的类。 关键字的使用以及语法： Java中的多重继承 interface CanFight{ ...
面向对象程序设计多态性怎么理解？
02-07
面向对象程序设计中的多态性指的是一个接口有多种不同的实现方式。例如，在一个类的层次结构中，基类可以定义一个方法，然后由派生类来覆盖和实现这个方法。这样，当调用这个方法时，可以根据调用方法的对象类型来...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值