CodeGym/Help with Java Tasks/It works but doesn't compile

Level 20

Tomsk

13.05.2021
599views
10comments

It works but doesn't compile

Question about the task

OOP: Books

Java Core, Level 5, Lesson 2

Resolved

Hello! It shows correctly result in IDE. Why CodeGym doesn't accept it?

1. Create a public static class MarkTwainBook that inherits Book. Name of the author [Mark Twain].
The constructor parameter is the book title.
2. Implement all the abstract methods in the MarkTwainBook class.
3. Change the return type of the getBook method to make it more appropriate.
4. In a similar manner, create the AgathaChristieBook class. Name of the author [Agatha Christie].
5. In the Book class, implement the getOutputByBookType method so that it returns:
5.1. agathaChristieOutput for books written by Agatha Christie;
5.2. markTwainOutput for books written by Mark Twain.

Requirements:

The Solution class must contain the public static MarkTwainBook class.
The MarkTwainBook class must be a descendant of the Book class.
The MarkTwainBook class must correctly implement a constructor with one String parameter (book title).
The MarkTwainBook class constructor should call the constructor of the parent class (Book) with the argument "Mark Twain".
The getBook method in the MarkTwainBook class must have the MarkTwainBook return type and return the current object.
The Solution class must contain the public static AgathaChristieBook class.
The AgathaChristieBook class must be a descendant of the Book class.
The AgathaChristieBook class must correctly implement a constructor with one String parameter (book title).
The AgathaChristieBook class constructor should call the constructor of the parent class (Book) with the argument "Agatha Christie".
The getBook method in the AgathaChristieBook class must have the AgathaChristieBook return type and return the current object.
The getTitle method in the AgathaChristieBook and MarkTwainBook classes should return the title of a specific book.
The getOutputByBookType method must return the correct string for AgathaChristieBook objects.
The getOutputByBookType method must return the correct string for MarkTwainBook objects.
The MarkTwainBook class must have a String field title (book title).
The AgathaChristieBook class must have a String field title (book title).

package com.codegym.task.task15.task1504; import java.util.LinkedList; import java.util.List; /* OOP: Books */ public class Solution { public static void main(String[] args) { List<Book> books = new LinkedList<Book>(); books.add(new MarkTwainBook("Tom Sawyer")); books.add(new AgathaChristieBook("Hercule Poirot")); System.out.println(books); } public static class MarkTwainBook extends Book { private String author; public MarkTwainBook(String author) { super("Mark Twain"); this.author = author; } @Override public Book getBook() { return this; } @Override public String getTitle() { return author; } } public static class AgathaChristieBook extends Book{ private String author; public AgathaChristieBook(String author) { super("Agatha Christie"); this.author = author; } @Override public Book getBook() { return this; } @Override public String getTitle() { return author; } } abstract static class Book { private String author; public Book(String author) { this.author = author; } public abstract Book getBook(); public abstract String getTitle(); private String getOutputByBookType() { String agathaChristieOutput = author + ": " + getBook().getTitle() + " is a detective"; String markTwainOutput = getBook().getTitle() + " was written by " + author; String output = "output"; //write your code here if (getBook() instanceof AgathaChristieBook) output = agathaChristieOutput; else if (getBook() instanceof MarkTwainBook) output = markTwainOutput; return output; } public String toString() { return getOutputByBookType(); } } }

Comments (10)

Popular
New
Old

You must be signed in to leave a comment

Gellert Varga

Level 23 , Szekesfehervar, Hungary

13 May 2021, 20:38

Yes, the code brings me the desired result as well. But the main problem is that you systematically named "author" everything what we should name "title" everywhere throughout the program. - CodeGym asks you to make a "title" field in the classes, but you made an author field (which is already existing in the Book class) - getTitle() does not return the title field rather the author field...

Guadalupe Gagnon

Level 37 , Tampa, United States

13 May 2021, 13:27

solution

The instructions do not say to create an Author field in the MarkTwainBook and AgathaChristieBook book class. This is why your code is failing. Be sure to remove that filed an update the code to work according to the task directions. Also, the getBook() method in both the MarkTwainBook and AgathaChristieBook classes has the wrong return type.

Gellert Varga

Level 23 , Szekesfehervar, Hungary

13 May 2021, 21:34

I would like to ask about this solution. 1) The System.out.println command on line 16 calls the toString () method inherited from Book on a MarkTwainBook object. = Line 75: public toString method. OK, this method is also existing in the MarkTwainBook object, because it is inherited. But this method (in child class) may call such a method which is existing only in its parent class?? = private getOutputByBookType() method. This is not inherited into the MarkTwainBook class! Because private. But yet the code works...:) How is it possible? 2) My other question is: this program has two private author fields: line 37 and line 54. Still, the JVM knows exactly which of the two authors need to access when calling the markTwainBookObject.toString() / getOutputByBookType() method... (line 65.) But it's not clear to me why.

Guadalupe Gagnon

Level 37 , Tampa, United States

14 May 2021, 00:42

1) the getOutputByBookType() is not inherited by the sub classes, this is true, only code inside the Book class can use this method. It makes only the result of the method available to the subclasses by the public toString() method. This is the OOP concept of encapsulation, which is the hiding important details behind a simple or easy to use interface. 2) In the above code it will output the title of the book as "author". Because ALL the author fields are private, non of them are hiding any of the other ones. This means when code calls the author field it will only be calling the author field from the class the line is on. So in the getOutputByBookType() method, because it is in the Book class, it will only access the Book.author field and not the others. Same with the other classes, if the line using 'author' is in the MTBook class then it will use line 20, and lines in the ACBook class will use the author field on line 37. Now in this code as well, the getOutputByBookType() uses the getTitle() method (which incorrectly returns 'author'). In this case, through polymorphism, it will call the getTitle() of the class that the object is. So when getTitle() is called and the object is a MTBook that will call the method on line 32, which returns author. Since that is in the MTBook class it will return the 'author' field on line 20. Same thing for the ACBook class with the getTitle() returning the 'author' on line 37.

Gellert Varga

Level 23 , Szekesfehervar, Hungary

14 May 2021, 13:15

public class MyClass {

    public static class Animal {
        public int age=20;

        public int getAge() {
            return this.age;
        }
    }

    public static class Pet extends Animal {
    }

    public static class Cat extends Pet {
        public int age = 3;
    }

    public static void main(String args[]) {
        Cat c1 = new Cat();

        System.out.println(c1.getAge()); // == 20
        System.out.println(c1.age); // == 3
    }
}

And why don’t the two age variables (Line4 and line15) conflict in the program below? The Cat class has an age variable inherited from Animal, but it has its own age too. Does c1.age cover the inherited one?

Thomas

Level 41 , Bayreuth, Germany

14 May 2021, 13:34

You can hide fields of the superclass in subclasses. Still you can reference the field of the superclass from the subclass using super like

public static class Cat extends Pet {
    public int age = super.age;
}

Guadalupe Gagnon

Level 37 , Tampa, United States

14 May 2021, 13:43

The variables would be called Animal.age and Cat.age. Because they exist in their own block of code the do not break any Java rules. If you had an 'age' in the Pet class, you wouldn't be able to get the 'Animal.age' directly from the Cat class using 'super', that would get the 'Pet.age' variable, though you can do it by casting to Animal:

Cat{
   int test() {
      return ((Animal)this).age;
   }
}

Your problem is going to be code that uses polymorphism, take this for example:

public static void main(String args[]) {
   Animal c1 = new Cat();

   System.out.println(c1.getAge()); // == 20
   System.out.println(c1.age); // == 20
   System.out.println(((Cat)c1).age); // == 3
}

If your object is a Cat, but you have it stored in a variable of Animal, then the value returned for 'age' is going to be the 'age' that is in the Class that is of the variable type and not the object type. That doesn't seem like a problem in this code, being its a small example, but lets say you have 30+ different classes that extend Animal and they all have their own 'age' variable. If you were to create multiple different kinds of those classes, added them to an ArrayList<Animal>, then wanted to get each of their ages, you would have to do something like this:

for(Animal x : animalList){
   if(x instanceof Cat)
       System.out.println((Cat)x).age);
   if(x instanceof Dog)
       System.out.println((Dog)x).age);
   if(x instanceof Fish)
       System.out.println((Fish)x).age);
   if(x instanceof Cow)
       System.out.println((Cow)x).age);
   if(x instanceof Bird)
       System.out.println((Bird)x).age);
    /// etc
}

A very lengthy process.

Thomas

Level 41 , Bayreuth, Germany

21 May 2021, 10:32

Your first line in the explanation is some sort of pseudo code? The Cat.age and Animal.age part? Cause that would address static variables but not instance ones. So it is just to visualize things I assume? The super keyword reaches that far up in the hierarchy till it finds the first implementation of a method or field. So that's pretty neat and should be sufficient in most cases. So if you have an age in Animal and not in Pet and Cat, then you get that age in Animal using super in either Pet or Cat. Upcasting your reference variable to step over the super limitation (if age is declared eg. in all three classes) is a nice work aroud. But I guess one should rethink the class layout if that is really necessary.

Guadalupe Gagnon

Level 37 , Tampa, United States

21 May 2021, 14:00

Those are stating the names of the variables in the class, not a specific way that you access them. We can't just say "age" when there are multiple variables with the same name in different locations, so Cat.age means the "age" variable that is in the Cat class and Animal.age is the "age" variable in the Animal class.

Thomas

Level 41 , Bayreuth, Germany

21 May 2021, 19:28

Ahh, OK, I see. I already was afraid I missed something :)