Каково использование создания конструктора, частного в классе?

Я бы пошел с доктриной. Мне кажется, что это гораздо более активным проектом и является ORM по умолчанию для Symfony, тем лучше поддерживаться (хотя официально Официально ОРМ считаются равными).

Кроме того, я лучше, как вы работаете с запросами (DQL вместо критериев):

<?php
// Propel
$c = new Criteria();
$c->add(ExamplePeer::ID, 20);
$items = ExamplePeer::doSelectJoinFoobar($c);

// Doctrine
$items = Doctrine_Query::create()
       ->from('Example e')
       ->leftJoin('e.Foobar')
       ->where('e.id = ?', 20)
       ->execute();
?>

(реализация доктрины гораздо интуитивно понятна для меня).

Также я действительно предпочитаю, как вы управляете отношениями в доктрине.

Я думаю, что эта страница от доктрины Документация стоит читать: http://www.doctrine-project.org/documentation/manual/1_2/ru/introduction:doctrine-xplied

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

Утилита классов может иметь частные конструкторы. Пользователи классов не должны иметь возможность создавать экземпляры этих классов:

public final class UtilityClass {
    private UtilityClass() {}

    public static utilityMethod1() {
        ...
    }
}

цитирование из Эффективного Java , вы можете иметь класс С частным конструктором, чтобы иметь класс утилиты, который определяет константы (в виде статических окончательных полей).

( Редактировать: Согласно комментарию, это то, что может быть применимо только с Java, я не знаю, если эта конструкция применима / необходима в других языках OO (скажем, C ++))

Пример, как показано ниже:

public class Constants {
    private Contants():

    public static final int ADDRESS_UNIT = 32;
    ...
}

Edit_1 : Опять же, под объяснением применимо в Java: (и ссылаясь из книги, Эффективной Java )

Эксирование утилитового класса, как тот, кто ниже, хотя и не вреден, не служит Любые цели, поскольку они не предназначены для создания.

Например, сказать, что нет частного конструктора для констант класса. Кусок кода, как ниже, является действительным, но лучше не передавать намерение пользователь класса констант

unit = (this.length)/new Constants().ADDRESS_UNIT;

В отличие от кода, как

unit = (this.length)/Constants.ADDRESS_UNIT;

Также я думаю, что частный конструктор передает намерение дизайнера констант (сказать) класс лучше.

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

Нельзя отметить статический класс верхнего уровня, и даже конечный класс можно создать.

Я видел вопрос от вас, обращаясь к тому же вопросу.

Просто если вы не хотите, чтобы другие могли создавать экземпляры, то сохраняйте состав в ограниченном объеме. Практическое применение (пример) - синглтон.

Если он является частным, то вы не можете назвать это ==> Вы не можете создать экземпляр класса. Полезно в некоторых случаях, как синглтон.

Есть обсуждение и еще несколько примеров здесь .

Существуют некоторые экземпляры, где вы не могли бы хотеть использовать общедоступного конструктора; например, если вы хотите singleton-класс.

, Если вы пишете блок, используемый третьими сторонами, могло бы быть много внутренних классов, которые вы только хотите созданный вашим блоком а не быть инстанцированными пользователями вашего блока.

Это может быть очень полезно для конструктора, который содержит общий код; Частные конструкторы могут быть вызваны другими конструкторами, используя «Это (...);» Обозначение. Сделав общий код инициализации в частном (или защищенном) конструкторе, вы также делаете явно ясно, что его называют только во время строительства, что не так, если бы это было просто методом:

public class Point {
   public Point() {
     this(0,0); // call common constructor
   }
   private Point(int x,int y) {
     m_x = x; m_y = y;
   }
};

Вы не должны сделать конструктор частным. Период. Сделайте его защищенным, чтобы вы могли продлить класс, если вам нужно.

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

Если это утилиты, упрощенный, более правильный и более элегантный раствор состоит в том, чтобы отметить весь класс «Статический финал» для предотвращения расширения. Это не приятно просто отметить частную конструктор; Действительно определенный пользователь всегда может использовать отражение для получения конструктора.

Действительное использование:

• Одно хорошее использование защищенного Конструктор - заставить использование статического фабричные методы, которые позволяют вам Ограничить змеевление или пул и повторное использование Дорогие ресурсы (соединения БД, родные ресурсы).
• Singletons (обычно не хорошая практика, но иногда необходимо)

Все зациклены на синглтоне, ничего себе.

Другое:

• Не позволяйте людям создавать ваш класс в стеке; создавать частные конструкторы и возвращать указатели только через фабричный метод.
• Предотвращение создания копий класса (частный конструктор копии)

Оставить "черный ход", позволяющий другому классу/функции друга построить объект запрещенным пользователю способом. Примером, который приходит на ум, может быть контейнер, создающий итератор (C++):

Iterator Container::begin() { return Iterator(this->beginPtr_); }
// Iterator(pointer_type p) constructor is private,
//     and Container is a friend of Iterator.

Это действительно одна очевидная причина: вы хотите построить объект, но непрактично делать это (с точки зрения интерфейса) внутри конструктора.

Пример Factory достаточно очевиден, позвольте мне продемонстрировать идиому Named Constructor.

Допустим, у меня есть класс Complex, который может представлять комплексное число.

class Complex { public: Complex(double,double); .... };

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

Я могу изменить интерфейс, чтобы сделать это проще:

class Complex
{
public:
  static Complex Regular(double, double = 0.0f);
  static Complex Polar(double, double = 0.0f);
private:
  Complex(double, double);
}; // class Complex

Это называется идиомой Named Constructor: класс может быть создан с нуля, только явно указав, какой конструктор мы хотим использовать.

Это частный случай многих методов конструирования. Паттерны проектирования предоставляют хорошее количество способов построения объекта: Builder, Factory, Abstract Factory, ... и частный конструктор обеспечит должное ограничение пользователя.

Это гарантирует, что вы (класс с частным конструктором) контролируете, как вызывается конструктор.

Пример: статический фабричный метод в классе может возвращать объекты, которые фабричный метод выберет для их размещения (например, одиночная фабрика).

Одно из важных применений - класс SingleTon

class Person
{
   private Person()
   {
      //Its private, Hense cannot be Instantiated
   }

   public static Person GetInstance()
   {
       //return new instance of Person
       // In here I will be able to access private constructor
   }
};

Он также подходит, если ваш класс имеет только статические методы. т.е. никому не нужно инстанцировать ваш класс

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

A. Экземпляры вашего класса создаются в статическом методе. Затем метод static объявляется как public.

class MyClass()
{
private:
  MyClass() { }

public:
  static MyClass * CreateInstance() { return new MyClass(); }
};

B. Ваш класс является синглтоном. Это означает, что в программе существует не более одного экземпляра вашего класса.

class MyClass()
{
private:
  MyClass() { }

public:
  MyClass & Instance()
  {
    static MyClass * aGlobalInst = new MyClass();
    return *aGlobalInst;
  }
};

C. (Применимо только к грядущему стандарту C++0x) У вас есть несколько конструкторов. Некоторые из них объявлены public, другие private. Для уменьшения объема кода публичные конструкторы "вызывают" частные конструкторы, которые в свою очередь выполняют всю работу. Таким образом, ваши публичные конструкторы называются делегирующими конструкторами:

class MyClass
{
public:
  MyClass() : MyClass(2010, 1, 1) { }

private:
  MyClass(int theYear, int theMonth, int theDay) { /* do real work */ }
};

D. Вы хотите ограничить копирование объектов (например, из-за использования общего ресурса):

class MyClass
{
  SharedResource * myResource;

private:
  MyClass(const MyClass & theOriginal) { }
};

E. Ваш класс является утилитарным классом. Это означает, что он содержит только статические члены. В этом случае в программе никогда не должен создаваться экземпляр объекта.

Вы можете захотеть предотвратить свободное инстанцирование класса. В качестве примера см. шаблон проектирования singleton. Чтобы гарантировать уникальность, вы не можете позволить никому создать его экземпляр :-)