Результаты поиска

В проекте наша команда использует списки объектов для выполнения массовых операций над наборами данных, которые должны обрабатываться аналогичным образом. В частности, различные объекты идеально действовали бы одинаково, что было бы очень легко достигнуто с помощью полиморфизма. Проблема, с которой я сталкиваюсь, заключается в том, что наследование подразумевает, что это отношение, а не имеет отношения. Например, у нескольких объектов есть счетчик повреждений, но чтобы сделать это простым в использовании в списке объектов, можно использовать полиморфизм - за исключением того, что это будет означать отношение, которое не будет истинным. (Человек не является счетчиком ущерба.)

Единственное решение, которое я могу придумать, состоит в том, чтобы член класса возвращал правильный тип объекта при неявном приведении вместо того, чтобы полагаться на наследование. Было бы лучше отказаться от is a / has a ideal в обмен на простоту программирования?

Редактировать: Чтобы быть более конкретным, я использую C++, поэтому использование полиморфизма позволит различным объектам "act the same" в том смысле, что производные классы могут находиться в одном списке и управляться виртуальной функцией базового класса. Использование интерфейса (или имитация их через наследование) кажется решением, которое я хотел бы использовать.

Если я наследую от базового класса и хочу передать что-то из конструктора унаследованного класса конструктору базового класса, как это сделать?

Например,

Если я унаследовал от класса исключений я хочу сделать что-то вроде этого:

class MyExceptionClass : Exception
{
     public MyExceptionClass(string message, string extraInfo)
     {
         //This is where it's all falling apart
         base(message);
     }
}

В основном я хочу иметь возможность передать строковое сообщение в базовый класс исключений.

Предположим, у вас есть следующие EJB 3 interfaces/classes:

public interface Repository<E>
{
   public void delete(E entity);
}

public abstract class AbstractRepository<E>  implements Repository<E>
{
   public void delete(E entity){
      //...
   }
}

public interface FooRepository<Foo>
{
   //other methods
}

@Local(FooRepository.class)
@Stateless
public class FooRepositoryImpl extends
    AbstractRepository<Foo> implements FooRepository
{
   @Override
   public void delete(Foo entity){
      //do something before deleting the entity
      super.delete(entity);
   }
   //other methods
}

А затем еще один боб, который обращается к Бобу FooRepository :

//...
@EJB
private FooRepository fooRepository;

public void someMethod(Foo foo)
{
    fooRepository.delete(foo);
}
//...

Однако метод переопределения никогда не выполняется при вызове метода delete компонента FooRepository . Вместо этого выполняется только реализация метода delete, определенного в AbstractRepository .

Что я делаю неправильно или это просто ограничение Java/EJB 3, что дженерики и наследование еще не играют хорошо вместе ?

В C#,, если у меня есть унаследованный класс с конструктором по умолчанию, должен ли я явно вызывать конструктор базового класса или он будет вызван неявно?

class BaseClass
{
    public BaseClass()
    {
        // ... some code
    }
}
class MyClass : BaseClass
{
    public MyClass() // Do I need to put ": base()" here or is it implied?
    {
        // ... some code
    }
}

У меня есть группа взаимосвязанных классов, которые все переопределены вместе, чтобы создать конкретную реализацию. Мне интересно, если это хорошая идея, чтобы заключить взаимосвязанные подклассы в пространстве имен.

Для примера рассмотрим следующие пространства имен и классы:

namespace Protocol
{
  public abstract class Message { }
  public abstract class Driver { }
}
namespace Protocol.Tcp
{
  public class TcpMessage : Message { }
  public class TcpDriver : Driver { }
}
namespace Protocol.Ftp
{
  public class FtpMessage : Message { }
  public class FtpDriver : Driver { }
}

Каков наилучший способ структурировать пространства имен? Кажется неизбежным выставлять наследование в пространстве имен, поскольку базовые классы на самом деле не принадлежат ни к пространству имен Protocol.Tcp, ни к пространству имен Protocol.Ftp.

В C#,, если у меня есть унаследованный класс с конструктором по умолчанию, должен ли я явно вызывать конструктор базового класса или он будет вызван неявно?

class BaseClass
{
    public BaseClass()
    {
        // ... some code
    }
}
class MyClass : BaseClass
{
    public MyClass() // Do I need to put ": base()" here or is it implied?
    {
        // ... some code
    }
}

Следуя из моего предыдущего вопроса , я работал над тем, чтобы моя объектная модель сериализовалась до XML. Но теперь я столкнулся с проблемой (quelle surprise!).

Проблема заключается в том, что у меня есть коллекция, которая имеет абстрактный базовый тип класса, который заполнен конкретными производными типами.

Я подумал, что было бы неплохо просто добавить атрибуты XML ко всем задействованным классам, и все будет замечательно. К сожалению, это не так!

Поэтому я немного покопался в Google и теперь понимаю, почему он не работает. В том, что XmlSerializer на самом деле делает некоторые умные размышления, чтобы сериализовать объекты в/из XML, и поскольку он основан на абстрактном типе, он не может понять, с чем, черт возьми, он говорит . Хорошо.

Я действительно наткнулся на эту страницу на CodeProject, которая выглядит так, как будто она может очень помочь (но все же читать/потреблять полностью), но я подумал, что хотел бы также перенести эту проблему в таблицу StackOverflow, чтобы посмотреть, есть ли у вас какие-либо аккуратные хаки/трюки, чтобы получить это и работать самым быстрым/легким способом.

Одно я должен также добавить, что я не хочу идти по маршруту XmlInclude . Там просто слишком много сцепления с ним, и эта область системы находится в тяжелом развитии, так что это будет настоящая головная боль обслуживания!

У меня есть коллекция классов, которые наследуются от абстрактного класса, который я создал. Я хотел бы использовать абстрактный класс в качестве фабрики для создания экземпляров конкретных реализаций моего абстрактного класса.

Есть ли способ скрыть конструктор от всего кода, кроме родительского класса.

Я хотел бы сделать это в основном

public abstract class AbstractClass
{
    public static AbstractClass MakeAbstractClass(string args)
    {
        if (args == "a")
            return new ConcreteClassA();
        if (args == "b")
            return new ConcreteClassB();
    }
}

public class ConcreteClassA : AbstractClass
{
}

public class ConcreteClassB : AbstractClass
{
}

Но я хочу, чтобы никто не мог напрямую создавать экземпляры 2 конкретных классов. Я хочу убедиться, что только метод MakeAbstractClass() может создавать экземпляры базовых классов. Есть ли способ сделать это?

ОБНОВЛЕНИЕ
Мне не нужно обращаться к каким-либо конкретным методам ConcreteClassA или B из-за пределов абстрактного класса. Мне нужны только общедоступные методы, которые предоставляет мой абстрактный класс. Мне действительно не нужно предотвращать создание экземпляров конкретных классов, я просто пытаюсь избежать этого, поскольку они не предоставляют новых открытых интерфейсов, а просто разные реализации некоторых очень специфических вещей, внутренних для абстрактного класса.

Для меня самым простым решением является создание дочерних классов, как упоминал Сэмюэл. Я хотел бы избежать этого, однако, поскольку это сделало бы файл моего абстрактного класса намного больше, чем мне бы хотелось. Я бы предпочел, чтобы классы были разделены на несколько файлов для организации.

Я думаю, что нет простого решения для этого...

Я хочу знать, что такое "виртуальный базовый класс" и что он означает.

Позвольте мне привести пример:

class Foo
{
public:
    void DoSomething() { /* ... */ }
};

class Bar : public virtual Foo
{
public:
    void DoSpecific() { /* ... */ }
};