标签: class-hierarchy

例如,如果我想看看我的.NET选项是用于实现IList或IDictionary的东西.有没有办法在MSDN文档中找到它？

在Ruby中,是否可以使用任何方法识别对象o在类层次结构中是否具有类C作为其祖先？

我在下面给出了一个例子,我用一种假设的方法has_super_class?来完成它.我该怎么做呢？

o = Array.new
o[0] = 0.5
o[1] = 1
o[2] = "This is good"
o[3] = Hash.new

o.each do |value|
  if (value.has_super_class? Numeric)
    puts "Number"
  elsif (value.has_super_class? String)
    puts "String"
  else
    puts "Useless"
  end
end

预期产出:

Number
Number
String
Useless

我正在尝试完成一些课程工作的问题,任何帮助将不胜感激!

我有3种类型的帐户,它们扩展了抽象类型"帐户".. [CurrentAccount,StaffAccount和MortgageAccount].

我试图从文件中读取一些数据并创建帐户对象以及用户对象以添加到程序中存储的哈希映射.

当我创建帐户对象时,我使用Account类型的临时变量,并根据读入的数据定义其子类型.

例如:

Account temp=null;

if(data[i].equalsIgnoreCase("mortgage"){
    temp= new MortgageAccount;
}

问题是当我尝试调用属于MortgageAccount类型的方法时.

我是否需要每种类型的临时变量,StaffAccount MortgageAccount和CurrentAccount并使用它们coresspondingly才能使用他们的方法？

提前致谢!

在我写的iOS应用程序中,我想遍历一个类层次结构来编制所有子类的清单.我的意图是NSStringForClass()在字典中使用每个子类类型作为键 - via - .

我的动机是能够自动发现基类的所有变体,以便我可以调用与该类相关的方法.出于分工的原因,我不想在这里使用方法覆盖.

是否可以进行这样的遍历？它会如何工作？

我想用以下类创建程序:Class Player,它存储有关get/set函数的玩家的一些信息.播放器可以作为AttackPlayer,它将拥有带有get/set功能的数据.Player也可以作为ProtectorPlayer,还有一些其他自己的数据,get/set函数与AttackPlayer不同.

Player也可以是TeamPlayer或FreePlayer,这些类中的每一个都有自己的数据等.

问题是如何正确实现层次结构？

起初我想过多重继承,无论如何都不好.类似于:Player AttackPlayer扩展Player ProtectorPlayer扩展Player

TeamPlayer扩展AttackPlayer或ProtectorPlayer FreePlayer扩展AttackPlayer或ProtectorPlayer

我也考虑过战略模式,但这里不适用,因为没有常见的算法.

有没有什么方法可以帮助组织这种互动？

另一种方法是在Player类中有一个字段,这有助于识别TeamPlayer/FreePlayer是Attack还是Protector类型,并根据它来访问适当的字段.在这种情况下,继承将是这样的:

播放器TeamPlayer扩展播放器FreePlayer扩展播放器

攻击,保护没有继承的结构或类,但作为Player类中的字段.

但我不喜欢这种方法,我正在寻找更好的设计.

下面的配置

<configuration>

    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <!-- encoders are assigned the type ch.qos.logback.classic.encoder.PatternLayoutEncoder by default -->
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} %C{0}: %msg%n</pattern>
        </encoder>
    </appender>

    <root level="debug">
        <appender-ref ref="STDOUT" />
    </root>

</configuration>

和以下代码

package tests;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Runner {

    private static final Logger log = LoggerFactory.getLogger(Runner.class);



    public static void main(String[] args) {

        new Runner().new Parent().hello();
        new Runner().new Child().hello();
    }

    public class Parent {

        public void hello() {
            log.info("Hello from " + getClass().getSimpleName());
        }
    }

    public class Child extends Parent{

    } …

在我的Haskell程序中,我有一些类型表示"形状"的抽象概念,即

-- | Class representing shapes.
class Shape a where
  isColliding :: (Shape b) => a -> b -> Bool
  centroid :: Point

-- | Class representing shapes composed of a finite number of vertices 
and line segments connecting them.
class (Shape a) => Polygon a where
  vertices :: a -> Vertices 

如你所见,Polygon自然是一个子类Shape.我也有一些数据类型是这些不同类型类的实例.例如:

data Box = Box Point Point Angle

instance Shape Box where
  ...

instance Polygon Box where
  ...

---------------------------------

data Circle = Circle Point …

加载类似的ficus配置

loadConfiguration[T <: Product](): T = {
import net.ceedubs.ficus.readers.ArbitraryTypeReader._
import net.ceedubs.ficus.Ficus._
val config: Config = ConfigFactory.load()
config.as[T]

失败了:

Cannot generate a config value reader for type T, because it has no apply method in a companion object that returns type T, and it doesn't have a primary constructor

而是直接指定一个case类而不是Tie SomeClass它工作得很好.我在这里错过了什么？

我有以下定义：

data Egg = ChickenEgg | ChocolateEgg
  deriving Show
  
data Milk = Milk Int -- amount in litres
  deriving Show
  
class Price a where
  price :: a -> Int

instance Price Egg where
  price ChickenEgg = 20
  price ChocolateEgg = 30

instance Price Milk where
  price (Milk v) = 15 * v

以上编译运行OK。但是，我需要能够做这样的事情：

price (Just ChickenEgg) -- 20
price [Milk 1, Milk 2] -- 45
price [Just ChocolateEgg, Nothing, Just ChickenEgg] -- 50
price [Nothing, Nothing, Just (Milk 1), Just …

我正在阅读一本Java书,并且这次再次思考这一段实际意味着什么:

接口旨在支持运行时的动态方法解析.通常,为了从一个类调用方法到另一个类,两个类都需要在编译时出现,因此Java编译器可以检查以确保方法签名是兼容的.这个要求本身就是一个静态和不可扩展的分类环境.在这样的系统中,不可避免地会在类层次结构中将功能提升得越来越高,以便机制可用于越来越多的子类.接口旨在避免此问题.它们将方法或方法集的定义与继承层次结构断开连接.由于接口与类的层次结构不同,因此在类层次结构方面不相关的类可能实现相同的接口.这是实现接口真正功能的地方.

第一个问题:作者的意思是什么from one class to another？他是否意味着这些类在层次结构方面是相关的？我的意思是,将子类对象引用分配给它的超类类型变量然后调用方法？

第二个问题:作者再次提出什么意思This requirement by itself makes for a static and nonextensible classing environment？我不明白其makes for含义(英语不是我的主要语言)以及为什么环境被称为静态和不可扩展.

第三个问题:他的意思是什么functionality gets pushed up higher and higher？为什么它会越来越高？什么功能？还有mechanisms will be available to more and more subclasses.什么机制？方法？

第四个问题:Interfaces are designed to avoid this problem.什么问题？？？

我知道答案必须明显,但我不知道.也许主要是因为我没有看到一些神奇的英语短语.请帮助我理解这一段的内容.