OCP - 3

Yes, the return type is of type Object

Catch the EOFException!

NO! Use the specific strategies for each kind of stream

• Java calls the first non-arg constructor for the first nonserializable parent class, skipping the constructors of all serialized classes in between!
• Static variables are ignored
• default intializers (eg private String myField = "123" and {}) are ignored

They offer a high-level interface to write formatted representation of Java objects to a text-based outputs stream

The System.err and Sytstem.out fields

They do not throw an exception! The checkError() method can be used for that instead

It depends on the os. You can access the value using System.getProperty("line.separator")

They are identical, printf calls format behind the scenes

It is convenience for the Readers/Writers System.in, System.out and System.err

It is a Singleton that is accessed using the System.console() method

• reader()
• writer()
• format() / printf()
  • Locale override is not supported! Use writer.format instead!
• flush()
• readLine()
• readPassword()

Before using readLine and readPassword to ensure only user input is read

If a string were returned, the passwourd might be available in the String pool long after the user entered it. By using a byte array, the password can be wiped as soon as it is not required anymore using Arrays.fill(passwordArray, 'x')

Yes

One single abstract method: void run();

1. Configure the Tread class by either passing a Runnable Object in the Thread constructor or by extending the Thread class and overriding the run method
2. Calling the start Method on the Thread instance

Never make assumptions on the order of execution of Threads and tasks. This is the responsibility of the operating system and you cannot assume anything!

Almost always the Runnable class. THread might be useful for complex rules upon which multiple tasks rely.

The runnable class is preferable becauase of single inheritance and the use of the Concurrency API

While waiting for the result of another thread, it might be necessary to poll for the Results of the other Thread. Using just a while loop is not only wasted energy but also a potential infinite loop. By using Thread.sleep, the current thread is paused for the defined amount of time, allowing other threads to do their work.

It declares the checked InterruptedException which must be handeled

It simplifies the execution of concurrent tasks by abstracting common error-prone operations

It is important to call the shutdown() method. A thread executor creates a non-demon thread on the first task that is executed, so failing to call shutdown will result in you application never terminating.

All Tasks that are queued are executed in the order in which they were added to the executor service

• After construction, an ExecutorService is active, meaning it accepts new tasks and executes tasks.
• After calling shutdown(), an ExecutorService is shutting down, meaning it rejects new tasks and executes tasks.
• After all Tasks are finished,  an ExecutorService is terminated, meaning it rejects new tasks and no tasks are running

• It attempts to stop all running tasks (NO Guarantees)
  • Typical implementations will cancel via Thread.interrupt(), so any task that fails to respond to interrupts may never terminate.
• This method does not wait for actively executing tasks to terminate. Use awaitTermination to do that.
• No new tasks are started and all queued, unexecuted Tasks are returned

• Future<?> submit(Runnable task)
• <T> Future<T> submit(Callable<T> task)
• <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException
• <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException

• execute is fire and forget - has no return type. It accepts a Runnable Instance, meaning that the implementation cannot throw a checked exception
• submit returns a Future to access it's result. It accepts a Calleable Instance, meaning that the implementation can throw a checked exception

• It executes the given task synchronously!
  •  Future.isDone() is true for each element of the returned list.
• The result is a list of all task results as a Collection of futures
  • Same order as the original collection