Where are Cat class and Kitten class getting their (super)name from? Thread class?

Question about the task

Resolved

1. Figure out what the program does.
2. Arrange the calls to join() so that each cat does the following:
2.1. First, the cat gives birth to kittens.
2.2. Then all the kittens climb out of the basket in random order.
2.3. Finally, the cat brings them back into the basket.
2.4. These events for one cat may be interspersed with events for another cat.
2.5. Add kitten nap-time (sleep 200 ms) to investigateWorld.

Requirements:

The join method should be called on each kitten (Kitten object).
The investigateWorld method should let the kitten sleep for 200 ms. Use Thread.sleep(200).
The program should create two cats and four kittens.
Don't change the methods that are responsible for screen output.
The program's output must indicate that the task conditions have been satisfied.

package com.codegym.task.task16.task1610; /* Arranging calls to join() */ public class Solution { public static void main(String[] args) throws InterruptedException { Cat cat1 = new Cat("Missy"); Cat cat2 = new Cat("Coco"); } private static void investigateWorld() { try { Thread.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); } } public static class Cat extends Thread { protected Kitten kitten1; protected Kitten kitten2; public Cat(String name) { super(name); kitten1 = new Kitten("Kitten 1 (mother - " + getName() + ")"); kitten2 = new Kitten("Kitten 2 (mother - " + getName() + ")"); start(); } public void run() { System.out.println(getName() + " gave birth to 2 kittens"); try { initAllKittens(); } catch (InterruptedException e) { } System.out.println(getName() + ": All the kittens are in the basket. " + getName() + " brought them back"); } private void initAllKittens() throws InterruptedException { kitten1.start(); kitten2.start(); } } public static class Kitten extends Thread { public Kitten(String name) { super(name); } public void run() { System.out.println(getName() + " got out of the basket"); investigateWorld(); } } }

Comments (5)

Popular
New
Old

You must be signed in to leave a comment

Nouser

Level 36 , Germany

11 December 2020, 16:33

solution

Kitten and Cat extend Thread. Thread, as you know has a constructor Thread(String name). That'll set the threads name (similar to a call of setName(name)). So if you have a Kitten that extends Thread, you can call the super class constructor inside the child class constructor like it is done here

public static class Kitten extends Thread {
    public Kitten(String name) {
        super(name);
    }

you create a new Kitten object new Kitten("Mimi"); Then the super class (Thread) constructor is called using "Mimi" as parameter inside of the Kitten constructor. The Thread class initializes the name variable with Mimi. Now you can grab the threads name using Thread.currentThread.getName(); (when the thread is executed, most probably inside of the run method) or, if you have a thread object Kitten myKitty = new Kitten("Mimi"); String threadName = myKitty.getName();

Andrei

Level 41

14 December 2020, 07:27

Thank you! So this constructor also has a getter?

Nouser

Level 36 , Germany

14 December 2020, 10:23

useful

Have a look at that code

public class A {

    protected int importantState;

    public A (int importantState) {
        this.importantState = importantState;
    }

    public void importantMethod() {
        //calculate something using importantState;
    }

    public static class B extends A {
        private int additionalImportantState;

        public B(int importantState, int additionalImportantState) {
            super(importantState);
            this.additionalImportantState = additionalImportantState;
        }

        public void additionalMethod() {
            importantMethod();
            //do more important stuff using additionalImportantState
        }
    }

    public static void main(String[] args) {
        A a = new A(1);
        a.importantMethod();

        B b = new B(2, 3);
        System.out.printf("%s saved in parent - %s saved in child", b.importantState, b.additionalImportantState);
        b.importantMethod();
        b.additionalMethod();
    }
}

We have two classes. A base class A and a class B that inherits from A. That's usually done cause we do not want to repeat/ rewrite code that already exists and is useful for us. Now imagine we have a class that nearly does everything we want. It needs just some finetuning, So we write another class and inherit from the first, B extends A. Now let us first have a look what happens if we just instanciate an A object. A asks for a value inside of the constructor. We have written an own constructor, so the default one is gone. We'd need to readd it if we'd need it. So we have to eg. write

A a = new A(10);

to create an A object. 10 is saved in a field and we can call a method importantMethod. On top of this we place now out child, somehow like in the first floor. importantState and importantMethod are in the basement.

Nouser

Level 36 , Germany

14 December 2020, 10:40

useful

In the first floor you have a new field and you now create an object of the child class. In the end that means, you need to give a value to the child class' field and a value to the base class' importantState field. That one is still in the basement and you have to access it there. Usually that is done using the constructor. In the child class you have two fields to initialize so you gave it to values. The one value for the child class additionalImportantState is no problem, you initialize that in the first floor, inside of the child class.

this.additionalImportantState = additionalImportantState;

But before you do that, you need to initialize the base class' field importantState. That one still is in the basement and you need to store the value there. There are several ways to do that, accessing it directly (if that's allowed), using a setter or, as here, the constructor of the base class. However here you have no choice. You have to use the constructor. A constructor is called everytime a class gets instanciated. And that's the same for base classes. First the constructor of the child class gets called and the first thing that's done inside the child constructor is, calling the base class constructor (invisible for us, and it is the default constructor). Here we do not have a default constructor anymore so it has to be the constructor with an int parameter. And now we can make use of super. It allows us to overwrite to invisible call to the base class constructor and call a differnt one. The super call needs to be the first thing we have to do again (see above, first thing is always to call the base constructor). The rest should be self explaining.

Andrei

Level 41

14 December 2020, 14:00

Awesome, thank you! 👏