Implementando una clase anidada al proyecto

Se utilizan las clases inner cuando quieres tener acceso a algun medodo de la clas exterior

Se utilizan las clases abstractas cuando no necesariamente quieres tener acceso a los metodos de la clase exterior

Pregunta como se haría una clase anidada en un diagrama de UML de clases.

muy buena clase y excelente explicación!!!

Vamos a trabajar.!!

Esta es mi versión de la definición de la clase anidada Page.

Page

import com.erosennin.amazonviewer.utils.Utils;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeUnit;

public class Book extends Publication implements Visualizable {

    private int id;
    private String isbn;
    private int pages;
    private Date startDate;

    public Book(String title, String editorial, String[] authors, Date publicationDate, String isbn, boolean readed, int pages) {
        super(title, editorial, authors, publicationDate);
        super.setReaded(readed);
        this.isbn = isbn;
        this.pages = pages;
    }

    public int getId() {
        return id;
    }

    public String getIsbn() {
        return isbn;
    }

    public int getPages() {
        return pages;
    }

    public static List<Book> makeBooksList() {
        List<Book> books = new ArrayList<>();
        for (int i = 1; i < 6; i++) {
            books.add(new Book("Book " + i, "Editorial " + i, new String[]{"Author " + i}, new Date(),
                    "ISBN " + i, false, 200 + i));
        }
        return books;
    }

    public void view() {
        setReaded(true);
        startToSee(new Date());
        for (int i = 0; i < 100; i++) {
            System.out.println("...You are reading the " + getTitle() + "...");
        }
        Utils.timeDelay(2);
        stopToSee(new Date());
        System.out.println("\n::YOU JUST SAW::" + toString());
    }

    @Override
    public String toString() {
        StringBuilder printerAuthors = new StringBuilder();
        String[] authors = getAuthors();
        for (String author : authors) {
            printerAuthors.append(author).append(", ");
        }
        printerAuthors.delete(printerAuthors.length() - 2, printerAuthors.length() - 1);
        return "\n::BOOK::" +
                "\nTitle: " + getTitle() +
                "\nPublisher: " + getEditorial() +
                "\nAuthors: " + printerAuthors +
                "\nPublication Date: " + new SimpleDateFormat("dd/MM/yyyy").format(getPublicationDate()) +
                "\nISBN: " + getIsbn() +
                "\nReaded: " + isReaded() +
                "\nPages: " + getPages();
    }

    @Override
    public void startToSee(Date startDate) {
        this.startDate = startDate;
    }

    @Override
    public void stopToSee(Date endDate) {
        if (startDate.getTime() < endDate.getTime()) {
            setTimeReaded((int) (endDate.getTime() - startDate.getTime()));
        } else {
            setTimeReaded(0);
        }
    }


    public static class Page {

        private int id;
        private int number;
        private String content;

        public Page(int number, String content) {
            this.number = number;
            this.content = content;
        }

        public int getNumber() {
            return number;
        }

        public String getContent() {
            return content;
        }
    }
}

si en buen punto las clases anidadas como se representan en UML

muy buena claseee!!!

Que buena clase, un ejemplo muy bueno

Me parece que ya viene lo más emocionante 😄

un ejemplo muy bueno de aplicacion, quedo claro el tema.

Muy buen ejemplo, algo que me pareció importante fue lo de Inner y Static:

Utilizamos Inner Class cuando queremos tener acceso a algún método en donde estamos y Static Class no necesariamente queremos tener acceso a los métodos en este caso de Book.

Excelente clase buena practica

Muy buena implementación, muy interesante esta nueva herramienta

Las clases anidadas son una representación de la relación Composición?

Super 😃

/**
 * Clase Interior Page
 * */
public static class Page { }

Genial.

Excelente clase, ahora me quedo más clara la diferencia entre las clases static y las clases inner respecto al uso de métodos de la clase externa.

Entonces existen clases que hacen parte de otras, que su definición esta en la definición de otra clase (por eso el aninadadas)

¿En qué se diferenciaría con qué una clase tenga como atributo a otra clase? ¿En qué casos es mejor una u otra?

Tengo entendido que es cuándo nadie más hará uso de ella, pero ¿Trae más ventajas?