Paul Anilprem

Congratulations, Andy! Thank you for sharing your experience.
Glad to know that our material was helpful in your preparation

Rob Spoor wrote:Lambdas can not just replace anonymous inner classes, they can also replace the need for template methods. Instead of creating an abstract base class that has abstract methods that need to be overridden, you can provide lambdas to provide that functionality.

A quick example from some code I've written some time ago; this class has a getter (String -> String), setter ((String, String) -> String) and a remover (String -> ()). Slightly simplified:
public final class Values {    private static final Values SYSTEM = new Values(System::getProperty, System::setProperty, System::clearProperty);    private final Function<? super String, String> getter;    private final BiConsumer<? super String, ? super String> setter;    private final Consumer<? super String> remover;    public Values(Map<String, String> map) {        getter = map::get;        setter = map::put;        remover = map::remove;    }    public Values(Function<? super String, String> getter, BiConsumer<? super String, ? super String> setter, Consumer<? super String> remover) {        this.getter = getter;        this.setter = setter;        this.remover = remover;    }    public static Values system() {        return SYSTEM;    } }
Before Java 8, I had to make this class abstract, and provide (anonymous) implementations for using a Map or System properties as a backing mechanism:
public abstract class Values {    private static final Values SYSTEM = new Values() {        protected String get(String key) {            return System.getProperty(key);        }        protected void set(String key, String value) {            System.setProperty(key, value);        }        protected void remove(String key) {            System.clearProperty(key);        }    };    protected abstract String get(String key);    protected abstract void set(String key, String value);    protected abstract void remove(String key);    public static Values fromMap(final Map<String, String> map) {        return new Values() {            protected String get(String key) {                return map.get(key);            }            protected void set(String key, String value) {                map.put(key, value);            }            protected void remove(String key) {                map.remove(key);            }        };    }    public static Values system() {        return SYSTEM;    } }

This example does seem to save you quite a bit of code but I am not sure if this is a good approach from a design perspective. You now have one class that does one thing in two different ways. I think there is an anti-pattern lurking in there somewhere Abstract class and two concrete classes looks better to me. Having an interface would probably be even better. Any thoughts?

Congratulations, Tiberius!

Congrtulations, Bangun! Thanks for sharing your experience

Congratulations! Great scores!!

Congratulations, Philippe!

When a subclass has a method with the same signature as a method in its superclass, it is called an "override". Overriding is very different from overloading. If you are following a book, you may want to go through the chapter that talks about overriding and then this question will be easy for you to understand.

Thanks for the information, Michael. I was intrigued by your response and so I checked out their website. They indeed do not mention the cost of the training upfront. On one page they say, "Since 2001 we've trained exactly 68.075 students and asked them all to review our Accelerated Learning.".  Very interesting

Congratulations, Nisim! Great score.
BTW, our mock exams also cost only $10 (for desktop OR web access). They cost $15 only if you buy desktop license as well as web access.

Wow, great score!
Congratulations!!
How much did the training cost if you don't mind me asking?

Congratulations, Nick! Thank you for sharing your experience. It is very inspirational.

-Paul.

Congratulations! Great score!!
Glad to know our material was helpful in your preparation

Congratulations, Malik! Great score!!

Congratulations, Rich!
Glad to know our s/w was helpful in your preparation

JDK (Java Development Kit) is a name given to a set of tools that are used to compile java code (i.e. .java files) and run the generated .class files. As you probably know, compilation is done using the program named javac (aka the java compiler) and execution is done using the program named java. Besides these two, there are tons of other tools such as a debugger, javadoc generator, and jarsigner (take a look at C:\Program Files\Java\jdk1.8.0_121\bin directory to see what all it contains). All these things make up the "JDK". It can exist anywhere, but usually, when you install the JDK on windows, these programs and their supporting libraries reside in C:\Program Files\Java\jdk1.8.0_121\.

JRE (Java Runtime Environment) comprises a subset of the tools that come with JDK. JRE contains only those programs (and supporting libraries) that are required to run java code. JDK usually includes a JRE ( see the constituents of C:\Program Files\Java\jdk1.8.0_121\jre folder). You should notice that it doesn't contain javac.

When you say JDK and JRE physically exist, that is what you probably mean. They exist in the form of files on your system.

JVM does not physically exist because, unlike your computer, which exists in the form of a physical box with motherboard and chips, the JVM exists in memory. The java.exe program that you run when you try to "execute" your java class implements a "virtual" computer aka the "virtual machine". You can also think of a JVM as a CPU simulator. You pass your java class file as an argument to this VM so that it can execute the instructions contained in your java class file.