In Java, data structures that can hold zero or more elements are known as _collections_. An **array** is a collection that has a fixed size/length and whose elements must all be of the same type. Elements can be assigned to an array or retrieved from it using an index. Java arrays are zero-based, meaning that the first element's index is always zero:

Booleans in Java are represented by the `boolean` type, which values can be either `true` or `false`.

Java supports three boolean operators: `!` (NOT), `&&` (AND), and `||` (OR).

The Java `char` type represents the smallest addressable components of text.

Multiple `char`s can comprise a string such as `"word"` or `char`s can be

processed independently. Their literals have single quotes e.g. `'A'`.

The primary object-oriented construct in Java is the _class_, which is a combination of data (_fields_) and behavior (_methods_). The fields and methods of a class are known as its _members_.

Access to members can be controlled through access modifiers, the two most common ones being:

Java supports the three logical operators `&&` (AND), `||` (OR), and `!` (NOT).

Creating an instance of a _class_ is done by calling its _constructor_ through the `new` operator. A constructor is a special type of method whose goal is to initialize a newly created instance. Constructors look like regular methods, but without a return type and with a name that matches the classes' name.

Inheritance is a core concept in OOP (Object Oriented Programming). It donates IS-A relationship.

It literally means in programming as it means in english, inheriting features from parent(in programming features is normally functions

and variables).

An interface is a type containing members defining a group of related functionality. It distances the uses of a class from the implementation allowing multiple different implementations or support for some generic behavior such as formatting, comparison or conversion.

The syntax of an interface is similar to that of a class except that methods appear as the signature only and no body is provided.

There are two different types of numbers in Java:

- Integers: numbers with no digits behind the decimal separator (whole numbers). Examples are `-6`, `0`, `1`, `25`, `976` and `-500000`.