编程C,C ++,Java,PHP,Ruby,图灵,VB
计算机科学加拿大 
编程C,C ++,Java,PHP,Ruby,图灵,VB  

用户名:   Password: 
 登记登记   

 Wiki.Wiki.   博客博客   搜索搜索   图灵图灵   聊天室  成员成员 
 对OOP的思考
指数 -> 一般编程
查看上一个主题 可打印的版本 下载主题订阅本主题私人信息刷新页面 查看下一个主题
作者 信息
WTD.




邮政发布: 2005年7月11日星期一:下午5:41  帖子主题:OOP上的思考

什么是面向对象的编程?这是一个非常复杂的问题,一个是一个你的问题,你将没有缺乏独特的答案。

也许我们应该问:为什么要使用面向对象的技术?

有些人使用OOP,因为他们被告知他们必须冷静,或者因为他们的老板告诉他们使用“类”关键字或找到新作业。

好的 原因是不同的。面向对象的编程为我们提供了一个漂亮的Darn,可以考虑编程,以及一个真正的自然。

当你环顾世界时,你会看到事情。当你与事物互动时,你很少知道他们真正工作的工作,甚至更频繁地知道你需要知道。

例如,让我们来看看创建一个窗口并使其可见。

代码:
w =窗口()
w.set_title.("hello world")
W.Show.()


请注意我们从未关心窗口的内部状态。直接没有变量变化。我们告诉窗口做了什么,它做到了。

当然,当我们决定创建自己的对象时,我们不能如此无浅。然后我们必须担心内部状态和可以修改和访问该状态的方式。

也就是说,您使用的状态应该是您决定的最后一件事之一。首先,您应该决定您的对象如何向外界期望。在这种情况下,我们希望向用户提供使用某些数据构建对象本身的机会。第一个和姓氏就足够了。

然后我们希望让用户获得第一个和姓氏的能力,但是 不是 修改它们。最后,我们希望能够将全名作为单个实体获取。

现在我们有那么下来,让我们想到这个国家。

我们可以存储一个字符串,其中一个由空格分隔的名字和姓氏。然后,当我们想要第一个或姓氏时,只需在内部拆分该空间并返回相关件。

但真的,这太复杂了。相反,让我们将个别名称存储为单独的变量,只能在必要时组合它们。

在许多编程语言中:

红宝石:
班级名称
   在tr_reader. :first, :last
 
   def initialize(第一的,last)
     @first,@last =首先,最后
   结尾

   def full_name
      “#{@ first}#{@ last}”
   结尾
结尾


C ++:
班级名称
{
   私人的:
      std::细绳名,last_name;
   上市:
      Name(STD.::细绳 F, std::细绳 l)
      : first_name(f), 姓(l)
      { }

      std::细绳 first() const
      {
         返回名;
      }

      std::细绳 last() const
      {
         返回 last_name;
      }

      std::细绳 full_name() const
      {
         返回 first() + + last();
      }
};


java.:
班级 名称
{
   私人的 细绳 firstName, lastName;

   上市 名称(细绳 F, 细绳 l)
   {
      firstName = f;
      lastName = l;
   }

   上市 细绳 first()
   {
      返回 firstName;
   }

   上市 细绳 last()
   {
      返回 lastName;
   }

   上市 细绳 fullName()
   {
      返回 first() + + last();
   }
}


c-sharp:
班级名称
{
   私有字符串FirstName,LastName;

   public Name(string f, string l)
   {
      firstName = f;
      lastName = l;
   }

   public string First
   {
     得到{返回名字; }
   }

   public string Last
   {
     获取{返回姓名; }
   }

   公共字符串全名称
   {
     得到{返回它。首先() + " " + this.Last(); }
   }
}


现在,让我们看看我们可以创建名称对象的轻松,并获得各种方法“免费”。

红宝石:
bobs_name. = name。新的("鲍勃", "史密斯")
putbobs_name.。全名


C ++:
名称bobs_name.("鲍勃", "史密斯");
STD.::COUT. << bobs_name.全名() << std::终止;


java.:
名称 Bobsname. = 新的 名称("鲍勃", "史密斯");
系统.出去.打印ln.(Bobsname..全名());


c-sharp:
名称bobsname =新名称("Bob", "Smith");
console.writeline.(bobsName.FullName());


但如果我们可以更好地“免费”,怎么办?在真理中,以这种方式打印出全名可能是我们最常处理的,因此我们不希望在我们的代码中包含该方法调用。

这是一定程度的多态性进来的地方。Wen我们在java中称之为“system.out.println()”。我们可以为此提供许多类型的对象,它只是有效。

如何?

因为所有这些对象都有一个ToString()方法,即PrintLN方法调用。让我们来看看我们为每个名称类实现这一切。

红宝石:
班级名称
   在tr_reader. :first, :last
 
   def initialize(第一的,last)
     @first,@last =首先,最后
   结尾

   def full_name
      “#{@ first}#{@ last}”
   结尾

   别名 :to_s. :full_name
结尾


C ++:
班级名称
{
   私人的:
      std::细绳名,last_name;
   上市:
      Name(STD.::细绳 F, std::细绳 l)
      : first_name(f), 姓(l)
      { }

      std::细绳 first() const
      {
         返回名;
      }

      std::细绳 last() const
      {
         返回 last_name;
      }

      std::细绳 full_name() const
      {
         返回 first() + + last();
      }

      朋友STD.::Ostream.& operator<<(STD.::Ostream.& out, const名称& n)
      {
         返回出去<< n.全名();
      }
};


java.:
班级 名称
{
   私人的 细绳 firstName, lastName;

   上市 名称(细绳 F, 细绳 l)
   {
      firstName = f;
      lastName = l;
   }

   上市 细绳 first()
   {
      返回 firstName;
   }

   上市 细绳 last()
   {
      返回 lastName;
   }

   上市 细绳 fullName()
   {
      返回 first() + + last();
   }

   上市 细绳 toString()
   {
      返回 fullName();
   }
}


c-sharp:
班级名称
{
   私有字符串FirstName,LastName;

   public Name(string f, string l)
   {
      firstName = f;
      lastName = l;
   }

   public string First
   {
     得到{返回名字; }
   }

   public string Last
   {
     获取{返回姓名; }
   }

   公共字符串全名称
   {
     得到{返回它。首先() + " " + this.Last(); }
   }

   公共字符串ToString.()
   {
     返回这个.Fullname;
   }
}


现在我们可以自由地写作:

红宝石:
bobs_name. = name。新的("鲍勃", "史密斯")
put bobs_name


C ++:
名称bobs_name.("鲍勃", "史密斯");
STD.::COUT. << bobs_name << std::终止;


java.:
名称 Bobsname. = 新的 名称("鲍勃", "史密斯");
系统.出去.打印ln.(Bobsname.);


c-sharp:
名称bobsname =新名称("Bob", "Smith");
console.writeline.(bobsName);


但是,对象导向可以在继承时真正展示它的力量。继承定义了“是-A”的关系。这意味着随着类型系统所关注的是,子类的对象可以访问父类的对象已经能够去。

我们可以随时与互动Ruby解释器看到这一点。

代码:
IRB.(main):001:0> class A
IRB.(main):002:1> end
=> nil
IRB.(main):003:0> class B < A
IRB.(main):004:1> end
=> nil
IRB.(main):005:0> B.new.is_a? A
=> true


但是如何适用于我们一直在努力的名称课程?

嗯,如果我们想要一个包含标题的名称类以及名字和姓氏,那么我们可以很容易地创建一个全新的课程。

红宝石:
班级拼写名称
   在tr_reader. :title, :first, :last
 
   def initialize(标题,first, last)
     @title,@first,@last = title,首先,最后
   结尾

   def full_name
      “#{title}#{@ first}#{@ last}”
   结尾

   别名 :to_s. :full_name
结尾


但是,一个铭文真的“是”名字,不是吗?我们可以轻松使用它,就像我们名字一样。那么如果通过继承名称类,我们会怎样呢?

通过这样做,我们可以利用我们为我们的名称类编写的代码。

红宝石:
班级拼写名称 < Name
   在tr_reader. :title
 
   def initialize(标题,first, last)
      极好的(第一的,last)
      @title= title
   结尾

   def full_name
      “#{title}#{super}”
   结尾
结尾


这里“超级”是对父(或超级)类中存在的方法的调用。

当然,“超级”通常具有不同语言的含义。例如,在Java和C-Sharp中,它基本上是“这个”,而是被视为上一类的对象。

让我们来看看。

C ++:
班级: 上市名称
{
   私人的:
      std::细绳 name_title;
   上市:
      FormalName(STD.::细绳 T, std::细绳 F, std::细绳 l)
      : Name(F,L.)
      , name_title(t)
      { }

      std::细绳 title() const
      {
         返回 name_title;
      }

      std::细绳 full_name() const
      {
         返回 title() + + Name::全名();
      }
};


java.:
班级拼写名称 延伸 名称
{
   私人的 细绳 nameTitle;

   上市拼写名称(细绳 T, 细绳 F, 细绳 l)
   {
      super(F,L.);
      nameTitle = t;
   }

   上市 细绳 title()
   {
      返回 nameTitle;
   }

   上市 细绳 fullName()
   {
      返回 title() + + super.全名();
   }
}


c-sharp:
班级: Name
{
   私有字符串nametitle;

   public FormalName(字符串t,string f,string l)
   : base(f, l)
   {
      nameTitle = t;
   }

   public string Title
   {
     得到{返回nametitle; }
   }

   公共字符串全名称
   {
     获取{返回this.title +" " + super.FullName; }
   }
}


现在,让我们看一下较差的琐碎榜样。使用Python及其HTMLParser类,我们希望计算HTML文档中的锚标记数。

面向对象的编程如何进入这一点?

嗯,HTMLParser类包含“Feed”成员函数,通过将源代码馈送到解析器中。由于它遇到不同类型的标签和数据,它调用其他成员函数。默认情况下,HTMLParser对我们无用,因为它对每个处理程序都没有任何作用。

但所有的基础都到位了。我们可以子类(或继承)HTMLParser,覆盖这些成员函数中的一些,并具有一个工作解析器。

Python:
HTMLParser. 进口 HTMLParser.

班级 MyParser(HTMLParser.):
   def __在里面__(自己):
      HTMLParser..__在里面__(自己)
      自己.__ anchor_count = 0
   def handle_starttag(自己,标签,attrs):
      如果 标签==. '一种':
         自己.anchor_count. + = 1
   def __get_anchor_count(自己):
      返回 自己.__ anchor_count.
   def __set_anchor_count(自己,new_count.):
      自己.__ anchor_count = new_count
   anchor_count = 财产(__get_anchor_count.,__set_anchor_count.)


现在,当我们想要计算锚标签时,我们只需要:

Python:
HTML. =. “这里的一些HTML”

p = myparser.()
p。喂养(HTML.)
打印 p.anchor_count.


我们可以在没有继承的情况下轻松编写自定义的HTML解析器吗?不是一个机会。大多数是额外的代码,漂亮它(anchor_count属性)。

对面向对象的编程来说,这一点是这样的,但希望这一直很好地看看它基本上是什么。请随时提出问题并要求进一步解释。
赞助
赞助
赞助
赞助
托尼




邮政发布: 2005年7月11日星期一:下午5:52  帖子主题:(没有主题)

总是伟大的。请再次提醒我为什么不发布书籍? 微笑

即使我已经熟悉OOP,也很愉快。让我想起了我多么喜欢红宝石和讨厌c ++ 笑
WTD.




邮政发布: 2005年7月11日星期一:下午9:53  帖子主题:(没有主题)

谢谢你的外部验证。 微笑
[Gandalf]




邮政发布: 2005年7月11日星期一晚上10:20 PM  帖子主题:(没有主题)

写得很好和解释。我花了一个多小时的时间试图理解它。它清除了一些关于OOP的事情,但我看到它是一个非常大的主题,我在C ++中我太早了解它。我缺乏对所有其他语言的了解,所以我试图跟随C ++,有时会看看Java。我仍然不明白私人和公共会员如何工作,如果用户想要更改“First_Name”,那就怎么了。你会在那个课堂上调用一个函数来改变它吗?

我也将不得不查找“朋友函数”和其他一些概念,但现在我对我更加了解的时候我有很好的参考 微笑.

对于Leedign Oop,你认为我应该看看Java而不是C ++吗?似乎语法越来越容易,而且似乎更简单了解。


也许这应该被粘在一起? OOP可能是现在编程中最重要的概念之一。
Lyam_kaskade




邮政发布: 2005年7月11日星期一晚上10:53  帖子主题:(没有主题)

[Gandalf]写道:

对于Leedign Oop,你认为我应该看看Java而不是C ++吗?似乎语法越来越容易,而且似乎更简单了解。


不是我是专家,但如果你想学习OOP,最好的语言可能是Ruby。我刚刚开始了几天前,它很棒。让我想知道为什么人们甚至使用C ++了。[/ Quote]
WTD.




邮政发布: 2005年7月11日星期一晚上10:54 PM  帖子主题:(没有主题)

[Gandalf]写道:
我仍然不明白私人和公共会员如何工作,如果用户想要更改“First_Name”,那就怎么了。你会在那个课堂上调用一个函数来改变它吗?


私人会员无法在课程之外访问。

公共会员可以在课程之外访问。

定义了类时,您不会更改First_Name。这是班级设计的一部分。我不希望名称能够改变。通过AKING那些变量私有,而不允许访问课程外部, 通过不提供任何成员函数来改变名称......通过做所有这些,我确保没有人可以改变名称的内部状态。

但有一种方法。

除了公共和私人之外,还有第三个限定符。它被称为“受保护”。这意味着成员仍然无法访问课程,但是子类可以访问该成员。

如果我写了名称课程:

C ++:
班级名称
{
   保护:
      std::细绳名,last_name;
   上市:
      Name(STD.::细绳 F, std::细绳 l)
      : first_name(f), 姓(l)
      { }

      std::细绳 first() const
      {
         返回名;
      }

      std::细绳 last() const
      {
         返回 last_name;
      }

      std::细绳 full_name() const
      {
         返回 first() + + last();
      }

      朋友STD.::Ostream.& operator<<(STD.::Ostream.& out, const名称& n)
      {
         返回出去<< n.全名();
      }
};


然后我可以编写一个子类,允许我设置第一个和姓氏。

C ++:
塑造 mutableName. : 上市名称
{
   MutableName(STD.::细绳 F, std::细绳 l)
   : Name(F,L.)
   { }

   空白 set_first(STD.::细绳 f)
   {
      first_name = f;
   }

   空白 set_last(STD.::细绳 l)
   {
      last_name = l;
   }
};


[Gandalf]写道:
我也将不得不查找“朋友函数”和其他一些概念,但现在我对我更加了解的时候我有很好的参考 微笑.


首先,让我们回顾造成混乱的代码。

C ++:
朋友STD.::Ostream.& operator<<(STD.::Ostream.& out, const名称& n)
{
   返回出去<< n.全名();
}


明白FRST的关键是 不是 名称类的成员函数。这只是一个常规的旧功能。

那么,为什么我们要把它称为名字的朋友?

在这种情况下,正如它所发生的那样,我们实际上没有必要,因为我们只是在传递的名称上呼叫公共会员函数。但是,想象一下,我们将其写为:

C ++:
朋友STD.::Ostream.& operator<<(STD.::Ostream.& out, const名称& n)
{
   返回出去<< n. << << n.最后的_name;
}


你看到这个问题吗?

名和last_name成员不公开,所以我无法访问它们......除非函数被声明为名称的朋友,因此可以访问名称的私有成员。

[Gandalf]写道:
对于Leedign Oop,你认为我应该看看Java而不是C ++吗?似乎语法越来越容易,而且似乎更简单了解。


它可能看起来更简单,但这是因为java缺乏C ++具有的功能。我不一定要说这会更好地制作C ++,或者Java更好。那是为了你决定。尽管如此,你应该做出明智的选择。
WTD.




邮政发布: 2005年7月11日星期一:下午11:03  帖子主题:(没有主题)

Lyam_Kaskade写道:
不是我是专家,但如果你想学习OOP,最好的语言可能是Ruby。


我并不倾向于不同意。 Ruby提供了所有OOP概念,虽然您需要的所有OOP概念,并使它们句子非常好。

此外,您可以在交互式解释器中编写用于测试目的的快速类。
德洛斯




邮政发布: 2005年7月12日星期二上午10:16  帖子主题:(没有主题)

真的很享受那个。现在,如果只有[语法]正确突出显示Ruby代码。我几乎没有介绍给Ruby,所以我可以了解一些。这些反思会很快继续持续吗?或者是现在的吗?

你有一个类型的地方 - “Wen”而不是“当”时。
赞助
赞助
赞助
赞助
WTD.




邮政发布: 星期二,2005年7月12日下午4:39  帖子主题:(没有主题)

德罗斯写道:
真的很享受那个。


很高兴我可以服务。
德罗斯写道:
这些反思会很快继续持续吗?或者是现在的吗?


询问和ye shell收到。 微笑

对面向对象编程的程序员来说是一个共同的混淆来源是单个继承和多重继承之间的区别。

我们已经看到了使用名称类和HTMLParser示例的单个继承,但我们尚未查看多重继承。原因很简单:多重继承比单个继承更复杂。

实际上,由于这个原因,许多语言甚至不包括使用多重继承的能力。此类别中的语言如Ruby,Java,C#,Objective-C以及许多其他人。

但是,还有其他语言是完全满意的,包括多重继承,并处理该功能的后果。 C ++,Python,Eiffel和O'Caml是此类别中的显着夹杂物。

有一件事您将注意到主要区别是单个继承的语言倾向于使所有对象从单个基类下降。例如,在Ruby和Java中,所有对象最终都从每个语言的各个对象类中降临。另一方面,多种继承语言倾向于特征,没有其他所有其他级别的单个类别下降。相反,它们具有许多根类。

现在,我不会告诉你一种方法或另一个是优越的。如果有的话,我会告诉你两个都是理解的,因为你几乎肯定会遇到两者。

我将要做的是向您展示我们可能使用多重继承的示例。

经典的编程练习是在10种等级中读取,找到平均,最小和最大等级。这相当简单,但让我们以面向对象的方式想象它。我们有什么对象?

我们有一个学生,读的成绩,这是简单的ints。

现在,让我们想想学生。我们可以用两种方式思考它。我们可以在“有”关系方面进行思考。这将向我们建议,学生既有名称和一系列成绩。

但我们正在寻找“是一种”的关系,为此我们可以说学生是一个名字和一系列成绩。我们已经有一个可以处理名称的类。

C ++:
班级名称
{
   私人的:
      std::细绳名,last_name;
   上市:
      Name(STD.::细绳 F, std::细绳 l)
      : first_name(f), 姓(l)
      { }

      std::细绳 first() const
      {
         返回名;
      }

      std::细绳 last() const
      {
         返回 last_name;
      }

      std::细绳 full_name() const
      {
         返回 first() + + last();
      }

      朋友STD.::Ostream.& operator<<(STD.::Ostream.& out, const名称& n)
      {
         返回出去<< n.全名();
      }
};


所以我们只需要考虑一下毕旧的课程。幸运的是,C ++具有一组方便的集合类。为此,我们将使用STD :: Ints的矢量。

C ++:
塑造 GradeCollection. : 上市STD.::向量<int>
{
   GradeCollection() : std::向量<int>() { }

   GradeCollection(尺寸_t. initial_size)
   : std::向量<int>(initial_size.)
   { }

   空白 add_grade( grade)
   {
      push_back(年级);
   }

   num_grades..() const
   {
      返回尺寸();
   }

    sum() const
   {
      sum(0);
      为了 ( i(0);一世< size(); ++ I.)
         sum += at(i);
      返回 sum;
   }

   双倍的 average() const
   {
      返回 sum() / static_cast<double>(num_grades.());
   }

    min_grade() const
   {
      min((0));
      为了 ( i(1);一世< num_grades(); ++ I.)
         如果 (闵> at(i))
            min = at(i);
      返回 min;
   }

    max_grade() const
   {
      max((0));
      为了 ( i(1);一世< num_grades(); ++ I.)
         如果 (最大限度< at(i))
            max = at(i);
      返回 max;
   }

   朋友STD.::Ostream.& operator<<(STD.::Ostream.& out, const GradeCollection. gc)
   {
      out << "(";
      为了 ( i(0);一世< gc.num_grades.() - 1; ++ I.)
         out << gc.(i) << “,”;
      out << gc.(GC。num_grades.() - 1) << ")";
      返回 out;
   }

   std::细绳 grades_as_string() const
   {
      std::OstringStream. ss;
      ss << *这个;
      返回 ss.str.();
   }
};


现在它很好地运作,但让我们想一想。当我们继承STD :: Vector时,我们从中获得了很多有用的功能,“免费”,它为我们节省了很多时间。但它也意味着我们的GradeCollection是STD :: Vector。如果我们不想建立这种关系怎么办。嗯,C ++功能有点独特的能力让我们继承而不建立这种关系。我们只需要替换课堂的第一行:

C ++:
塑造 GradeCollection. : 私人的STD.::向量<int>


这标志着从STD :: Vector作为私有的所有成员都是私有的,因此我们无效“是”关系。

只有一个剩下的问题。我们不妨创建一个更高级的GradeCollection子类,这些子类将需要访问STD :: Vector的成员。解决方案是依赖于第三,不太众所周知的限定符:受保护。

C ++:
塑造 GradeCollection. : 保护STD.::向量<int>


STD :: Vector的所有成员现在标记为受保护,因此我们无法在GradeCollection对象外部使用它们,但我们可以在子类内部在内部使用它们。

我们回到了学生。对于我们的学生既是姓名和毕旧的,它必须公开继承这些课程。

C ++:
塑造 学生 : 上市名称, 上市 GradeCollection
{
   Student(STD.::细绳 F, std::细绳 我, 尺寸_t.num_grades..)
   : Name(F,L.)
   , GradeCollection(num_grades.)
   { }
};


就是这样。这是继承的美丽。

现在要创造一个学生并通过读数十个等级。

C ++:
#包括<string>
#包括<iostream>
#包括"Student.h"

main()
{
   Student bob("鲍勃", "史密斯", 10);
   
   为了 ( i(0);一世< 10; ++ I.)
   {
      温度;

     
      {
         std::COUT. << "年级: ";
         std::COUT..fl();
         std::cin >> temp;
      } 尽管 (STD.::cin.失败());

      bob.add_grade.(临时);
   }

   std::COUT. << bob.全名()                  << std::终止
             << bob.年级s_as_string()           << std::终止
             << “平均数: "   << bob.平均数()   << std::终止
             << “闵等级: " << bob.闵_grade.() << std::终止;
             << “最高等级: " << bob.最大限度_grade.() << std::终止;
   
   返回 0;
}


免责声明:并非所有此代码都已测试过。如果您有问题,请告诉我。
WTD.




邮政发布: 2005年7月12日星期二5:51  帖子主题:(没有主题)

不太确定这一的质量。随意批评建设性。

当然,这有点错误地说java和c#这样的语言缺乏多重继承。到目前为止,我们只研究了实现继承,其中继承类别从父类中实现了功能。

这些语言和其他语言也实现了我们称之为“界面继承”的语言。界面实际上没有定义特定方法或方法组的工作原理。它只是说他们在课堂上,他们采取的论点以及他们回归的原因。

正如实现继承所创建的“是”的关系,我们可以将接口继承视为“是”关系通过“DO”关系。而不是用父类标识并因此拟合一定的分类,而是根据它的作用,该类适合该分类。

让我们再次看看学生课程,这次在C#中(只是为了混合东西)。我们已经有一个名称课程,可以很好地工作。

c-sharp:
班级名称
{
   私有字符串FirstName,LastName;

   public Name(string f, string l)
   {
      firstName = f;
      lastName = l;
   }

   public string First
   {
     得到{返回名字; }
   }

   public string Last
   {
     获取{返回姓名; }
   }

   公共字符串全名称
   {
     得到{返回它。首先() + " " + this.Last(); }
   }

   公共字符串ToString.()
   {
     返回这个.Fullname;
   }
}


现在我们需要一个可以收集等级的对象的接口。这阐述了我们预期的任何类都可以实现IGRADECollector接口。

c-sharp:
接口IGRADECLOLLER
{
   public void AddGrade(int grade);
   公共INT {GET; }
   public int numberofgrades {get; }
   公共INT平均{GET; }
   Public Int Mingrade {GET; }
   Public Int Maxgrade {GET; }
   公共字符串gradeAsstring {GET; }
}


我们现在可以继承名称并实现IGRADECollector以获取我们的学生课程。

c-sharp:
使用system.collections;
使用system.text;

班级学生:名称,iGraDecollector.
{
   私人阵列等级;

   public Student(string f,string l,int dromgrades)
   : base(f, l)
   {
     成绩=新的ArrayList(numGrades);
   }

   public void AddGrade(int grade)
   {
      grades.Add(grade);
   }

   public int Sum
   {
      get
      {
         int sum = 0;
         ienumerator e = grades.getenumerator();
         while (e.MoveNext())
            sum += e.Current;
         return sum;
      }
   }

   公共int numberofrodes.
   {
     得到{返回grades.count; }
   }

   public int Average
   {
      get { return (double)这个.sum / this.numberofgrades; }
   }

   public int MinGrade
   {
      get
      {
         int min = this.item [0];
         ienumerator e = grades.getenumerator(1, grades.Count - 1);
         while (e.MoveNext())
            if (min > e.Current)
               min = e.Current;
         return min;
      }
   }

   public int MaxGrade
   {
      get
      {
         int max = this.item [0];
         ienumerator e = grades.getenumerator(1, grades.Count - 1);
         while (e.MoveNext())
            if (max < e.Current)
               max = e.Current;
         return max;
      }
   }

   公共字符串gradeSastring.
   {
      get
      {
         StringBuilder SB = New StringBuilder("(");
         ienumerator e = grades.getenumerator(0, grades.Count - 2);
         while (e.MoveNext())
            sb.AppendFormat("{0}, ", e.Current);
         sb.AppendFormat("{0})",gradetes.item [gradet.count - 1]);
         return sb.ToString();
      }
   }
}


我不会打扰完成完成,因为它看起来几乎就像之前帖子中的C ++程序一样。

重要的是实现接口的重要事项是,他们允许您指定对象可以做的事情,同时留下它对实现类的详细信息。
Bugzpodder.




邮政发布: 2005年12月13日上午11:00  帖子主题:(没有主题)

对于高级OOP概念,请参阅“设计模式:元素
可重复使用的面向对象的软件“并由Erich Gamma,Richard Helm,Ralph Johnson和John Vlissides(Aka The Four的Gang)编写。
高级抽象(在UML图中)出现在此处:
http://www.tml.tkk.fi/~pnr/Tik-76.278/gof/html/

http://st-www.cs.uiuc.edu/users/patterns/DPBook/DPBook.html
在采访中,一些雇主甚至会问我是否读过这本书。
Zeroth.




邮政发布: 2008年6月27日星期五下午5:28  发表主题:RE:对OOP的反思

我知道这是一个非常旧的话题,但我认为这可能是发布这个的最佳地点。一位朋友向我展示了这个: 关于OOP的神话。当然,他在他对OOP的仇恨中落后的方式,但它为OOP程序员提供了一些很好的积分和Gotchas。大多数情况下,我所看到的只是好点,也可以应用于程序编程。相反,他们通常是OOP的问题,而不是OOP,他们更加,“不要过度的事情,白痴。”或者doti原则。使用任何代码,您需要评估功能提供的福利,以及在任何将来更改中需要完成的潜在工作。
Michaelp.




邮政发布: 星期二:2008年7月6:55  发表主题:RE:对OOP的反思

他真的试图在那里反对oop。
这是一个伟大的概念,我无法想象没有它的任何大规模。
在C ++中思考的第一章,第1卷,可能是我读过的最佳介绍之一。 (虽然我没有读过那么多,但在我读它的时候,我才知道它很好)
WTD.




邮政发布: 星期二01,2008 7:49 PM  发表主题:RE:对OOP的反思

对OOP的任何批评都没有提及功能规划本身缺乏可信度。
Zeroth.




邮政发布: 星期二:2008年7月8:27  发表主题:RE:对OOP的反思

大多数情况下,他只是试图推动自己的范式,这在某种程度上有意义......除了他是那些相信数据库是充足的编程语言的人之一。
从上一个显示帖子:   
   指数 -> 一般编程
查看上一个主题 告诉一个朋友可打印的版本 下载主题订阅本主题私人信息刷新页面 查看下一个主题

11  [ 15 Posts ]
跳到:   


Style:  
搜索: