Наследование и агрегация

class Album {
//Так как предметная область медиатека, я взял сначала, альбом в котором год и номер
private double god, nomer;
// конструктары
public Album() { god=0; nomer=0; }
public Album(double xval, double yval) { god=xval; nomer=yval; }
public void setGod(double xval) {god=xval;} //перемення значения год
public void setNomer(double yval) {nomer=yval;} //перемення значения номера
public void setAlbum(double xval, double yval) {god=xval; nomer=yval;}
public double getGod() {return god;} //получения года
public double getNomer() {return nomer;} //получения номера
}
//Унаследование, тут носители и тераж, касеты и тераж
class Avtor extends Album{
 
 
private double kaset, tirag;
public Avtor() { setAlbum(0,0); kaset=1; tirag=1; }
public Avtor(double xval, double yval, double l, double w ) {
setAlbum(xval, yval); kaset=l; tirag=w;}
public void setKaset(double val) {kaset=val;}
public void setTirag(double val) {tirag=val;}
public void setSides(double lval, double wval) {
kaset=lval; tirag=wval;}
public double getKaset() {return kaset;}
public double getTirag() {return tirag;}
public double getKol() {return kaset*tirag;} //подсчёт касет
} 
//Тут хотелось бы агрегацию конечно, но пока так
class Video extends Avtor{
double video;
public Video() { setAlbum(0,0); setSides(0,0); video=0; }
public Video(double xval, double yval, double l, double w, double h ) {
setAlbum(xval, yval); setSides(l, w); video=h;}
public void setVideo(double val) {video=val;}
public void setSides(double l, double w, double h) {
super.setSides(l, w); video=h;}
public double getvideo() {return video;}
public double getAll() {
return (getKol()+video);
} 
public double getSumm() {return (getKol()+video;} 
}

import java.util.*;
 
interface MediaData {
    String getType();
}
 
class MediaBook implements MediaData {
    @Override
    public String getType() {
        return "книга";
    }
    @Override
    public String toString() {
        return "MediaBook{" +
            "type=" + getType() +
            "}";
    }
}
 
class MediaFile implements Comparable<MediaFile> {
 
    public static class MediaFileBuilder {
        private MediaFile mediaFile;
        public MediaFileBuilder() {
            mediaFile = new MediaFile();
        }
        MediaFileBuilder setName(String name) {
            mediaFile.setName(name);
            return this;
        }
        MediaFileBuilder addAuthor(String author) {
            mediaFile.getAuthors().add(author);
            return this;
        }
        MediaFileBuilder addTag(String tag) {
            mediaFile.getTags().add(tag);
            return this;
        }
        MediaFileBuilder setData(MediaData data) {
            mediaFile.setData(data);
            return this;
        }
        MediaFile build() {
            return mediaFile;
        }
    }
 
    public static MediaFileBuilder getBuilder() {
        return new MediaFileBuilder();
    }
 
    private String name;
    private static Integer lastUid = 0;
    private String uid;
    private Set<String> authors;
    private Set<String> tags;
    private MediaData data;
 
    MediaFile() {
        name = "";
        uid = Integer.toHexString(lastUid++);
        authors = new HashSet<String>();
        tags = new HashSet<String>();
        data = null;
    }
 
    public String getUid() {
        return uid;
    }
 
    public void setUid(String uid) {
        this.uid = uid;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public Set<String> getAuthors() {
        return authors;
    }
 
    public void setAuthors(Set<String> authors) {
        this.authors = authors;
    }
 
    public Set<String> getTags() {
        return tags;
    }
 
    public void setTags(Set<String> tags) {
        this.tags = tags;
    }
 
    public MediaData getData() {
        return data;
    }
 
    public void setData(MediaData data) {
        this.data = data;
    }
 
    @Override
    public int compareTo(MediaFile o) {
        return getUid().compareTo(o.getUid());
    }
 
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof MediaFile)) return false;
 
        MediaFile mediaFile = (MediaFile) o;
 
        if (!uid.equals(mediaFile.uid)) return false;
 
        return true;
    }
 
    @Override
    public int hashCode() {
        return uid.hashCode();
    }
 
    @Override
    public String toString() {
        return "MediaFile{" +
                "uid='" + uid + '\'' +
                ", name='" + name + '\'' +
                ", authors='" + authors + '\'' +
                ", tags=" + tags +
                ", data=" + data +
                '}';
    }
}
 
class MediaStorage {
    private Set<MediaFile> mediaFiles;
    private Map<String, Set<MediaFile>> mediaFilesByTag;
    private Map<String, Set<MediaFile>> mediaFilesByName;
    private Map<String, Set<MediaFile>> mediaFilesByAuthor;
 
    public MediaStorage() {
        mediaFiles = new TreeSet<MediaFile>();
        mediaFilesByTag = new TreeMap<String, Set<MediaFile>>();
        mediaFilesByName = new TreeMap<String, Set<MediaFile>>();
        mediaFilesByAuthor = new TreeMap<String, Set<MediaFile>>();
    }
 
    private void addByTag(MediaFile mediaFile) {
        for (String tag : mediaFile.getTags()) {
            if (!mediaFilesByTag.containsKey(tag)) {
                mediaFilesByTag.put(tag, new TreeSet<MediaFile>());
            }
            mediaFilesByTag.get(tag).add(mediaFile);
        }
    }
 
    private void addByAuthor(MediaFile mediaFile) {
        for (String author : mediaFile.getAuthors()) {
            if (!mediaFilesByAuthor.containsKey(author)) {
                mediaFilesByAuthor.put(author, new TreeSet<MediaFile>());
            }
            mediaFilesByAuthor.get(author).add(mediaFile);
        }
    }
 
    private void addByName(MediaFile mediaFile) {
        if (!mediaFilesByName.containsKey(mediaFile.getName()))
            mediaFilesByName.put(mediaFile.getName(), new TreeSet<MediaFile>());
        mediaFilesByName.get(mediaFile.getName()).add(mediaFile);
    }
 
    public void add(MediaFile mediaFile) {
        mediaFiles.add(mediaFile);
        addByTag(mediaFile);
        addByName(mediaFile);
        addByAuthor(mediaFile);
    }
 
    public Collection<MediaFile> getByTag(String tag) {
        return new HashSet<MediaFile>(mediaFilesByTag.get(tag));
    }
    public Collection<MediaFile> getByAuthor(String author) {
        return new HashSet<MediaFile>(mediaFilesByAuthor.get(author));
    }
    public Collection<MediaFile> getByName(String name) {
        return new HashSet<MediaFile>(mediaFilesByName.get(name));
    }
 
    @Override
    public String toString() {
        return "MediaStorage{" +
            "mediaFiles=" + mediaFiles +
            '}';
    }
}
 
public class Tutorial0007 {
    public static void main(String[] args) {
        MediaStorage storage = new MediaStorage();
 
        storage.add(MediaFile.getBuilder()
                .addAuthor("Иван Иванов").addAuthor("Петр Петров")
                .setName("Основы программирования на Java")
                .addTag("основы").addTag("java").addTag("программирование").addTag("обучение")
                .setData(new MediaBook())
                .build());
 
        storage.add(MediaFile.getBuilder()
                .addAuthor("Петр Петров")
                .setName("Ядерная физика для домохозяек")
                .addTag("обучение").addTag("физика").addTag("основы")
                .setData(new MediaBook())
                .build());
 
        storage.add(MediaFile.getBuilder()
                .addAuthor("Иван Иванов").addAuthor("Семен Семенов")
                .setName("Суслики -- миф или реальность?")
                .addTag("обучение").addTag("эзотерика").addTag("животноводство")
                .setData(new MediaBook())
                .build());
 
        System.out.println(storage);
 
        System.out.println(storage.getByTag("основы"));
        System.out.println(storage.getByAuthor("Иван Иванов"));
    }
}