Static Threads??

Question about the task

Clew

Java Core, Level 6, Lesson 13

Resolved

Am I on the right track? Do you have to make the Threads static if you put them in a static block. Thanks in advance.

1. Create 5 different threads that differ from Thread:
1.1. Thread 1 must run indefinitely;
1.2. Thread 2 should display "InterruptedException" when an InterruptedException occurs;
1.3. Thread 3 should display "Hurray" every half second";
1.4. Thread 4 must implement the Message interface. When the showWarning method is called, the thread should stop;
1.5. Thread 5 should read numbers from the console until "N" is entered. Then it should display the sum of the entered numbers.
2. In a static block, add your threads to List<Thread> threads in the specified order.
3. The threads should not start automatically.

Hint:
Thread 4 can be checked using isAlive()

Requirements:

The Solution class's static block must create 5 threads and add them to the threads list.
The threads in the threads list should not start automatically.
Thread 1 in the threads list must run infinitely.
Thread 2 in the threads list should display "InterruptedException" when an InterruptedException occurs.
Thread 3 in the threads list should display "Hurray" every half second.
Thread 4 in the threads list must implement the Message interface. When the showWarning method is called, the thread should stop.
Thread 5 in the threads list should read numbers from the console until "N" is entered. Then it should display the sum of the entered numbers.

package com.codegym.task.task16.task1632; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.ArrayList; import java.util.List; public class Solution { public static List<Thread> threads = new ArrayList<>(5); static { threads.add(new Thread1()); threads.add(new Thread2()); threads.add(new Thread3()); threads.add(new Thread4()); threads.add(new Thread5()); } public static void main(String[] args) { } public static class Thread1 extends Thread { public void run() { } } public static class Thread2 extends Thread { public void run() { } } public static class Thread3 extends Thread { public void run() { try { Thread3.sleep(500); System.out.println("Hurray"); } catch (Exception e) { e.printStackTrace(); } } } public static class Thread4 extends Thread implements Message{ public void showWarning() { while (true) { if (!this.isAlive()) { this.interrupt(); } } } public void run() { } } public static class Thread5 extends Thread { public void run() { } } }

Comments (2)

Popular
New
Old

You must be signed in to leave a comment

Guadalupe Gagnon

Level 37 , Tampa, United States

2 September 2021, 15:38

useful

Line 10: The 'threads' list is static in this code, which means it belongs to the class as a whole and not to any individual object. Because of this, you can use it in any static block (including a static method). Now the actual Thread# classes: When a class is contained within another class, such as the Thread# custom classes in this code they must be static to be independent from the containing class. If they were not static then they would be fully connected to the containing class and an object could not be made without an object of the containing class. So:

class Solution {
   class InnerClass{ }

   public static void main(String[] args) {
      Solution x = new Solution();
      InnerClass x1 = x.new InnerClass();
   }
}

To create an InnerClass in this code you MUST have an object of Solution to do so. You can see that on line 6 where it uses 'x' to create the new InnerClass object. This give the created object access to all the fields/methods of the object it was made from regardless of their access level. An example of this in actual code that you have probably used already without realizing it would be the Iterator class, which can be created from an object that implements the Iterable<> interface. Now if I change the code to make InnerClass static then a created object of InnerClass can exist independently without the requirement of an object of the outer class:

class Solution {
   static class InnerClass{ }

   public static void main(String[] args) {
      InnerClass x1 = new InnerClass();
   }
}

Now it is independent from the outer class (Solution) and can be created by itself. It can still access members of the outer class, but if they are not static then it needs an object to do so.

Guadalupe Gagnon

Level 37 , Tampa, United States

2 September 2021, 15:42

useful

Here is an example:

class Solution {
    private String name = "huzzah";

    static class InnerClass {
        public void printName(Solution x) {
            System.out.println(x.name);
        }
    }

    public static void main(String[] args) {
        Solution x = new Solution();
        InnerClass x1 = new InnerClass();
        x1.printName(x);

    }
}

class OutsideClass {
    public void printName(Solution x) {
        System.out.println(x.name); //!! ERROR
    }
}

In this code the InnerClass object can print "name", a private field, from a Solution object, However the same exact code in the OutsideClass shows an error when trying to access "name" from a Solution object because it can't access the private fields like a non-static class within the Solution class can. It allows a lot of design options when using OOP principals to encapsulate data and control access to that data.