标签: interface

首先，我不知道如何称呼我的问题，所以任何更好的标题建议请告诉我。

我想创建一个接口，以便其他人可以添加他们的实现，然后在运行时决定使用哪个实现。

即我创建了一个接口“Food”，并且存在 2 个实现“Breakfast”和“Lunch”。在实现中，两者具有相同的方法名称和相同的参数，我想让用户在运行时调用它们中的任何一个。“makeFood() 使用早餐”或“makeFood() 使用午餐”。

一种可能性是仅编译一种实现，但是如果将来必须使用其他实现，则需要删除 .class 文件。

或者我应该使用某种类型的继承？

另外（不是优先级）：我不知道实现类名称，所以有人可以创建“晚餐”或“第二早餐”。这会让我陷入另一个困境，如果用户请求一个尚未实现的“类”该怎么办：SI 总是可以假设用户知道哪些实现可用。

我对.NET比较陌生，并且偶然发现了这个特定问题：在遵循存储库模式教程时，该类的定义如下所示：

public class GenericRepository<TEntity> where TEntity : class { ...

话虽这么说，这个类应该实现一个接口。既然我已经使用了该:运算符，我该怎么做呢？

我public class GenericRepository<TEntity> : IGenericRepository where TEntity : class {也尝试过public class GenericRepository<TEntity> where TEntity : class : IGenericRepository {，但没用

我的目的是在两个响应结构的标头和正文中使用 HTTP 状态代码。但是，无需将状态代码设置两次作为函数参数，并再次设置结构以避免冗余。

response的参数JSON()是一个允许接受两个结构的接口。编译器抛出以下异常：

response.Status undefined (type interface {} has no field or method Status)

因为响应字段不能有状态属性。有没有其他方法可以避免设置状态代码两次？

type Response struct {
    Status int         `json:"status"`
    Data   interface{} `json:"data"`
}

type ErrorResponse struct {
    Status int      `json:"status"`
    Errors []string `json:"errors"`
}

func JSON(rw http.ResponseWriter, response interface{}) {
    payload, _ := json.MarshalIndent(response, "", "    ")
    rw.WriteHeader(response.Status)
    ...
}

在 Java 8default中引入了方法实现。我的问题是为什么需要default在方法名称/签名中有关键字。为什么不能default像通常的方法实现一样没有关键字？

我得到一个地图界面，如：

getUsersAppInfo := usersAppInfo.GetUsersAppInfo(getUserId)

然后我打印：

fmt.Println(getUsersAppInfo)

得到这个，比如：

[map[appId:2 fcmServerKey:keyTestTest name:com.app]]

问：如何只打印值，比如

appId value is 2 
name value is com.app 
fcmServerKey:keyTestTest value is keyTestTest 

我有以下接口和一些实现它的结构：

package main

import "fmt"

type vehicle interface {
    vehicleType() string
    numberOfWheels() int
    EngineType() string
}

// -------------------------------------------

type truck struct {
    loadCapacity int
}

func (t truck) vehicleType() string {
    return "Truck"
}

func (t truck) numberOfWheels() int {
    return 6
}

func (t truck) EngineType() string {
    return "Gasoline"
}

// -------------------------------------------
type ev struct {
    capacityInKWh int
}

func (e ev) vehicleType() string {
    return "Electric Vehicle"
}

func (e ev) numberOfWheels() int {
    return 4
} …

在 Kotlin 中编写函数时，基本上完全在Thread创建内部实现start()，Android Studio 提供了“转换为表达式主体”的选项

选择这样做时，kotlin 会将函数转换为表达式主体：

有没有办法要求一个接口（就像这个函数覆盖的那个）？

我希望接口总是要求validate函数启动一个新的Thread并且只有 (!!) 能够执行里面的东西Thread，而不是方法体本身，因为它只会用于寻址服务器。

我知道我可以通过使用 aabstract class而不是interface这样的方式来强制这种行为：

abstract class ServerValidator<T> {
    fun validate(value: T?, function: ((ValidationResult) -> Unit)) = Thread {
        doValidation(value, function)
    }.start()

    protected abstract fun doValidation(value: T?, function: ((ValidationResult) -> Unit))
}

这样一个继承类将能够覆盖该doValidation函数，而另一个类只能调用validate并因此始终使用新线程。

但是，我特别想知道是否可以使用接口来做这样的事情。

就像是：

interface ServerValidator<T> {
    fun validate(value: T?, function: ((ValidationResult) -> Unit)) = Thread::start
}

// or 

interface ServerValidator<T> { …

我很想知道如果一个类实现了两个或多个具有相似方法的接口，是否可以将其视为方法重载。如果不是，那么正确的术语是什么？

举个例子

public interface I1 {
  int method1(String input);
}

public interface I2 {
  void method1(int input);
}

public class C1 implements I1, I2 {
  public int method1(String input){ return 0;}

  public void method1(int input){}
}

题

我无法理解“可重用面向对象软件的元素”中观察者模式的以下 UML 图。谁能解释我为什么我的 Java 实现是错误的，我必须改变什么才能正确实现它？

UML-图

尝试（但错误）实施

public interface Subject {
    
    public static final List<Observer> observers = new ArrayList<Observer>();
    
    public void attach(Observer o);
    public void detach(Observer o);
    public void notifyObservers();
}

public interface Observer { 
    public void update();
}

public class ConcreteSubject implements Subject {
    
    private String subjectState;

    @Override
    public void attach(Observer o) {
        observers.add(o);   
    }

    @Override
    public void detach(Observer o) {
        observers.remove(o);
    }

    @Override
    public void notifyObservers() {
        for (Observer o : observers) {
            o.update();
        } …

我读到，在 Go 中，函数可以实现接口（就像在这个例子或这个例子中）。

但是让一个函数实现一个接口有什么价值呢？

例如，为什么要花时间定义一个接口、一个新的函数类型和一个方法，像这样：

type Handler interface {
    ServeHTTP(*Conn, *Request)
}

type HandlerFunc func(*Conn, *Request)

func (f HandlerFunc) ServeHTTP(c *Conn, req *Request) {
    f(c, req)
}

相反，您可以只创建一个像这样的函数：

func ServeHTTP(f func(*Conn, *Request), c *Conn, req *Request) {
    f(c, req)
}

提前致谢！