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

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

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.

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

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

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

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

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

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.

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

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

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

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 with floating-point values.

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

Arithmetic overflow

Unsuccessful memory allocation

Out of range array indices

Division by zero

Invalid method parameters

Thread interruption

Disk I/O completion problems

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

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

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

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

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

Try block encloses the code that might throw an exception.

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

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

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

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

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

All interface members must be public.

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

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

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

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.

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

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

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

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

Assigning a subclass reference to a superclass variable is safe.

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