¿Cómo organizar de forma lógica en el código paquete preservando al mismo tiempo la encapsulación

gixlg:

Esta es una cuestión conceptual.
Me suelen organizar en paquetes de código lógicamente. Por ejemplo: operación matemática va en my.package.matho lógica de negocio entra en my.package.businessy así sucesivamente.

En estos días tengo una duda que quiero Sare sobre una restricción impuesta por la visibilidad de paquete en Java.

Te voy a enseñar algo de código para explicar mejor mi caso: Tengo la siguiente estructura del paquete:

+-- org.example
    +-- greetings
    |   +-- RandomGreetings
    +-- GreetingsService
    |
    +-- Main

y el siguiente código:

GreetingsService.java

package org.example;

import org.example.greetings.RandomGreetings;

public class GreetingsService {
    public String greetingsToTheWorld(){
        RandomGreetings greetings = new RandomGreetings();
        return greetings.say() + " World";
    }
}

RandomGreetings.java

package org.example.greetings;

import java.util.Random;

class RandomGreetings {
    public String say() {
        Random rand = new Random();
        int value = rand.nextInt(2);
        return value==0 ? "Hello" : "Hi";
    }
}

Main.java

package org.example;

public class Main {

    public static void main(String[] args) {
        GreetingsService sayHelloService = new GreetingsService();
        System.out.println(sayHelloService.greetingsToTheWorld());
    }
}

Este código, como os muestro, no se compila porque la clase RandomGreetingses el paquete visible que significa que no pueden GreetingsService instanciarlo. Este problema puede ser resuelto de venta pública en la clase RandomGreetings:

public class GreetingsService {
...
}

Pero RandomGreetingspara mí es una implementación que quiero mantener la encapsulación y no es visible pública. En este escenario, el mundo (cualquiera que importar el frasco artefacto del que puede producir) es capaz de ver y llamar a esa clase y que no es algo que yo quiero.

Otra posible solución es mover GreetingsServiceal mismo nivel de RandomGreetings, así:

+-- org.example
    +-- greetings
    |   +-- RandomGreetings
    |   |
    |   +-- GreetingsService
    |
    +-- Main

En este caso, el código se compila con éxito y el RandomGreetingsse encapsula pero terminan con otro problema para mí.
No más capaz de organizar esa clase en el paquete en un orden lógico.
En este caso, hay unos pocos de clase por lo que la situación sigue siendo manejable, pero si el número de aumento de la clase no será sólo un paquete único grande que piensan.

Sé que en Java no hay visibilidad sub-paquete , por lo que ¿cómo manejar esta situación?
¿Cómo se resolvería el problema de mi código de seguridad?

progman:

Cuando se desea utilizar un paquete, debe tener algún punto de entrada, que tiene que ser public. De lo contrario se puede tirar el paquete de distancia, ya que no se puede utilizar. Esto significa que su org.example.greetingsenvase debe tener algo, que es publicy puede ser utilizado / llamada de "afuera". No tiene por qué ser su RandomGreetingsclase.

Se puede definir una interfaz (en el org.examplepaquete), ponerlo en práctica en su RandomGreetingsclase y utilizar otro publicmétodo para crear y devolver el "visible paquete" RandomGreetingsde clase. El código podría tener este aspecto:

package org.example;

public interface Greeting {
    public String say();
}

Esto se implementa por la RandomGreetingsclase:

package org.example.greetings;

import org.example.Greeting;

class RandomGreetings implements Greeting {
    // ...
}

A continuación, se define una publicclase de ayuda para devolver un RandomGreetingsobjeto del org.example.greetingspaquete:

package org.example.greetings;

import org.example.Greeting;

public GeneratorHelper {
    public static Greeting buildIt() {
         return new RandomGreetings();
    }
}

Cuando se utiliza el GeneratorHelper.buildIt()método se obtiene un objeto que implementa la Greetinginterfaz. Pero no se puede acceder a la RandomGreetingsclase en sí, ya que sigue siendo "paquete visible".