Parameterübergabe an Methode Java?
Methode = public boolean addBook(long id, String title, ArrayList <String> authors, String publisher, int year, String isbn);
Aufgabe der Methode = Legt ein neues Objekt vom Typ Book an, initialisiert es mit den übergebenen Parametern und fügt es zu books hinzu, sofern noch kein Buch mit derselben Id vorhanden ist. In diesem Fall wird true zurückgegeben.
Gibt es bereits ein Buch mit derselben Id so wird kein neues Buch hinzugefügt und es wird false zurückgegeben.
Wie schaut diese Aufgabe in Java-Code aus. Bin Anfänger und verzweifle schon seit Tagen daran?
Ich denke mal, die Parameter werden von der Main-Methode übergeben
2 Antworten
Hallo Hubertus777,
wir fangen mit einer einfachen Book-Klasse an um alle nötigen Informationen halten zu können.
import java.util.List;
public class Book {
private final long id;
private final String title;
private final List<String> authors;
private final String publisher;
private final int year;
private final String isbn;
public Book(long id, String title, List<String> authors, String publisher, int year, String isbn) {
this.id = id;
this.title = title;
this.authors = authors;
this.publisher = publisher;
this.year = year;
this.isbn = isbn;
}
public long getId() {
return id;
}
public String getTitle() {
return title;
}
public List<String> getAuthors() {
return authors;
}
public String getPublisher() {
return publisher;
}
public int getYear() {
return year;
}
public String getIsbn() {
return isbn;
}
@Override
public String toString() {
final StringBuffer sb = new StringBuffer("Book{");
sb.append("id=").append(id);
sb.append(", title='").append(title).append('\'');
sb.append(", authors=").append(authors);
sb.append(", publisher='").append(publisher).append('\'');
sb.append(", year=").append(year);
sb.append(", isbn='").append(isbn).append('\'');
sb.append('}');
return sb.toString();
}
}
Dann erstellen wir eine BookShelf-Klasse mit der geforderten Methode. Diese Klasse repräsentiert einfach eine Sammlung von Büchern.
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Stream;
public class BookShelf {
private Map<Long, Book> books = new HashMap<>();
public boolean addBook(long id, String title, List<String> authors, String publisher, int year, String isbn) {
if (containsBookId(id)) {
return false;
}
Book book = new Book(id, title, authors, publisher, year, isbn);
books.put(book.getId(), book);
return true;
}
public Stream<Book> getAllBooks() {
return books.values().stream();
}
private boolean containsBookId(long bookId) {
return books.containsKey(bookId);
}
}
Für einen kleinen Test nutzen wir eine Main-Methode. Wenn man etwas weiter ist sollte man lieber auf Unit-Tests setzen.
import java.util.stream.Collectors;
import java.util.stream.Stream;
import static java.lang.String.format;
import static java.util.Arrays.asList;
public class Main {
private static final String BOOK_OUTPUT_DELIMITER = "\n";
public static void main(String[] args) {
new Main();
}
public Main(){
BookShelf bookShelf = new BookShelf();
boolean result = bookShelf.addBook(12, "My first book", asList("Hanz", "Other Hanz"), "A publisher", 2019, "978-3-16-148410-0");
printResult(result);
result = bookShelf.addBook(14, "My second book", asList("Hanz", "Other Hanz"), "A publisher", 2019, "912-3-12-356323-1");
printResult(result);
result = bookShelf.addBook(16, "My third book", asList("Other Hanz", "Pether"), "other publisher", 2017, "135-6-12-128457-2");
printResult(result);
result = bookShelf.addBook(16, "My third book", asList("Other Hanz", "Pether"), "other publisher", 2017, "135-6-12-128457-2");
printResult(result);
printAllBooks(bookShelf);
}
private void printAllBooks(BookShelf bookShelf) {
Stream<Book> allBooks = bookShelf.getAllBooks();
String resultString = allBooks.map(Book::toString).collect(Collectors.joining(BOOK_OUTPUT_DELIMITER));
System.out.println(resultString);
}
private void printResult(boolean result) {
System.out.println(format("Added book result: %s", result));
}
}
Resultierende Ausgabe sieht dann so aus:
Added book result: true
Added book result: true
Added book result: true
Added book result: false
Book{id=16, title='My third book', authors=[Other Hanz, Pether], publisher='other publisher', year=2017, isbn='135-6-12-128457-2'}
Book{id=12, title='My first book', authors=[Hanz, Other Hanz], publisher='A publisher', year=2019, isbn='978-3-16-148410-0'}
Book{id=14, title='My second book', authors=[Hanz, Other Hanz], publisher='A publisher', year=2019, isbn='912-3-12-356323-1'}
Als Anfänger verzichtet man vielleicht noch auf Streams. Allerdings sind die so praktisch, dass man auch einen frühen Einsatz schon rechtfertigen kann. Im gezeigten Beispiel wird der Stream<Book> auch nur für die Ausgabe verwendet, die in der Aufgabenstellung nicht mal verlangt wird. Aber ich will schon was sehen.
Ansonsten möchte ich noch Anmerken, dass das BookShelf selbst eigentlich keine Books instanziieren sollte. Lieber außerhalb erzeugen lassen und dann an das BookShelf übergeben. Die lange Parameterliste in BookShelf Methode addBook deutet schon auf schlechtes Design hin. Allerdings fordert die Aufgabenstellung genau diese Methode, sodass wir da wohl nicht drum rum kommen.
Gruß und viel Spaß
BookShelf müsste laut Aufgabenstellung wohl "Books" heißen. Ich finde "Books" allerdings auch sehr schlecht benannt. "books" wird viel zu gerne für diverse Collections benutzt, die eben Book-Objekte enthalten. Da wäre mir die Verwechselungsgefahr zu groß.
Ist aber auch Geschmackssache und wenn es in der Aufgabe steht, hat man kaum eine Wahl.
Gruß
Schick mal bitte nur die Aufgabenstellungen ohne deine Ergänzungen. Ich hab die Aufgabe so gelöst wie es da stand. Dass da noch weitere Aufgaben sind konnte ich nicht wissen.
Gruß
Tut mir leid
Angabe
1.)
Schreiben Sie eine Klasse Book, welche folgende Instanzvariablen und Methoden beinhaltet:
Variable
private long id;
private String title;
private ArrayList <String> authors;
private String publisher;
private int year;
private String isbn;
Methode
Verhalten / Zweck
public Book(long id);
Initialisiert alle Instanzvariablen in Book
id wird auf die übergebene id gesetzt
für authors wird eine neue ArrayList initialisiert
publisher und isbn werden mit ““ initialisiert
year wird mit Integer.MAX_VALUE initialisiert
public void addAuthor(String author);
Fügt einen neuen Autor (z.B. Vor- und Nachname) zur ArrayList authors hinzu.
Implementieren Sie weiters für jede Instanzvariable entsprechende „Setter“- und „Getter“- Methoden um Werte zuzuweisen bzw. auszulesen.
2.)
Schreiben Sie eine Klasse BookAdministration, welche folgende Instanzvariablen und Methoden beinhaltet:
Variable
private ArrayList<Book> books;
Methode
Verhalten / Zweck
public BookAdministration();
Initialisiert books mit einer neuen, leeren ArrayList
public boolean addBook(long id, String title, ArrayList <String> authors, String publisher, int year, String isbn);
Legt ein neues Objekt vom Typ Book an, initialisiert es mit den übergebenen Parametern und fügt es zu books hinzu, sofern noch kein Buch mit derselben Id vorhanden ist. In diesem Fall wird true zurückgegeben.
Gibt es bereits ein Buch mit derselben Id so wird kein neues Buch hinzugefügt und es wird false zurückgegeben.
public String getBook(long id);
Sucht das Buch mit der übergebenen Id in books.
Gibt eine String-Repräsentation eines Objektes vom Typ Book zurück, z.B.: “ID;TITLE;AUTHOR1,…,AUTHORn;PUBLISHER;YEAR;ISBN“
Testen Sie Ihre Klassen indem Sie eine Klasse Main inklusive main()-Methode anlegen, und darin ein paar Bücher anlegen, suchen und ausgeben.
Wieder fangen wir mit Book an, sollte sich nicht groß verändert haben:
package books2;
import java.util.ArrayList;
import java.util.List;
import static java.lang.String.format;
public class Book {
private long id;
private String title;
private List<String> authors;
private String publisher;
private int year;
private String isbn;
public Book(long id) {
this.id = id;
this.authors = new ArrayList<>();
this.publisher = "";
this.isbn = "";
this.year = Integer.MAX_VALUE;
}
public void addAuthor(String author) {
this.authors.add(author);
}
public long getId() {
return id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public List<String> getAuthors() {
return authors;
}
public String getPublisher() {
return publisher;
}
public void setPublisher(String publisher) {
this.publisher = publisher;
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
public String getIsbn() {
return isbn;
}
public void setIsbn(String isbn) {
this.isbn = isbn;
}
public void addAuthors(List<String> authors) {
authors.forEach(this::addAuthor);
}
@Override
public String toString() {
final StringBuffer stringBuffer = new StringBuffer("Book{");
stringBuffer.append("id=").append(format("[%d]", id));
stringBuffer.append(", title='").append(title).append('\'');
stringBuffer.append(", authors=").append(authors);
stringBuffer.append(", publisher='").append(publisher).append('\'');
stringBuffer.append(", year=").append(year);
stringBuffer.append(", isbn='").append(isbn).append('\'');
stringBuffer.append('}');
return stringBuffer.toString();
}
}
Wie gewünscht eine BookAdministration mit einer Liste von Book-Objekten. Die Liste ist unpraktischer als die Map, aber die Aufgabe will es so.
package books2;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;
import static java.lang.String.format;
public class BookAdministration {
private static final String BOOK_NOT_FOUND_MESSAGE = "No book with id [%d] found";
private List<Book> books;
public BookAdministration() {
this.books = new ArrayList<>();
}
public boolean addBook(long id, String title, List<String> authors, String publisher, int year, String isbn) {
if (containsBookId(id)) {
return false;
}
Book book = new Book(id);
book.setTitle(title);
book.addAuthors(authors);
book.setPublisher(publisher);
book.setYear(year);
book.setIsbn(isbn);
books.add(book);
return true;
}
public Stream<Book> getAllBooks() {
return books.stream();
}
public String getBook(long bookId) {
// Optional<Book> optional = getAllBooks().filter(b -> b.getId() == bookId).findAny();
//
// if (!optional.isPresent()) {
// return format(BOOK_NOT_FOUND_MESSAGE, bookId);
// }
//
// Book book = optional.get();
//
// return book.toString();
Book foundBook = null;
for (Book book : books) {
if (book.getId() == bookId) {
foundBook = book;
break;
}
}
if (foundBook == null) {
return format(BOOK_NOT_FOUND_MESSAGE, bookId);
}
return foundBook.toString();
}
private boolean containsBookId(long bookId) {
// return getAllBooks().map(Book::getId)
// .anyMatch(id -> id == bookId);
for (Book book : books) {
if (book.getId() == bookId) {
return true;
}
}
return false;
}
}
Dann noch eine Main wie es die Aufgabenstellung verlangt. Nicht schön, aber selten:
package books2;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import static java.lang.String.format;
import static java.util.Arrays.asList;
public class Main {
private static final String BOOK_OUTPUT_DELIMITER = "\n";
public static void main(String[] args) {
new Main();
}
public Main() {
BookAdministration bookAdministration = new BookAdministration();
boolean result = bookAdministration.addBook(12, "My first book", asList("Hanz", "Other Hanz"), "A publisher", 2019, "978-3-16-148410-0");
printResult(result);
result = bookAdministration.addBook(14, "My second book", asList("Hanz", "Other Hanz"), "A publisher", 2019, "912-3-12-356323-1");
printResult(result);
result = bookAdministration.addBook(16, "My third book", asList("Other Hanz", "Pether"), "other publisher", 2017, "135-6-12-128457-2");
printResult(result);
result = bookAdministration.addBook(16, "My third book", asList("Other Hanz", "Pether"), "other publisher", 2017, "135-6-12-128457-2");
printResult(result);
printAllBooks(bookAdministration);
long searchBookdId1 = 100;
System.out.printf("\nSearch for book [%d]:\n", searchBookdId1);
System.out.println(bookAdministration.getBook(searchBookdId1));
long searchBookdId2 = 14;
System.out.printf("Search for book [%d]:\n", searchBookdId2);
System.out.println(bookAdministration.getBook(searchBookdId2));
}
private void printAllBooks(BookAdministration bookAdministration) {
Stream<Book> allBooks = bookAdministration.getAllBooks();
String resultString = allBooks.map(Book::toString).collect(Collectors.joining(BOOK_OUTPUT_DELIMITER));
System.out.println("\nAll Books: ");
System.out.println(resultString);
}
private void printResult(boolean result) {
System.out.println(format("Added book result: %s", result));
}
}
Die Streams habe ich auskommentiert und durch Schleifennutzung ersetzt. Ich denke man kann gut sehen, dass die Schleifen nicht die erste Wahl sind um mit Collections zu arbeiten. Aber wahrscheinlich möchte man im Anfängerbereich unbedingt darauf abzielen.
Dass die Methode getBook einen String zurückgibt finde ich übrigens äußerst hässlich. getBook sollte nach geltender Java-Konvention (und viele andere Sprachen machen es auch so) ein Book-Objekt zurückgeben, keinen String. Aber nu, die Aufgabenstellung will es so.
Gruß
Okay ich glaube ich habs einigermaßen verstanden. Ich werde mich noch ein wenig in deinen Code einlesen um alles 100%ig zu verstehen. Danke du hast mir sehr geholfen. Ich werde jetzt versuchen den Code mal selber zu schreiben, dass ich ihn auch wirklich verstehe.
Gute Idee.
Kannst ja auch abweichende Lösungen implementieren. Gibt da ja auch noch andere for-Schleifen zum Beispiel. Da könntest Du über einen Index gehen.
for (int i = 0; i < books.size(); i++)
Besonders in altem Code findet man das noch sehr oft. Bis man gemerkt hat, dass ein Index auch häufig zu Fehlern führt.
Passend zum Index besetzt List praktischerweise eine get(int index) Methode um das Objekt an der Index-Position abzurufen. Schöner wird der Code damit natürlich nicht, aber es sind Alternativen die man manchmal sogar benötigt.
Gruß
public static void main(String[] args)
{
string parameter1 = args[0]
string p2 = args[1]
//usw.
}
wenn du es als Konsolenanwendung programmierst rufst du die jar z.b. aus dem Windows cmd prompt so auf:
java -jar dateiname.jar "parameter1" "parameter2" "usw"
d.h. diese parameter übergibst du beim start mit.
kannst auch eleganter machen und eine batch datei schreiben und sie einfach ausführen.
In Eclipse selber kannst du dann einfach in der run configuration die parameter mitgeben ohne dieses java -jar gedöns
Aber kann auch sein, dass du was völlig anderes meinst.
wie z.b. die Parameter in der Methode. Die Kannst du dann auch nur innerhalb der Methode benutzen.
Edit: Jetzt beim mehrmaligen lesen deiner Frage -> kannst den ersten Part vergessen -> das interessiert dich für die Aufgabe nicht :D
Wenn ein True zurückgegeben wird, dann ist die function ein bool.
d.h. einfach die methode in der main function ausführen und wenn es klappt -> true oder false ausgabe.
Ich weiss nicht, was dir jetzt nicht klar ist.
Wie man eine Methode mit Parametern aufruft, ist jetzt nicht schwer.
z.b.
public static void main() {
methode(param1value, param2value);
}
methode(string p1, int p2, //was auch immer) {
//programierlogik mit parametern
}
-> In main wird jetzt methode ausgeführt mit deinen übergebenen parametern. Rest muss man sich überlegen, was man in der Logik einbaut.
Da ich wirklich noch ein sehr großer Anfänger bin werde ich einfach nochmal präsentieren wie ich es gelöst habe immer mit Angabe und meiner Lösung.
Angabe 1:
public Book(long id);
Initialisiert alle Instanzvariablen in Book
id wird auf die übergebene id gesetzt
für authors wird eine neue ArrayList initialisiert
publisher und isbn werden mit ““ initialisiert
year wird mit Integer.MAX_VALUE initialisiert
public void addAuthor(String author);
Fügt einen neuen Autor (z.B. Vor- und Nachname) zur ArrayList authors hinzu
Meine Lösung in Intellij
Angabe 2
Schreiben Sie eine Klasse BookAdministration, welche folgende Instanzvariablen und Methoden beinhaltet:
Variable
private ArrayList<Book> books;
Methode
public BookAdministration();
Initialisiert books mit einer neuen, leeren ArrayList
public boolean addBook(long id, String title, ArrayList <String> authors, String publisher, int year, String isbn);
Legt ein neues Objekt vom Typ Book an, initialisiert es mit den übergebenen Parametern und fügt es zu books hinzu, sofern noch kein Buch mit derselben Id vorhanden ist. In diesem Fall wird true zurückgegeben.
Gibt es bereits ein Buch mit derselben Id so wird kein neues Buch hinzugefügt und es wird false zurückgegeben.
public String getBook(long id);
Sucht das Buch mit der übergebenen Id in books.
Gibt eine String-Repräsentation eines Objektes vom Typ Book zurück, z.B.: “ID;TITLE;AUTHOR1,…,AUTHORn;PUBLISHER;YEAR;ISBN“
Meine Lösung
Hier bin ich mit meinem Latein am Ende. Ich verstehe ja die Aufgabe so, dass ich in der Methode addBook ein neues Objekt erstellen soll also Book xxx = new Book (); und dieses neue Objekt soll mit den Variablen der Main-Methode initialisiert werden. Jedoch kann dies ja nicht funktionieren weil ich ja in der Main Methode das Buch bennene und nicht in der Methode.
Wenn ich das erledigt habe soll das Buch in die neu erstelle ArrayList hinzugefügt werden. Bevor dies passiert soll jedoch geprüft werden ob das Buch schon vorhanden ist was ich mit einer for Schleife und einem if Statement lösen würde.
Jetzt muss ich es in die Praxis umsetzen und weiß aber leider immernoch nicht wie :/
Generell sollen wir auch keine weiteren Klassen erstellen sondern wirklich alles nur so Lösen wie in der Angabe