标签: interface

我有一个名为Node的类和另一个名为ClassicNode的类,它扩展了Node.现在我有一个由ClassicNode类实现的接口AgentInterface.接口声明必须有一个方法

Node selection();

如您所见,返回类型应为Node类型.但是在类ClassicNode中,我可以像这样实现它: -

ClassicNode selection(){
    //Code
}

这会满足界面吗？(因为ClassicNode继承了Node)

它似乎是标准所以我到目前为止一直在使用它,但现在我正在从头开始构建一个新类而不是修改旧类,并且我觉得我应该理解为什么我应该遵循项目约定.

几乎每个类都有一个调用它的接口classnameable.在代码中database.class永远不会出现一次,但在我希望使用我看到的那个类的地方databaseable.class.

根据我的理解,接口是一个从未实现过的类,但是为了保持标准而固有.那么为什么接口被用作真正的类呢？

Interface IWorkPerson
{
    public string FirstName {get; set;}
    public string LastName { get; set; }
    public string WorkPhone { get; set; }
}

interface IHomePerson
{
    public string FirstName {get; set;}
    public string LastName { get; set; }
    public string HomePhone { get; set; }
}

public class Person : IWorkPerson, IHomePerson
{
    public string FirstName {get; set;}
    public string LastName { get; set; }
    public string WorkPhone { get; set; }
    public string HomePhone { get; set; }
} …

我有一个接口类

public interface AsyncTaskExecuteCommand {
public Object executeCommand(String jsonLocation) throws IOException,JSONException;
}

我有一个存储此接口实例的HashMap

public static HashMap<String,AsyncTaskExecuteCommand> executeCommandHashMap

executeCommandHashMap.put(COMMAND_CORE_FIELD_FETCH, new AsyncTaskExecuteCommand() {
        @Override
        public Object executeCommand(String jsonLocation) throws IOException, JSONException{
                           //return some thing
        }
    });

executeCommandHashMap.put(COMMAND_REGISTER_FIELD_FETCH, new AsyncTaskExecuteCommand() {
        @Override
        public Object executeCommand(String jsonLocation) throws IOException,
                JSONException {
                          //return some thing
        }
    });

我的AsyncTask名为GeneralAsyncTask包含

doInBackground(){

 AsyncTaskExecuteCommand asyncTaskExecuteCommand = executeCommandHashMap.get(params[0]);
 return asyncTaskExecuteCommand.executeCommand(params[1]);
}

而这个AsyncTask被调用

new GeneralAsyncTask().execute(COMMAND_REGISTER_FIELD_FETCH,"http://something");

我这样做是因为我的AsyncTask的一般结构保持不变,即它做了一些方法执行并返回一些值.只有方法执行类型和返回值会有所不同.如果我不实现传递接口到异步任务,我最终创建了许多AsyncTask类.那么,这种方法是否可以解决我的问题？

我有以下代码:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace QQQ.Mappings
{
    interface IExcess<T>
    {
        IEnumerable<string, T> getExcessByMaterialGroup(T[] data);
        void Sort<TKey>(T[] data, Func<T, TKey> selector);
    }
}

但我得到这个错误,"使用泛型类型'System.Collections.Generic.IEnumerable'需要'1'类型参数"

我创建了一个名为的方法GetStudentMarks().这种方法的返回类型是通用的List<StudentMark>.即使我List<StudentMark>用泛型替换了代码也能很好地工作IList<StudentMark>.当接口只包含声明时,接口如何替换类？

在C++中,我如何声明一个接口,我可以使用它,如下所示:

/** Enemy "Interface" */
Class Enemy {
    Enemy();
    virtual ~Enemy();
    virtual void doStuff() = 0;
};

/** Enemy of type 1 */
Class Enemy_type1 : public Enemy {
    Enemy_type1();
    virtual ~Enemy_type1();
    virtual void doStuff() {
        // different for every type of enemy
    }
};

/** Add an enemy to EnemyManager */
void EnemyManager::addEnemy(Enemy * e) {
    this->enemies.push_back(*e); // declared as vector<Enemy> enemies;
}

我有3个项目:P1,P2和P3

在P1中,有一个接口I的定义

在P2中,有一个实现接口I的C类

public class C : I
{
    ...
}

在P3中,我在一个类中有这个方法:

public static C getC (int id)
{
   ...
}

在编译时,P3不编译,因为接口I是在未引用的项目中定义的.为什么？

请注意,我没有使用P3中的接口,我使用具体类.

接口是否Iterator已在java库中的某处定义(请注意术语).即

我要问的是,说我有一个arraylist,现在我写.

Iterator itr= new Iterator();

但我从未定义过类似的东西

public interface Iterator{  // all the methods };

我是否需要导入一些已定义此迭代器的包？

我来这里举个例子:

class BOX implements Comparable {

    private double length;
    private double width;
    private double height;

    BOX(double l, double b, double h) {
        length = l;
        width = b;
        height = h;
    }

    public double getLength() {
        return length;
    }

    public double getWidth() {
        return width;
    }

    public double getHeight() {
        return height;
    }

    public double getArea() {
        return 2 * (length * …

请考虑以下代码:

public class Main implements Vehicle, Car {
  public static void main(String[] args) {
    Main generalConcreteClass = new Main();
    System.out.println(((Vehicle) generalConcreteClass).TYPE); //**Line 1**

    Vehicle vehicle = new Main();  //**Line 2**
    System.out.println(vehicle.TYPE);//  Here there is no Ambiguity since vehicle is of TYPE vehicle

    System.out.println(((Car)vehicle).TYPE);  // **Line3** This doesn't throw ClassCastException..
  }
}

这里,Vehicle和Car接口都具有相同的常量TYPE,具有不同的值.

Line1上的generalConcreteClass会有歧义,因此需要进行类型转换,并且可以访问任何一个TYPE.

Line2:车辆对象有车辆界面参考.

第3行:如何将我的车辆对象转换为Car类型并仍然可以访问常量TYPE of Car.如何使车辆物体可见.或者它如何在内部工作？

现在,如果我不使我的类实现Car接口,那么类型的类型转换车辆对象类型Car会抛出ClassCastException.