The syntax of the java. Conditional constructions. - Default methods for interface

must necessarily match the name of the class whose main () method is called when the Java machine starts up.

Object - the class from which to inherit all objects in Java, including arrays and strings ().

Access specifiers are individual for each member (specified before the declaration).

All class members are by default open to scope package... The default scope is a cross between private and protected, see.

Each * .java file can contain only one class declared as public and accessible from the outside.

The definition and declaration of a class is always in one file, it is impossible to put prototypes in headers.

Pointers are missing.

All class variables are actually references to objects, not the objects themselves. Their initialization for use must be done through new<конструктор-класса>(...) .

Based previous paragraph- when assigning one object variable to another, only the reference is changed but not the object copy.

Variables in a function are passed by value if it is elementary types(int, byte, long, etc ...), or by reference if they are objects.

The public static members of a class are accessed through the dot operator. , and not through ::, which in my opinion introduces some external confusion.

There is no destructor, but there is finalize ().

Finalize () should not be confused with the C ++ destructor. finalize () is called garbage collection only, which has nothing to do with the object going out of scope and the absence of at least one reference to this object.

You can force garbage collection by calling the Runtime.gc () method on the current Runtime object or the static System.gc () method. Judging by the experiments carried out, freeing memory only works within virtual machine Java and once allocated memory in the OS does not return until the machine ends.

In Java-style coding, functions throw exceptions instead of returning code. systemic errors or errors in the logic of the virtual machine. Therefore, a lot of functions must be executed inside the try (...) catch (...) (...) block that handles the exception, or the method that calls them must explicitly indicate through throws the list of exceptions thrown by these functions that are not handled by them, for processing by their methods up the call stack.

Exceptions are divided into and.

The try (...) block can also end with a finally (...) block, which is executed regardless of the presence / absence of exceptions in the previous try (...) block. It is convenient to use this to perform any required actions regardless of the results of executing a block of code, for example, to automatically release all resources allocated in it.

char is not a single-byte type like with C / C ++, it is a 16-bit type that supports unicode strings.

bool is known as boolean in Java.

Conditional constructs accept only boolean type of variables or expressions. This means that the code is like:
int a; ... actions on the variable a ...; if (a) (...)
Not true from the point of view Java syntax and will not compile.

Constants are declared final and not const.

All arrays are objects.

Even string constants (like "any string const") are objects.

For strings (the String class), only one operator is defined - +, concatenation.

Comparison of strings is done through the bool equals () method of the String class, for example s1.equals (s2).

The content of String objects is constant and does not imply changing a single element of the string, this is done for performance reasons. If you need such operations, you can use the StringBuffer class.

When concatenating an uninitialized string with a non-empty string, you get null + non-empty-string, for example s + = "| string"; will be equal to "null | string"

Arrays have a public member variable length, strings don't have instead, they use the length () method.

Java do not support multiple inheritance. Some of its functions are performed through "interfaces". Interfaces support multiple "inheritance" implementations of multiple interfaces in a single class, and in general many (interfaces) to many (classes) relationships and vice versa.

Interfaces allow the creation of links through which you can refer to objects of classes that implement these interfaces. True, the dynamic search for a suitable method when accessing through the reference-interface requires a lot of overhead, therefore it is not desirable.

Instead of enums, you can use interfaces without method declarations in them. In this case, all interface variables must be initialized when the interface is defined and their values will automatically be constant. After that, through implements they can be "connected" to the defined class.

Also, since JDK 5 there are externally classic enumerations - enum. In fact, this is not just a list of named constants, but a special class inherited from the superclass Enum. Each element of the enumeration is an object of this class. The numeric value of an enumeration object can be obtained with the ordinal built-in function.

Custom operator overloading familiar in C ++, in Java not supported.

To work in an object environment with "primitive types" (int, float, char, etc ...), Java uses autoboxing / autoboxing into wrapper types (Integer, Float, Character, etc ...). In fact, this is an implementation of operator overloading for several built-in classes that implement the functionality of primitive types + object methods.

super - a keyword that allows you to call the constructor of a superclass from a subclass, or refer to a member of the superclass of a hidden member of the subclass.

When used as a constructor - super should always be first operator in the constructor of the subclass.

For determining abstract methods, the abstract keyword is used, a class containing an abstract method must also be defined as an abstract class ....

final prohibits overriding methods in child classes. For "short" methods declared as final, this keyword has the same effect as inline in C ++ - in subclasses instead of calling a function. may be inserted superclass method bytecode into calling class method code.

final also prohibits inheriting from a class declared as final.

Namespaces(namespace) in Java are implemented as packages(package).

To connect packages use import, you can also use import static ..(*|) to import static members of the class.

Java supports threads through the built-in Thread class and the Runable interface. For synchronization, use the synchronized specifier before the method in the class description, or synchronized (

The syntax of the java. Conditional constructions. - Default methods for interface

- Default methods for interface

Here are the basic syntax rules

Increment and decrement operators

Incrementing and decrementing

Object Oriented Programming Concepts and Principles