Что такое статические фабричные методы?

Что такое метод "статической фабрики"?

Мы избегаем предоставления прямого доступа к соединениям с базой данных, поскольку они требуют значительных ресурсов. Поэтому мы используем статический метод фабрики, getDbConnectionкоторый создает соединение, если мы находимся ниже предела. В противном случае он пытается предоставить «запасное» соединение, в случае неудачи с исключением, если оно отсутствует.

public class DbConnection{
   private static final int MAX_CONNS = 100;
   private static int totalConnections = 0;

   private static Set<DbConnection> availableConnections = new HashSet<DbConnection>();

   private DbConnection(){
     // ...
     totalConnections++;
   }

   public static DbConnection getDbConnection(){

     if(totalConnections < MAX_CONNS){
       return new DbConnection();

     }else if(availableConnections.size() > 0){
         DbConnection dbc = availableConnections.iterator().next();
         availableConnections.remove(dbc);
         return dbc;

     }else {
         throw new NoDbConnections();
     }
   }

   public static void returnDbConnection(DbConnection dbc){
     availableConnections.add(dbc);
     //...
   }
}

Статический шаблон Фабричный метод является способ создания объекта Encapsulate. Без фабричного метода, вы бы просто вызвать класс в конструктор напрямую: Foo x = new Foo(). С помощью этой модели, вы бы вместо того, чтобы вызвать метод фабрики: Foo x = Foo.create(). Конструкторы помечены как приватные, поэтому их нельзя вызывать, кроме как изнутри класса, а метод фабрики помечается staticтак, что его можно вызывать без предварительного наличия объекта.

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

Еще одно преимущество, как указывали Мэтью и Джеймс, - контроль доступа к ограниченному ресурсу, такому как соединения. Это способ реализации пулов многократно используемых объектов - вместо создания, использования и разрушения объекта, если строительство и уничтожение являются дорогостоящими процессами, может быть более целесообразно их построить один раз и утилизировать. Фабричный метод может вернуть существующий, неиспользуемый экземплярный объект, если он есть, или создать его, если число объектов ниже некоторого нижнего порога, или выдать исключение или вернуть, nullесли он выше верхнего порога.

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

Coordinate c = Coordinate.createFromCartesian(double x, double y)

и

Coordinate c = Coordinate.createFromPolar(double distance, double angle)

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

НОТА! « Статический метод фабрики является НЕ такой же , как Фабричный метод шаблона» (с) Effective Java, Джошуа Блох.

Метод Factory: «Определите интерфейс для создания объекта, но пусть классы, которые реализуют интерфейс, решают, какой класс создавать. Метод Factory позволяет классу отложить создание экземпляров для подклассов» (c) GoF.

«Метод статической фабрики - это просто статический метод, который возвращает экземпляр класса». (с) Эффективная Ява, Джошуа Блох. Обычно этот метод находится внутри определенного класса.

Различия:

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

• значение
• деЫпзЬапсе
• newInstance

Читаемость может быть улучшена статическими фабричными методами:

сравнить

public class Foo{
  public Foo(boolean withBar){
    //...
  }
}

//...

// What exactly does this mean?
Foo foo = new Foo(true);
// You have to lookup the documentation to be sure.
// Even if you remember that the boolean has something to do with a Bar
// you might not remember whether it specified withBar or withoutBar.

в

public class Foo{
  public static Foo createWithBar(){
    //...
  }

  public static Foo createWithoutBar(){
    //...
  }
}

// ...

// This is much easier to read!
Foo foo = Foo.createWithBar();

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

с http://www.javapractices.com/topic/TopicAction.do?Id=21

Все сводится к ремонтопригодности. Лучший способ это сделать - всякий раз, когда вы используете newключевое слово для создания объекта, вы связываете код, который вы пишете, с реализацией.

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

Сегодня фабрики в значительной степени отброшены в пользу использования Dependency Injection, потому что они требуют большого количества кода, который оказывается немного сложным в обслуживании. Внедрение зависимостей в основном эквивалентно фабрикам, но позволяет вам указать, как ваши объекты декларативно соединяются (через конфигурацию или аннотации).

Если конструктор класса является закрытым, вы не можете создать объект для класса извне.

class Test{
 int x, y;
 private Test(){
  .......
  .......
  }
}

Мы не можем создать объект для вышеупомянутого класса извне. Таким образом, вы не можете получить доступ к x, y извне класса. Тогда какая польза от этого класса?
Вот метод Ответ: ФАБРИКА .
Добавьте метод ниже в классе выше

public static Test getObject(){
  return new Test();
}

Так что теперь вы можете создать объект для этого класса извне. Нравится, как ...

Test t = Test.getObject();

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

Я думал, что добавлю немного света в этот пост на то, что я знаю. Мы широко использовали эту технику в нашем recent android project. Вместо этого creating objects using new operatorвы также можете использовать static methodдля создания экземпляра класса. Список кодов:

//instantiating a class using constructor
Vinoth vin = new Vinoth(); 

//instantiating the class using static method
Class Vinoth{
  private Vinoth(){
  }
  // factory method to instantiate the class
  public static Vinoth getInstance(){
    if(someCondition)
        return new Vinoth();
  }
}

Статические методы поддерживают создание условных объектов : каждый раз, когда вы вызываете конструктор, объект создается, но вы можете этого не хотеть. Предположим, вы хотите проверить какое-то условие только тогда, когда захотите создать новый объект. Вы не будете создавать новый экземпляр Vinoth каждый раз, если ваше условие не будет выполнено.

Еще один пример взят из Effective Java .

public static Boolean valueOf(boolean b) {
        return (b ? TRUE : FALSE);
}

Этот метод переводит логическое значение примитива в ссылку на логический объект. Boolean.valueOf(boolean)Метод показывает нам, он никогда не создает объект. Возможность static factory methodsвозвращать один и тот же объект из повторяющихся invocationsпозволяет классам поддерживать строгий контроль над тем, какие экземпляры существуют в любое время.

Static factory methodsв том, что, в отличие от них constructors, они могут возвращать objectлюбой subtypeиз их типа возврата. Одним из применений этой гибкости является то, что API может возвращать объекты, не делая их классы общедоступными. Сокрытие классов реализации таким способом приводит к очень компактному API.

Calendar.getInstance () является отличным примером вышесказанному, он создает в зависимости от локали а BuddhistCalendar, JapaneseImperialCalendarили по умолчанию один Georgian.

Другой пример, о котором я могу подумать Singleton pattern, это когда вы делаете свои конструкторы приватными, создаете собственный getInstanceметод, в котором вы убедитесь, что всегда доступен только один экземпляр.

public class Singleton{
    //initailzed during class loading
    private static final Singleton INSTANCE = new Singleton();

    //to prevent creating another instance of Singleton
    private Singleton(){}

    public static Singleton getSingleton(){
        return INSTANCE;
    }
}

Фабричный метод - метод, который абстрагирует создание объекта от объекта. Обычно фабрики полезны, когда вы знаете, что вам нужен новый экземпляр класса, который реализует некоторый интерфейс, но вы не знаете реализующий класс.

Это полезно при работе с иерархиями связанных классов, хорошим примером этого будет инструментарий GUI. Вы можете просто жестко закодировать вызовы конструкторов для конкретных реализаций каждого виджета, но если вы когда-нибудь захотите поменять один инструментарий на другой, у вас будет много мест для изменения. Используя фабрику, вы уменьшаете объем кода, который вам нужно изменить.

Одно из преимуществ, которое вытекает из статической фабрики, состоит в том, что этот API может возвращать объекты, не делая их классы общедоступными. Это приводит к очень компактному API. В Java это достигается с помощью класса Collections, который скрывает около 32 классов, что делает его API-интерфейс очень компактным.

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

Например, в классе подключения к базе данных может потребоваться, чтобы только один класс создавал подключение к базе данных, поэтому, если вы решите переключиться с Mysql на Oracle, вы можете просто изменить логику в одном классе, а остальная часть приложения будет используйте новое соединение.

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

Он защищает остальную часть приложения от изменений, которые вы можете внести на завод-изготовитель, что является целью.

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

Одно из преимуществ статических методов фабрики с закрытым конструктором (создание объектов должно быть ограничено для внешних классов, чтобы экземпляры не создавались извне) заключается в том, что вы можете создавать управляемые экземплярами классы. А управляемые экземплярами классы гарантируют, что не существует двух одинаковых различных экземпляров ( a.equals (b) тогда и только тогда, когда a == b ) во время работы вашей программы, что означает, что вы можете проверить равенство объектов с помощью оператора == вместо метода equals В соответствии с действующим Java.

Способность статических методов фабрики возвращать один и тот же объект из повторных вызовов позволяет классам в любой момент поддерживать строгий контроль над тем, какие экземпляры существуют. Классы, которые делают это, называются контролируемыми экземплярами. Есть несколько причин для написания управляемых экземпляром классов. Контроль экземпляров позволяет классу гарантировать, что он является одноэлементным (элемент 3) или нереализуемым (элемент 4). Кроме того, он позволяет неизменному классу (элемент 15) гарантировать, что не существует двух одинаковых экземпляров: a.equals (b) тогда и только тогда, когда a == b. Если класс дает такую ​​гарантию, его клиенты могут использовать оператор == вместо метода equals (Object), что может привести к повышению производительности. Типы enum (пункт 30) предоставляют эту гарантию.

От эффективной Явы, Джошуа Блох (Элемент 1, страница 6)

статический

Член объявлен с ключевым словом «статический».

заводские методы

Методы, которые создают и возвращают новые объекты.

на Яве

Язык программирования имеет отношение к значению «статический», но не к определению «фабричный».

Реализация Java содержит классы утилит java.util.Arrays и java.util.Collections. Оба они содержат статические фабричные методы , примеры и способы их использования:

• Arrays.asList("1","2","3")

• Collections.synchronizedList(..), Collections.emptyList(), Collections.unmodifiableList(...) (Только некоторые примеры могут проверять javadocs на наличие примеров из методов: https://docs.oracle.com/javase/8/docs/api/java/util/Collections.html ).

Также у класса java.lang.String есть такие статические фабричные методы :

• String.format(...), String.valueOf(..), String.copyValueOf(...)