标签: abstraction

因此,如果一种语言提供更高阶的程序,那么我可以有返回程序的程序.就像是:

(define (Proc a b c)
  (lambda (x) ( #| method body here in terms of a b c and x |# )))

要创建新程序,我会做类似的事情:

(define ProcA (Proc a1 b1 c1)) ; Would create ProcA that has 1 argument

类似的任务可以用不支持高阶过程的语言来完成,方法是定义Proc4个而不是3个参数并调用这个过程来定义ProcA,如:

(define (Proc a b c x) ( #| method body -- does not return any procedure |# )
(define (ProcA x) (Proc a1 b1 c1 x))

那么为什么有关高阶程序的模糊呢？我错过了什么吗？

如何设计涉及其他类集合的类？

一般例子:

一个工作区包含数项目.
一个项目包含了大量的资源.
每个资源可能包含大量文件.

所以这里确定的类可以是Workspace,Project,Resource和File.Workspace将包含Project.Project列表,其中包含Resources和Resource列表.当然每个班级都有相关的设置.

现在基本的问题是:
a)谁创建并添加了一个特定集合的类？另一个类或包含该集合的类？
b)另外如何跟踪特定的集合以及如何存储它？
c)谁审核特定馆藏的变化？
d)在这种情况下可以应用哪些不同的设计模式？

基本上我想减少不同类之间的耦合.

感谢大家

我知道这是非常抽象的,但我相信它非常集中.

今天有很多高级语言:C#,Java,VB,Python等,它们都是为了抽象出低级复杂性并提供更加用户友好的编程体验而创建的.高级语言可以减少并且大部分时间完全删除执行低级特定于进程的操作(例如指针操作和内存管理)的必要性.许多还删除了平台细节(如文件操作,用户界面生成等)

我的两个问题是:

1. 还有什么可以/应该被抽象出来？今天的高级语言中是否还有更多的低级语义将被进一步抽象出来？
2. 通用的高级语言在什么时候变得非常高级,即面向目标？

我想知道我是否想以RAD的名义抽象过多.

这里的一个例子 - 假设我有一个数据库表,它有3个模型(主模型,映射器模型和数据库模型).每个都扩展了抽象模型,映射器和db表模型.

这个设置非常好用.大部分操作实际上都在抽象模型中.但是,现在我想抽象更多.我会去远吗？

我已经抽象了基本的CRUD操作,现在我正在考虑抽象更高级的操作.

一个例子就是获取一些相关的模型.目前我会这样做:

$ modelOne-> modelTwo(); 其中modelTwo是明确定义的.

我的想法是使用像injectModel('modelTwo')这样的抽象方法或魔术方法.

我总是可以建立相关的规则来确保我的模型保持完整性......但是这太过分了吗？

感谢任何建议.

我不在乎我的一些代码是不连贯的; 我可以在这些部分写清楚的文档和注释.

在我目前的项目中,我们为代码指标"可维护性指数"和"Cyclometic Complexity"设定了一些目标.可维护性指数应为60或更高,Cyclometic Complexity为25或更低.我们知道60和更高的可维护性指数相当高.

我们还使用了很多linq来过滤/分组/选择实体.我发现这些linq查询在维护性指数上得分并不高.将这些查询提取到扩展方法中,可以给我一个更高的可维护性指数,这很好.但是在大多数情况下,扩展方法不再是通用的,因为我将它们与我的类型而不是泛型类型一起使用.

例如,以下linq-query vs扩展方法:

Linq查询

List.Where(m => m.BeginTime >= selectionFrom && m.EndTime <= selectionTo)

扩展方法:

public static IEnumerable<MyType> FilterBy(this IEnumerable<MyType> source, DateTime selectionFrom, DateTime selectionTo)
{
    return (IEnumerable<MyType>)source.Where(m => m.BeginTime >= selectionFrom && m.EndTime <= selectionTo);
}

List.FilterBy(selectionFrom, selectionTo);

扩展方法为我提供了6个点的可维护性指数改进,并提供了一个很好的流利语法.另一方面,我必须添加一个静态类,它不是通用的.

关于什么方法的任何想法会对你有利吗？或者可能对如何重构linq查询以提高可维护性指数有不同的想法？

我正在一些图形API(DirectX9和DirectX11)上面写一个抽象层,我想你的意见.

传统上,我会为每个想要抽象的概念创建一个基类.
因此,在典型的OO方式中,我将有一个类Shader和2个子类DX9Shader和DX11Shader.

我会重复纹理等过程...当我需要实例化它们时,我有一个抽象工厂,它将根据当前的图形API返回适当的子类.
在RAII之后,返回的指针将封装在std :: shared_ptr中.

到目前为止一直很好,但就我而言,这种方法存在一些问题:

1. 我需要提出一个公共接口,它封装了两个API(以及将来的其他API)的功能.
2. 派生类存储在单独的DLL中(一个用于DX9,一个用于DX11等...)并且在客户端中有一个shared_ptr是一个诅咒:在退出时,图形dll被卸载,如果客户端仍然有一个shared_ptr其中一个图形对象繁荣,由于从卸载的DLL调用代码而崩溃.

这促使我重新设计我的工作方式:我认为我可以返回资源的原始指针,并让图形API自行清理,但仍然存在客户端悬挂指针和接口问题的问题.我甚至认为手动引用计数像COM,但我认为这将是一个倒退(纠正我,如果我错了,来自shared_ptr世界,手动引用计数似乎是原始的).

然后我看到了Humus的工作,其中所有的图形类都由整数ID表示(很像OpenGL的作用).创建一个新对象只返回其整数ID,并在内部存储指针; 它完全不透明!

代表抽象的类(例如DX9Shader等......)都隐藏在设备API后面,这是唯一的接口.
如果想要设置纹理,只需调用device-> SetTexture(ID),其余的就在幕后发生.

失败的原因是API的隐藏部分膨胀,需要很多锅炉板代码才能使其工作,我不是一个全能类的粉丝.

任何想法/想法？

我有兴趣推广使用Cayley Table的一些计算工具,这意味着基于查找表的乘法运算.

我可以创建一个最小的实现,如下所示:

date CayleyTable = CayleyTable {
    ct_name :: ByteString,
    ct_products :: V.Vector (V.Vector Int)
} deriving (Read, Show)

instance Eq (CayleyTable) where
 (==) a b = ct_name a == ct_name b

data CTElement = CTElement { 
    ct_cayleytable :: CayleyTable,
    ct_index   :: !Int
}

instance Eq (CTElement) where
 (==) a b = assert (ct_cayleytable a == ct_cayleytable b) $
            ct_index a == ct_index b

instance Show (CTElement) where
   show = ("CTElement" ++) . show . ctp_index

a …

我正在尝试使用node.js和其他相关技术来实现应用程序.从java土地多态性开始但是很自然,但对于经典程序员节点的工作方式不同.

应用程序将在用户提供的运行时加载新代码.为了让主要核心使用这个代码"我们"需要就某种约定达成一致.知道新节点是什么我并不感到惊讶,因为我找不到答案.问题是这个问题在JS中也相当模糊.

要求:

1. 强烈的脱钩.
2. 在运行时加载新代码.
3. 该解决方案应该适用,因此我可以与浏览器共享尽可能多的代码.

更新:

1. 我确实摆弄了鸭子打字,我也遇到了Clojure关于基于协议的实现的想法.
2. 我会很感激答案中的一些代码.

我了解OOP概念的基础知识[继承，抽象，封装，多态]

我们在父子关系的情况下使用继承 [子级可以具有父级具有的所有功能，也可以为其自身添加更多功能]

并且我们将Abstract类（在Java中）用于类中方法的部分默认实现集，这也可以通过简单的Inheritance实现。

看下面的例子，这使我的观点清楚。

遗产：

家长班

public class Parent {

    // This method will remain same for all child classes.No need to override
    public void abc() {
        System.out.println("Parent here");
    }

    // This methods need to be overridden from child class
    public int getROI() {
        return 0;
    }
}

儿童班

public class Child extends Parent{

    @Override
    public int getROI(){
        return 5;
    }

    public static void main(String[] args) {
        Child child =new Child();
        child.abc();
        System.out.println(child.getROI());
    }
}

抽象类： …

假设我有一个使用Array of Structures(AoS)内存布局的大代码.我想在C++中构建一个零成本的抽象,它允许我在尽可能少的重构努力之间切换AoS和SoA.例如,使用具有访问成员函数的类

 struct Item{
   auto& myDouble(){ return mDouble; }
   auto& myChar(){ return mChar; }
   auto& myString(){ return mString; }
 private:
   double mDouble;
   char mChar;
   std::string mString;
 };

它在循环中的容器内使用

std::vector<Item> vec_(1000);
for (auto& i : vec_)
  i.myDouble()=5.;

我想改变第一个片段,而第二个片段保持相似...例如,有类似的东西

MyContainer<Item, SoA> vec_(1000)
for (auto& i : vec_)
  i.myDouble()=5.;

我可以使用"SoA"或"AoS"模板参数选择内存布局.我的问题是:这样的事情存在于某个地方吗？如果没有,最好如何实施？