Зачем служат локальные классы в Java?

Я нашел документацию Java по локальным классам и не нахожу Вашу утилиту. А именно, если я помещаю класс, на другую не была бы должна провоцировать меня ошибка.

Я имею в виду это: Inner Класс Эксампле.

Они могли бы объяснять мне Вашу утилиту и предоставлять мне какой-то пример, который не давал мне ошибку после того, как имел два класса в том же файле?

5
задан 06.12.2016, 07:32
3 ответа

Согласно документации Oracle: Укрытые классы позволяют группировать логической формы классы, которые только будут использованы в единственном месте, увеличивая использование encapsulación и создавая код, более понятный и легкий для того, чтобы быть поддержанным.

https://docs.oracle.com/javase/tutorial/java/javaOO/whentouse.html

5
ответ дан 24.11.2019, 12:15

Это внутренние классы и он не должен давать тебе ошибку. Ссылка, которую ты поместил, это определяет верно. Я боюсь, что это будет проблема того, как ты размещаешь ключи. Если твоя ошибка состоит в том, что твой IDE говорит, что у класса должно быть то же имя, что и файл .java, обрати внимание, что твой внутренний класс был внутри ключей класса, который определяет файл, он должен бы быть в ту же высоту, что и Ваш строитель для того, чтобы я объяснился.

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

Я ИЗДАЮ:

Чтобы добавлять твой пример, и что у тебя остался более ясным:

public class Coche {
    String marca;
    Motor motor;

    public Coche (String marca, Motor motor) {
        this.marca = marca;
        this.motor = motor;
        System.out.println("Escribe la marca del carro:");
    }

    public void mostrarCoche(){
        System.out.println("Coche marca: " + marca + " | motor: " + motor);
    }

    public class Motor {
        String tipoMotor;

        public Motor (){
            tipoMotor = "Uno Cualquiera";
        }

        @Override
        public String toString(){
            return tipoMotor;
        }
    }
5
ответ дан 24.11.2019, 12:15
  • 1
    привет Awes0meM4n я понимаю, что он служит как класс внутри класса? но мой вопрос ты мог давать тому пример в ежедневной жизни разработки, в которой вещь могла бы осуществлять это, я не понимаю – sommer0123 05.12.2016, 22:04
  • 2
    Представь, что у тебя есть класс vehí зад и ты нуждаешься в том, чтобы осуществить другой класс механизм. Если só ты это будешь использовать класс механизм в классе vehí зад, не надо, чтобы ты сделал другой файл .java для класса двигательный, ты можешь делать ее практиканткой и у тебя остается пакет má s компактный. – Awes0meM4n 05.12.2016, 22:06
  • 3
    Конечно @sommer0123, вне темы, и поскольку я увидел тебе, что ты попробовал сообщить má s комментария в частности, если ты хочешь сделать это, ты должен помещать предшествуемое имя пользователя одной пользователям и все объединенный. Ты можешь видеть это в этикетке, которую он помещает " ayuda" рядом с комментариями, которые ты пишешь. – Awes0meM4n 05.12.2016, 22:12
  • 4
    haaaaaa okey aver пашите пример aver, если он, как ты это комментируешь: – sommer0123 05.12.2016, 22:15
  • 5
    package ClassLocales; import java.util. Scanner; public class ClaseMain { public static void main (String [] args) { введенный Scanner = new Сканнер (System.in); System.out.println (" Напиши отметку carro:"); } public class методы { public static Стринг Карро (String автомобиль) { return автомобиль; } } } – sommer0123 05.12.2016, 22:15

Ответы @Garrizano и @Awes0meM4n покрывают концепцию. То, чего нет, состоит в том, чтобы объяснять, когда полезные эти классы. Давайте видеть каждый класс согласно Вашему типу:

  1. Внутренние статические классы

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

Пример:

public class Persona {
    private int id;
    private String nombre;

    //constructor, getters y setters...
    //método toString
    public String toString() {
        return id + " " + nombre;
    }
}

public class Comparadores {
    public static class ComparadorPersonaPorId implements Comparator<Persona> {
        @Override
        public int compare(Persona p1, Persona p2) {
            Objects.requireNonNull(p1);
            Objects.requireNonNull(p2);
            return Integer.compare(p1.getId(), p2.getId());
        }
    }

    public static class ComparadorPersonaPorNombre implements Comparator<Persona> {
        @Override
        public int compare(Persona p1, Persona p2) {
            Objects.requireNonNull(p1);
            Objects.requireNonNull(p2);
            //puede que hayas importado alguna librería con este utilitario
            //o que lo crees por tu cuenta
            //el código de compare de cadenas es algo como
            // return s1 == null && s2 == null ? 0 :
            //            s1 == null ? -1 :
            //            s2 == null ? 1 : s1.compareTo(s2);
            return StringUtils.compare(p1.getNombre(), p2.getNombre());
        }
    }
}

public class Principal {
    public static void main(String[] args) {
        List<Persona> personas = Arrays.asList(
            new Persona(1, "Jose"),
            new Persona(3, "Gabriela"),
            new Persona(2, "Alvin"));
        System.out.println(personas);
        personas.sort(new Comparadores.ComparatorPersonaPorId());
        System.out.println(personas);
        personas.sort(new Comparadores. ComparadorPersonaPorNombre());
        System.out.println(personas);
    }
}

Примеры в JDK: LinkedList#Node (линия 970), HashMap#Node (линия 278), Arrays#ArrayList (линия 3800).

  1. Внутренние не статические классы

Равно как внутренние статические классы, они используются главным образом командой в твоих компонентах. Факт того, что не статика значит, что он может соглашаться на состояние класса, который содержит ее. Это большое преимущество, когда ты разрабатываешь классы логики дела, которые не нуждаются в том, чтобы быть выставленными внешнему миру.

Приспособленный пример класса, который я осуществил давно (сочинение для Java 6):

public interface BonoService {
    void validaBonos(String excel);
    //entre otros métodos...
}

public class BonoServiceImpl implements BonoService {

    private BonoDao bonoDao;
    private ClienteService clienteService;
    private int numeroHilos;

    @Override
    public void validaBonos(String excel) {
        List<Bono> listaBonos = obtieneBonos(excel);
        //la acción de validar cada Bono toma mucho tiempo
        //así que vamos a procesarlos en hilos
        ExecutorService es = Executors.newFixedThreadPool(numeroHilos);
        for (Bono bono : listaBonos) {
            es.submit(new ValidadorBono(bono));
        }
        es.shutdown();
        while (!es.isTerminated()) {
            //esperar que termine de validar todos los bonos...
        }
    }

    private List<Bono> obtieneBonos(String excel) {
        //lee un archivo Excel en base a la ruta
        //convierte cada línea del archivo en una instancia de Bono
        //devuelve una lista con los bonos encontrados
    }

    private class ValidadorBono implements Runnable {
        Bono bono;
        public ValidadorBono(Bono bono) {
            this.bono = bono;
        }

        @Override
        public void run() {
            //implementación de validación de objeto Bono
            //ejemplo de una regla de validacion
            //Como se menciona, se pueden acceder a los atributos
            //y métodos de la clase contenedora
            //por ejemplo, el siguiente código hace referencia al
            //atributo clienteService que se encuentra en la clase superior
            if (BonoServiceImpl.this.clienteService
                //el de aquí es un método del objeto
                .existeCliente(bono.getCliente()) {
                //continuar...
            }
        }
    }
}

Примеры в JDKL ArrayList#Itr (линия 825).

  1. Внутренние локальные классы

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

Пример:

public class EjercicioHilos {
    public static void main(String[] args) {
        //usaremos ExecutorService nuevamente
        ExecutorService es = Executors.newFixedThreadPool(10);
        for (int i = 1; i < 1000; i++) {
            //Runnable es una interfaz
            //las llaves luego de new Runnable()
            //indican que se va a escribir la implementación
            //de manera directa aquí en el método

            //las clases locales no pueden reasignar variables
            //que pertenecen al método
            //por ello, para usar una variable ella debe ser
            //declarada como final
            //por ello no podemos pasar "i" directamente
            //sino mediante una variable "final int x"
            final int x = i;
            es.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(x);
                }
            });
        }
    }
}

Заметь: все эти примеры могут быть re письменные используя новую функцию Java 8: lambdas. Код более краткий и прямой.

2
ответ дан 24.11.2019, 12:15