An object is a software bundle of related state and behavior. Software objects are often used to model the real-world objects that you find in everyday life. 

A class is a blueprint or prototype from which objects are created. 

Inheritance provides a powerful and natural mechanism for organizing and structuring your software. A class which extends another class is a subclass of the class it extends, which is called the superclass. A subclass inherits all of the methods and fields of the superclass, as well as adding more of it's own.

An interface is a contract between a class and the outside world. When a class implements an interface, it promises to provide the behavior published by that interface. 

A package is a namespace for organizing  a set of related classes and interfaces in a logical manner.

The source code for an object can be written and maintained independently of the source code for other objects. Once created, an object can be easily passed around inside the system.

By interacting only with an object's methods, the details of its internal implementation remain hidden from the outside world.

If an object already exists (perhaps written by another software developer), you can use that object in your program. This allows specialists to implement/test/debug complex, task-specific objects, which you can then trust to run in your own code.

If a particular object turns out to be problematic, you can simply remove it from your application and plug in a different object as its replacement. This is analogous to fixing mechanical problems in the real world. If a bolt breaks, you replace it, not the entire machine.

At the beginning of the class definition, use the extends keyword immediately after the class name, followed by the name of the class to inherit from, e.g.:

class MySubbie extends MySuper {

// field declarations

// method declarations and definitions

}

An Interface is a class which is defined with a group of related methods with empty bodies, using the keyword interface for the declaration. 

Another class can then be defined using the keyword implements and within this new class the methods identified in the interface class would then be defined. 

Furthermore, these implemented interface methods must be declared as public in the implementing method.

Instance variables are fields whose value is unique to each instance of a class (to each object, in other words). They are also known as non-static fields because they are declared without the static keyword.

A Class is a blueprint for the an Object. An Object is an instance of a Class.

A class variable is any field declared with the static modifier; this tells the compiler that there is exactly one copy of this variable in existence, regardless of how many times the class has been instantiated. Class Variables are also known as Static Fields.

A Local Variable is a variable which is declared and used within a single Method. There is no keyword for designating a variable as local.

A Parameter is a variable which is defined within the parenthesis of a method declaration. A Parameter can also be called an argument. It is not considered a field.

Variable names can begin with any letter, a dollar sign or an underscore. 

By convention a variable name should only begin with a letter.

• A variable name should only begin with a letter.
• A variable name should contain full words, not abbreviations.
• A variable name should describe the variable's utility.
• For non-constants, use all lower case letters for variable names with the exception of the first letter of the second and any subsequent words, which should be upper case.
• For constants, use all upper case letters throughout and separate words with an underscore.

boolean 

byte 

char 

double 

float 

int 

long 

short 

A signed two's complement integer is a whole number value data type which contains positive and negative values. The range of values is determined by the maximum value of a binary number that is one bit smaller. The first bit of a signed two's complement integer identifies whether the value is positive or negative. In the Java programming language, the maximum negative value of a signed two's complement integer is one greater than the maximum positive value.

-2³¹ to 2³¹ - 1

or

-2,147,483,648 to 2,147,483,647

-2⁶³ to 2⁶³ - 1

or

9,223,372,036,854,775,808 to 9,223,372,036,854,775,807

OR 

negative 9 quintillion, 223 quadrillion, 372 trillion, 36 billion, 854 million, 775 thousand and 808 to 9 quintillion, 223 quadrillion, 372 trillion, 36 billion, 854 million, 775 thousand and 807

An integer literal is of type long if it ends with the letter L or l; otherwise it is of type int. It is recommended that you use the upper case letter L because the lower case letter l is hard to distinguish from the digit 1.

• Decimal (base 10) (most common)
• Hexidecimal (base 16)
• Binary (base 2)

Both of the floating point types (float and double) can also be expressed using E or e (for scientific notation). 

By way of example here is the same value being assigned to a double:

double d1 = 123.4;

double d2 = 1.234e2;

Yes, underscore characters can be employed when assigning a numeric literal in order to improve the readability of the assignment. Underscore characters can be thought of as the commas used to differentiate between thousands and millions, for example, but unlike those commas, an underscore character can be placed ALMOST anywhere within the number being assigned as a literal. You can place underscores only between digits; you cannot place underscores in the following places:

• At the beginning or end of a number
• Adjacent to a decimal point in a floating point literal
• Prior to an F or L suffix
• In positions where a string of digits is expected

An array can legally be declared in the following ways:

//example 1

int[] myIntegerArray;

//example 2

int myIntegerArray[];

Although both will compile, the convention is to place the brackets immediately after the type (example 1)

One way to create an array is with the new operator, followed by the array type and a number in brackets which determines the array size. E.g:

myIntegerArray = new int[10];

Alternatively an array can be created using a shortcut syntax which consists of the variable type, followed by empty brackets, followed by the variable name, followed by an equal sign, followed by a comma delimited list of valid values enclosed within curly brackets. E.g.:

int[] myIntegerArray = { 100, 200, 300, 400 };

What is the command to determine the size of an array and what is the syntax for using it?

Use the built-in length property to determine the size of any array. E.g.:

System.out.println(myIntegerArray.length);

The System class has an arraycopy() method that you can use to efficiently copy data from one array into another:

public static void arraycopy(Object src, int srcPos,

                           Object dest, int destPos, int length)

The two Object arguments specify the array to copy from and the array to copy to. The three int arguments specify the starting position in the source array, the starting position in the destination array, and the number of array elements to copy.