// get an instance of logger 
   private static Logger logger = LoggerFactory.getLogger(PolicyContainer.class);       
   // 'KieServices' singleton
-  static private KieServices kieServices = KieServices.Factory.get();
+  private static KieServices kieServices = KieServices.Factory.get();
 
   // set of all 'PolicyContainer' instances
-  static private HashSet<PolicyContainer> containers =
+  private static HashSet<PolicyContainer> containers =
        new HashSet<>();
 
   // maps feature objects to per-PolicyContainer data
   // indicates whether the scanner has been started
   // (it can block for a long time)
   private boolean scannerStarted = false;
+  
+  private static final String ERROR_STRING = "ERROR: Feature API: ";
 
   /**
    * uses 'groupId', 'artifactId' and 'version', and fetches the associated
                                  }
                                catch (Exception e)
                                  {
-                                       logger.error("ERROR: Feature API: "
+                                       logger.error(ERROR_STRING
                                                                 + feature.getClass().getName(), e);
                                  }
                          }
                                          }
                                        catch (Exception e)
                                          {
-                                               logger.error("ERROR: Feature API: "
+                                               logger.error(ERROR_STRING
                                                                         + feature.getClass().getName(), e);
                                          }
                                  }
                          }
                        catch (Exception e)
                          {
-                               logger.error("ERROR: Feature API: "
+                               logger.error(ERROR_STRING
                                                         + feature.getClass().getName(), e);
                          }
                  }
   public synchronized void startScanner(ReleaseId releaseId)
   {
        String version = releaseId.getVersion();
-       if (scannerStarted == false && scanner == null && version != null
+       if (!scannerStarted && scanner == null && version != null
                && ("LATEST".equals(version) || "RELEASE".equals(version)
                        || version.endsWith("-SNAPSHOT")))
          {
                                  }
                                catch (Exception e)
                                  {
-                                       logger.error("ERROR: Feature API: "
+                                       logger.error(ERROR_STRING
                                                                 + feature.getClass().getName(), e);
                                  }
                          }
                          }
                        catch (Exception e)
                          {
-                               logger.error("ERROR: Feature API: "
+                               logger.error(ERROR_STRING
                                                         + feature.getClass().getName(), e);
                          }
                  }
   /**
    * This method is called when the host goes from the 'standby->active' state.
    */
-  static public void activate()
+  public static void activate()
   {
        // start all of the 'PolicyContainer' instances
        for (PolicyContainer container : containers)
   /**
    * This method is called when the host goes from the 'active->standby' state.
    */
-  static public void deactivate()
+  public static void deactivate()
   {
        // deactivate all of the 'PolicyContainer' instances
        for (PolicyContainer container : containers)
    *
    * @param args standard 'main' arguments, which are currently ignored
    */
-  public static void globalInit(String args[])
+  public static void globalInit(String[] args)
   {
        String configDir = "config";
        logger.info("PolicyContainer.main: configDir=" + configDir);
                  }
                catch (Exception e)
                  {
-                       logger.error("ERROR: Feature API: "
+                       logger.error(ERROR_STRING
                                                 + feature.getClass().getName(), e);
                  }
          }
 
   private ThreadModel threadModel = null;
 
   // supports 'getCurrentSession()' method
-  static private ThreadLocal<PolicySession> policySession =
+  private static ThreadLocal<PolicySession> policySession =
        new ThreadLocal<>();
 
   /**
         * 'KieContainer.updateToVersion(...)' has been called (meaning the
         * full name of this session has changed).
         */
-       default public void updated() {}
+       public default void updated() {}
   }
 
   /* ============================================================ */
         */
        private String getThreadName()
        {
-         return("Session " + session.getFullName());
+         return "Session " + session.getFullName();
        }
 
        /***************************/
 
    * 'FeatureAPI.impl.getList()' returns an ordered list of objects
    * implementing the 'FeatureAPI' interface.
    */
-  static public OrderedServiceImpl<PolicySessionFeatureAPI> impl =
+  public static OrderedServiceImpl<PolicySessionFeatureAPI> impl =
        new OrderedServiceImpl<>(PolicySessionFeatureAPI.class);
 
   /**
    * @param args standard 'main' arguments, which are currently ignored
    * @param configDir the relative directory containing configuration files
    */
-  default public void globalInit(String args[], String configDir) {}
+  public default void globalInit(String[] args, String configDir) {}
 
   /**
    * This method is used to create a 'KieSession' as part of a
    *   (this depends on the capabilities and state of the object implementing
    *   this interface)
    */
-  default public KieSession activatePolicySession
+  public default KieSession activatePolicySession
        (PolicyContainer policyContainer, String name, String kieBaseName)
   {
        return null;
    *
    * @param policySession the new 'PolicySession' instance
    */
-  default public void newPolicySession(PolicySession policySession) {}
+  public default void newPolicySession(PolicySession policySession) {}
 
   /**
    * This method is called to select the 'ThreadModel' instance associated
    * with a 'PolicySession' instance.
    */
-  default public PolicySession.ThreadModel selectThreadModel
+  public default PolicySession.ThreadModel selectThreadModel
        (PolicySession session)
   {
        return null;
    * @param policySession the 'PolicySession' object that wrapped the
    *   'KieSession'
    */
-  default public void disposeKieSession(PolicySession policySession) {}
+  public default void disposeKieSession(PolicySession policySession) {}
 
   /**
    * This method is called after 'KieSession.destroy()' is called
    * @param policySession the 'PolicySession' object that wrapped the
    *   'KieSession'
    */
-  default public void destroyKieSession(PolicySession policySession) {}
+  public default void destroyKieSession(PolicySession policySession) {}
 }