标签: interface

我想在明天的办公时间去问老师之前得到一些信息.

我们有项目可以做类似iclicker问题回答收集器的事情.他告诉我们要避免使用switch case语句.我只是想知道为什么以及为什么这个领域的人不喜欢使用它们,还有什么选择呢？而且我怀疑他是否希望我们使用if语句.

我认为我们必须使用多态/接口,但我只是不敢说清楚,切换案例似乎非常直接.

谢谢.

我在Delphi中写了.pas 32bit DLL接口,如下所示:

用途:

 {$IFDEF WIN32}
 Windows;
 {$ELSE}
 Wintypes, WinProcs;
 {$ENIF}

接口:

function PI_InterfaceSetupDlg(const szRegKeyName: PChar): LongInt cdecl  {$IFDEF WIN32} stdcall {$ENDIF}; 

执行:

function PI_InterfaceSetupDlg; external 'PI_GCS2_DLL.DLL';

它适用于32位Widnows,但是我必须为64位写这样的东西,我有64位dll,但我不知道它必须使用哪些Windows组件以及如何为64位声明函数.64位Windows是否使用stdcall？我必须使用什么样的变量？

对不起混乱的帖子,我是Stack的新手.

我有

LoginCommandExecutor implements CommandExecutor<LoginCommand>
LoginCommand implements Command

为什么这一行会引发编译错误:

CommandExecutor<Command> a = new LoginCommandExecutor(commander, null);

但它适用于以下两个方面:

CommandExecutor<? extends Command> a = new LoginCommandExecutor(commander, null);
CommandExecutor b = new LoginCommandExecutor(commander, null);

如果两者都有效,哪一个更好？为什么？

因为我看到a和b在IDE中显示相同的方法

我有一个返回类型T的泛型方法.现在我想修改它,以便如果T碰巧实现接口I,则在对象上设置一个附加属性(即从I开始).

像这样的东西(但当然这不起作用):

    public T MyMethod<T>()
    {
        T resultAsT = some function ....

        var resultAsI = (resultAsT as I);

        if (resultAsI != null)
        {
            resultAsI.PropertyOnlyAvailableInI = 99;
            return resultAsI;
        }
        else
            return resultAsT;
    }

这样的事情可能吗？

我的问题是,在C#中如果我想在接口中添加另一个函数,但我不想在实现该接口的所有类中实现该函数.我怎样才能做到这一点？例如

接口包含5个方法,该接口在20个类中实现.现在我想在同一个接口中添加另一个方法,但我想只在5个类而不是在15个类中实现该函数？我怎么能实现这一目标？

谢谢

所以采取这个假设:

public enum CollectionRange
{
    One,
    ZeroToOne,
    ZeroToMany,
    OneToMany
}


public interface ICollectableTypeTemplate
{
    CollectionRange PossibleRange { get; }

    bool MustHaveAtleastOneItem
    {
        get
        {
            return PossibleRange == CollectionRange.One ||
                   PossibleRange == CollectionRange.OneToMany;
        }
    }

    bool MulipleOfTypeAllowed
    {
        get
        {
            return PossibleRange == CollectionRange.ZeroToMany ||
                   PossibleRange == CollectionRange.OneToMany;
        }
    }

}

这将是错误,因为我给了那两个辅助属性的身体..但为什么他们不能拥有身体？什么是一个很好的方式,我可以重新设计它,所以它构建？

为什么Go不会自动转换:

package main

import "fmt"

type Any interface{} // Any is an empty interface
type X func(x Any) // X is a function that receives Any

func Y(x X) { // Y is a function that receives X
  x(1)
}

func test(v interface{}) { // test is not considered equal to X
  fmt.Println("called",v)
}

func main() {
  Y(test) // error: cannot use test (type func(interface {})) as type X in argument to Y
}

还有这个:

package main
import "fmt"

type …

我遇到了一个实现接口的类的问题,该接口具有其他接口类型的列表.试图在下面创建一个简单的例子.

    public interface IPerson
{
    IEnumerable<IPersonEntry> Persons { get; set; }
    DateTime LastUpdated { get; set; }
}

public class PersonType1 : IPerson
{
    public IEnumerable<IPersonEntry> Persons { get; set; }
    public DateTime LastUpdated { get; set; }

    public PersonType1()
    {
        Persons = new List<NormalEntry>();
    }
}

public class PersonType2 : IPerson
{
    IEnumerable<IPersonEntry> Persons { get; set; }
    public DateTime LastUpdated { get; set; }

    public PersonType2()
    {
        Persons = new List<SomethingDifferent>();
    }
}

public interface IPersonEntry
{
    string …

当我实现一个接口时Eclipse告诉我添加所有实现的方法.

由于并非所有这些都是通常需要的,有没有办法删除从接口继承的方法而不是空体？让这个无用的代码浮出水面让我感到困扰.

一个很好的例子是KeyListener界面.

jTextComponent.addKeyListener(new KeyListener()
{
    @Override
    public void keyTyped(KeyEvent e)
    {
    }

    @Override
    public void keyPressed(KeyEvent pressedEvent)
    {
         System.out.println("Pressed!");
    }

    @Override
    public void keyReleased(KeyEvent arg0)
    {
    }
});

我想写下面或类似的:

jTextComponent.addKeyListener(new KeyListener()
{
    @Override
    public void keyPressed(KeyEvent pressedEvent)
    {
         System.out.println("Pressed!");
    }
});

有没有办法说所有未实现的方法都是自动为空或者某些东西而不是将它们放入代码中？

我有一些界面问题!

这是代码:

我希望能够通过我的测试模板访问属性Added和ID,但intellisense说不!

我滥用界面了吗？我犯了一个愚蠢的错误吗？

任何建议表示赞赏 - 这让我感到疯狂.

namespace blah.blah.blah
{
    public interface ITrackedItem
    {
        DateTime Added { get; set; }
        int ID { get; set; }
    }

    public class TestTemplate<ITrackedItem>
        where ITrackedItem : new() 
    {
        public SortedSet<ITrackedItem> Set { get; set; }

        public void Test()
        {
            Set = new SortedSet<ITrackedItem>();

            foreach (var item in Set)
            {
                // cannot access any properties here
                // var ID = item.ID; <=============|
            }
        }
    }
}