Variable-length argument lists can be used to create methods that receive an unspecified number of arguments.

In this statement, public static double mchee (double...num), it means that variable number of double (data type) values can be passed to this method.

The condition that parameter type followed by an ellipsis can occur a few times at the end of a parameter list.

Parameter type followed by an ellipsis indicates that the method receives a variable number of arguments of that particular type.

Ellipsis is represented by this syntax (...) in Java programming.

If the code does not include an explicit call to the superclass constructor, Java will not call the superclass's default or no-argument constructor.

A class's default constructor calls the superclass's default or no-argument constructor.

In general, constructors are not inherited.

The first task of a subclass constructor is to call its direct superclass's constructor explicitly or implicitly.

Superclass constructor call syntax is the keyword super, followed by a set of parentheses containing the superclass constructor arguments.

Each subclass constructor must implicitly or explicitly call its superclass constructor to initialize the instance variables inherited from the superclass.

In the stack trace during Exception Handling, information is displayed when an exception takes place but is not handled.

Exceptions are thrown when a method detects a problem and is unable to handle it.

In the stack trace during Exception Handling, information includes the method-call stack (i.e. call chain) at the time it occurred.

During Exception Handling, Java does not allow division by zero with floating-point values.

The information of the stack trace during Exception Handling includes the name of the exception in a descriptive message that indicates the problem that occurred.

During Exception Handling, Java does not allow division by zero in integer arithmetic.

Division by zero

Arithmetic overflow

Thread interruption

Out of range array indices

Unsuccessful memory allocation

Disk I/O completion problems

Invalid method parameters

Try block encloses the code that might throw an exception.

Try block consists of the keyword try followed by a block of code enclosed in curly braces.

Catch block begins with the keyword catch followed by an exception parameter in parentheses and a block of code enclosed in curly braces.

The method's name enables the catch block to interact with a caught exception object.

At least one catch block must immediately follow the try block.

Try block encloses the code that should not execute if an exception occurs.

Interfaces offer a capability requiring that unrelated classes implement a set of common methods.

Interfaces define and standardize the ways in which things such as people and systems can interact with one another.

An interface in Java describes a set of methods that can be called on an object.

An interface declaration begins with the keyword interface and contains only instance variables and protected methods.

All interface members must be public.

Interfaces may not specify any implementation details, such as concrete method declarations and instance variables.

Methods that are declared private are implicitly final because it is impossible to override them in a subclass.

Methods that are declared private are implicitly static because it is impossible to override them in a subclass.

Calls to the final methods are resolved at the compilation time, and hence this is known as the static binding.

Since a class can extend a final class, a final class can itself be a superclass.

A final method in a superclass cannot be overridden in a subclass.

A final method's declaration can never change and so, all subclasses use the same method implementation.

Assigning a subclass reference to a subclass variable is pretty straightforward.

Assigning a superclass reference to a superclass variable is pretty straightforward.

Assigning a subclass reference to a superclass variable is safe.

Java compiler will report errors if the code refers to subclass only members through the superclass variable. 

In the allowed assignments between superclass and subclass variables, the subclass object is an object of its superclass.

The superclass variable can be used to refer only to subclass members.