JSP page syntax. Conditional constructs

Programming is writing the source code of a program in one of the programming languages. There are many different languages programming, thanks to which all kinds of programs are created that solve a certain range of problems. A programming language is a set of reserved words used to write the source code of a program. Computer systems are unable (yet) to understand human language, and even more so, human logic (especially feminine), so all programs are written in programming languages, which are subsequently translated into computer language or machine code. Systems that translate the source code of a program into machine code are very complex and, as a rule, they are created by more than a dozen months and more than a dozen programmers. Such systems are called integrated programming environments or tools.

A programming system is a huge thoughtful visual environment where you can write the source code of the program, translate it into machine code, test, debug, and much more. Additionally, there are programs that allow you to perform the above actions using command line.

You have probably heard the term "a program is written under Windows or under Linux, Unix" more than once. The fact is that programming environments for translating a programming language into machine code can be of two types: compilers and interpreters. Compiling or interpreting a program determines how the program will continue to run on the device. Programs written in the Java language always work on the basis of interpretation, while programs written in C / C ++ - compilation. What is the difference between these two methods?

The compiler, after writing the source code at the time of compilation, immediately reads the entire source code of the program and translates it into machine code. After which the program exists as a whole and can only be executed in that operating system in which it was written. Therefore, programs written under Windows cannot function under Linux and vice versa. The interpreter will step through or line by line execution of the program each time it is executed. During the interpretation, not executable code is generated, but virtual code, which is subsequently executed by the Java virtual machine. Therefore, on any platform - Windows or Linux, Java programs can be executed in the same way if there is a virtual Java machine in the system, which is also called the Runtime System.

Object Oriented Programming

Object-oriented programming is based on objects, which is somewhat similar to our world. If you look around you, then you can definitely find something that will help you more clearly understand the model of such programming. For example, I am now sitting at a table and typing this chapter on a computer that consists of a monitor, system unit, keyboard, mouse, speakers, and so on. All of these parts are the objects that make up the computer. Knowing this, it is very easy to formulate some kind of generalized model for the operation of the entire computer. If you do not understand the intricacies of the software and hardware properties of a computer, then we can say that the System unit object performs certain actions that are shown by the Monitor object. In turn, the Keyboard object can correct or even specify actions for the System unit object that affect the operation of the Monitor object. The presented process characterizes very well the entire object-oriented programming system.

Imagine some powerful software containing hundreds of thousands of lines of code. The entire program is executed line by line, line by line, and in principle, each of the subsequent lines of code will necessarily be linked to the previous line of code. If you do not use object-oriented programming, and when you need to change this program code, say, if you need to improve some elements, you will have to do a lot of work with all the source code of this program.

Object-oriented programming is much simpler, let's go back to the example of a computer system. Let's say you are no longer satisfied with a seventeen-inch monitor. You can safely exchange it for a twenty-inch monitor, of course, if you have certain material resources. The exchange process itself will not entail huge problems, except that the driver will have to be changed, and the dust from under the old monitor should be wiped off and that's it. Object-oriented programming is based on approximately this principle of operation, where a certain part of the code can represent a class of homogeneous objects that can be easily modernized or replaced.

Object-oriented programming very easily and clearly reflects the essence of the problem being solved and, most importantly, makes it possible, without prejudice to the entire program, to remove unnecessary objects by replacing these objects with newer ones. Accordingly, the overall readability of the entire program source code becomes much easier. It is also important that the same code can be used in completely different programs.

Classes

At the core of all Java programs are the classes on which object-oriented programming is based. In fact, you already know what classes are, but you don't know about it yet. In the previous section, we talked about objects, taking as an example the structure of an entire computer. Each object from which a computer is assembled is a representative of its own class. For example, the Monitors class unites all monitors, regardless of their types, sizes and capabilities, and one specific monitor standing on your table is an object of the monitors class.

This approach makes it very easy to simulate all sorts of processes in programming, making it easier to solve the assigned tasks. For example, there are four objects of four different classes: monitor, system unit, keyboard, and speakers. To play a sound file, use the keyboard to give the command system unit, you will observe the very action of giving the command visually on the monitor and, as a result, the speakers will play the sound file. That is, any object is part of a certain class and contains all the means and capabilities of this class. There can be as many objects of the same class as needed to solve the problem.

Methods

When the playback example was given sound file, then it was mentioned about giving a command or a message, on the basis of which certain actions were carried out. The task of performing actions is solved using the methods that each object has. Methods are a set of commands with which you can perform certain actions with an object.

Each object has its own purpose and is designed to solve a certain range of problems using methods. For example, what good would the Keyboard object be if you could not press keys and still be able to issue commands? The Keyboard object has a certain number of keys with which the user gains control over the input device and can issue the necessary commands. Processing of such commands occurs using methods.

For example, you press the Esc key to cancel any action and thereby give a command to the method assigned to this key, which at the program level solves this problem. The question immediately arises about the number of methods of the Keyboard object, but there can be a different implementation here - from defining methods for each of the keys (which, in general, is unreasonable), to creating one method that will monitor the general state of the keyboard. That is, this method monitors whether a key was pressed, and then, depending on which of the keys is involved, decides what to do.

So, we see that each of the objects can have at its disposal a set of methods for solving various problems. And since each object is an object of a certain class, it turns out that the class contains a set of methods that are used by various objects of the same class. In Java, all methods you create must be owned or part of a particular class.

Syntax and semantics Java language

In order to speak and read any foreign language, it is necessary to learn the alphabet and grammar of that language. A similar condition is observed in the study of programming languages, with the only difference, it seems to me, that this process is somewhat easier. But before you start writing the source code of the program, you must first solve the problem posed to you in any form convenient for you.

Let's create a certain class that is responsible, for example, for a phone, which will have only two methods: turning this phone on and off. Since we do not know the syntax of the Java language now, we will write the Phone class in an abstract language.

Class Phone
{
Include () method
{
// operations to turn on the phone
}
Disable () method
{
// operations to turn off the phone
}
}

The Phone class might look something like this. Note that the curly braces denote the beginning and end of the body of a class, method, or any sequence of data, respectively. That is, the parentheses indicate the belonging to a method or class. Each open parenthesis must have a closing parenthesis. In order not to get confused, they are usually put at the same level in the code.

Now let's write the same class in Java only.

Class Telefon
{
void on ()
{
// body of the on () method
}
void off ()
{
// body of the off () method
}
}

The class keyword in the Java language declares a class, followed by the name of the class itself. In our case, this is Telefon. Just a few words about the register of the record. In almost all programming languages, it is important to keep the names recorded in the case in which they were made. If you wrote Telefon, then already such a spelling as telefon or TELefoN will give an error during compilation. As it was written initially, so it is necessary to write further.

Reserved or keywords are written in their specific case, and you cannot use them by giving their names to methods, classes, objects, and so on. Spaces between words don't matter as the compiler simply ignores them, but they are important for the readability of the code.

There are two methods in the body of the Telefon class: on () - turns the phone on and the off () method - turns off the phone. Both methods have their own bodies and, in theory, they should contain some kind of source code describing the necessary actions of both methods. For us now, it doesn't matter how these methods are implemented, the main thing is the syntax of the Java language.

Both methods have parentheses on (), inside which parameters can be written, for example on (int time) or on (int time, int time1). With the help of parameters, there is a kind of connection between the methods and the outside world. The on (int time) method is said to take a time parameter. What is it for? For example, you want your phone to turn on in certain time... Then the integer value in the time parameter will be passed to the body of the method and the phone will be turned on based on the received data. If the parentheses are empty, then the method takes no parameters.

Comments (1)

In the Telefon class, the bodies of both methods have an entry after two slashes: //. Such an entry denotes comments that will be ignored by the compiler, but are needed for readability of the code. The more information you comment out while writing the program, the more chances you will have to remember in a year what you've been working on all this time.

Comments in Java can be of three types, they are:

//, /*…*/ and /**…*/

Comments written using the // operator must be located on one line:

// One line
!!! Error! You cannot wrap to the second line!
// First line
// Second line
// …
// Last line

Comments using the / * ... * / operators can span multiple lines. At the beginning of your comment, put / *, and at the end, when you are finished commenting the code, put the * / operator. The last kind of comment / ** ... * / is used when documenting the code and can also be located on any number of lines.

Java data types

Data types exist in Java to set an arbitrary value. In the Telefon class, we have created two methods. Both methods had no parameters, but when the example of the on (int time) method with the time parameter was given, it was said about passing a value to the method. This value indicated the time by which the phone was supposedly to be turned on. The int specifier determines the type of the time value. Java 2 ME has six data types.

Byte - small integer value from –128 to 128;
short - short integer value in the range from –32768 to 32767;
int - contains any integer value from –2147483648 to 2147483647;
long is a very large integer value, from –922337203685475808 to 9223372036854775807;
char is a Unicode character constant. Range this format 0 to 65536, which is 256 characters. Any character of this type must be written in single quotes, for example: ‘G’;
boolean - a boolean type, has only two values: false - false and true - true. This type is often used in loops about which a little later. The idea is very simple - if you have money in your pocket, presumably this is true, and if not, then false. Thus, if there is money, we go to the store for bread or beer (underline the necessary), if there is no money, we stay at home. That is, it is such a logical value that contributes to the choice of further actions of your program.

To declare some required value, the following entry is used:

Int time;
long BigTime;
char word;

The semicolon operator is required after the entries and is placed at the end of the line. You can combine several ads of the same type separated by commas:

Mt time, time1, time2;

Now let's improve our Telefon class by adding some values to it. We no longer need the on () and off () methods, we will add new methods that can really solve certain problems.

Class Telefon
{
// S - display area
// w - display width
// h - display height
int w, h, S;
// method that calculates the display area
vord Area ()
{
S = w * h;
}
}

So, we have three variables S, w and h, which are responsible, respectively, for the area, width and height of the display in pixels. The Area () method calculates the area of the phone screen in pixels. The operation is useless, but very indicative and easy to understand. The body of the Area () method has acquired itself and has the form S = w * h. In this method, we simply multiply the width by the height and assign or, as they say, store the result in the variable S. This variable will contain the values of the display area this phone.

Now we come close to the operators of the Java language, with which you can perform all sorts of operations. Operators of the Java language, as well as of other programming languages, have their own purposes. So there are arithmetic operators, increment and decrement operators, logical operators, and relational operators. Let's take a look at each of the above operators.

Arithmetic operators

All arithmetic operators are very simple and are similar to the operators for multiplication "*", division "/", addition "+" and subtraction "-" used in mathematics. There is the modulo operator "%" and the situation with the operator equal to "=" is a bit confusing at first glance. The operator equals in programming languages is called the assignment operator:

Here you assign the value 3 to the variable x. And the operator "equal" in programming languages corresponds to writing two consecutive operators "equal": "==". Let's look at an example of what various arithmetic operators can do.

Int x, y, z;
x = 5;
y = 3;
z = 0;
z = x + y;

In this case, z will have the value of the sum of x and y, that is, 8.

The variable x had a value of 5, but after such a record, the previous value is lost and the product z * x (8 * 5) is written, which is 40. Now, if we continue our code further, the variables will look like this:

// x = 40;
// y = 3;
// z = 8;

The addition and subtraction operators have the same purposes as in mathematics. Negative numbers are similarly related.

The decrement “––” and increment “++” operators are very specific, but very simple. There are often times in programming when you need to increase or decrease a value by one. This is often found in loops. The increment operation increases the variable by one.

Int x = 5;
x ++;
// Here x is already 6

The decrement operation decreases the variable by one.

Int x = 5;
x--;
// x is 4

Increment and decrement operations can be post and prefix:

Int x = 5;
int y = 0;
y = x ++;

In the last line of code, first the value x is assigned to y, this is the value 5, and only then the variable x is incremented by one. It turns out that:

The prefix increment is:

Int x = 3;
int y = 0;
y = ++ x;

And in this case, first the variable x is increased by one, and then it assigns the already increased value to y.

Relational operators

Relation operators allow you to check the equality of both parts of an expression. There is an equality operator "==", operators are less than "<» и больше «>", less than or equal to "<=» и больше или равно «>= ", As well as the negation operator"! = ".
9 == 10;

This expression is not true, nine is not equal to ten, so its value for this expression is false.

Here, on the contrary, the negation operator indicates the inequality of the expression, and the value will be true. Greater than, less than, greater than or equal, and less than or equal operators are analogous to the corresponding operators from mathematics.

Logical operators

There are two logical operators. The AND operator, denoted by &&, and the OR operator, denoted by two forward slashes "||". For example, there is an expression:

A * B && B * C;

In the event that only both parts of the expression are true, the value of the expression is considered true. If one of the parts is incorrect, then the value of the entire expression will be false.
In contrast to the "&&" operator, there is the "||" operator, which is not in vain called "OR".

A * B || B * C;

If any part of the expression is true, then the entire expression is considered true. Both operators can be combined in one expression, for example:

A * B || B * C && C * D || B * A;

With the help of this expression, I have led you, it seems to me, into a difficulty, isn't it? The fact is that in Java, as in mathematics, there is a priority or the so-called hierarchy of operators, with the help of which it is determined which of the operators is more important, and, therefore, is checked first. Let's consider using a list the precedence of all the available operators in the Java language:

, ., (),
!, ~, ++, - -, + (unary), - (unary), new,
*, /, %,
+, –,
<<, >>, >>>,
<, <=, >, >=,
= =, !=,
&, ^, |,
&&,
||,
?:,
=, +=, –=, *=, /=, %=, |=, ^=, <<=, >>=, >>>=.

The operator associativity in the list follows from left to right and from top to bottom. That is, everything that is to the left and above is older in rank and more important.

JSP pages have a combined syntax: a combination of the standard syntax that conforms to the HTML specification and the JSP syntax that is defined by the Java Server Pages specification. JSP syntax defines the rules for writing JSP pages, which are composed of standard HTML tags and JSP tags. JSP pages, in addition to HTML tags, contain JSP tags of the following categories:

JSP directives

Directives provide global information regarding specific requests to the JSP and provide information needed during the translation stage.

Directives are always placed at the beginning of the JSP page before all other tags, so that parser(parser) JSP, when parsing the text, at the very beginning, highlighted the global instructions. Thus, the JSP Engine (JSP runtime) parses the code and creates a servlet from the JSP. Directives are messages to a JSP container. Syntax directives The JSP looks like this:

<%@ директива имяАтрибута="значение" %>Task syntax directives in XML: Directive can have multiple attributes. In this case directive can be repeated for each of the attributes. At the same time, couples "AttributeName = value" can be placed under one directive with a space as a separator. There are three types of directives:

page (page)
taglib (tag library)
include (include)

Page directive

Directive page defines properties JSP pages that affect the translator. Order of attributes in a directive page does not matter. Violation of syntax or presence of unrecognized attributes results in a translation error. An example of a directive page the following code can serve:<%@ page buffer="none" isThreadSafe="yes" errorPage="/error.jsp" %>This directive declares that this page The JSP does not use buffering, that it is possible for many users to access a given JSP page at the same time, and that an error page named error.jsp.
Directive page may contain information about the page:<%@ page info = "JSP Sample 1" %>List of possible directive attributes page presented in the table.

Attribute name	Meaning	Description
language	Line	Determines the language used in JSP file scriptlets, expressions, or any include files, including the body of translated code. The default is "java"
extends	Line	Specifies the superclass for the generated servlet. This attribute should be used with great care as it is possible that the server is already using a superclass.
import	Line	Definition of packages to import, for example: & lt% @ page import = "java.util. *%>
Session	true or false	Meaning true(default) indicates that a predefined variable session(type HttpSession) must be bound to an existing session, if any, otherwise a new session is created and bound to. Meaning false determines that sessions will not be used, and attempts to access a variable session will result in an error when translating the JSP page to the servlet
Buffer	none or the size of the buffer in kB.	Sets the buffer size for the JspWriter out. The default value depends on the server settings and should not exceed 8 kB. If the value is none the output goes directly to the object
autoFlush	true or false	Determines whether the buffer should be emptied automatically when it overflows or an error occurs. The default is true
isThreadSafe	true or false	Meaning true(the default) specifies the normal execution mode of the servlet, where multiple requests are processed concurrently using a single servlet instance, assuming that the author has synchronized access to the variables of that instance. A false value signals that the servlet should inherit SingleThreadModel(single-threaded model) where sequential or concurrent requests are handled by separate instances of the servlet
info	Line	Defines a string of information about a JSP page that will be accessed using the method Servlet.getServletInfo ()
errorPage	Line	The attribute value is the URL of the page that should be displayed in the event possible mistakes throwing exceptions
isErrorPage	true or false	Signals whether this page can be used to handle errors for other JSP pages. The default is false
contentType	Line	Specifies the encoding for the JSP page and response, and the MIME type of the JSP response. The default value of the content type is text / html, encodings - ISO-8859-1. For example: contentType = "text / html; charset = ISO-8859-1"
pageEncoding	Line	Determines the character encoding of the JSP page. The default is charset from attribute contentType if it is defined there. If the value charset in attribute contentType undefined, value pageEncoding is set equal ISO-8859-1

Taglib directive

Directive taglib declares that a given JSP page uses a tag library, uniquely identifies it with a URI, and maps a tag prefix with which the library can be acted upon. If the container cannot find the tag library, a fatal translation error occurs. Directive taglib has the following syntax:<%@ taglib uri="URI of the included tag library"prefix =" prefix name"%> Prefix" prefix name"is used when referring to the library. An example of using the tag library mytags: <%@ taglib uri="http://www.taglib/mytags" prefix="customs" %> . . . V this example the tag library has a URI "http: //www.taglib/mytags", the string is assigned as a prefix customs that is used in the JSP page when accessing elements of the tag library.

Include directive

Directive include allows you to insert text or code while translating a JSP page into a servlet. Directive syntax include looks like this:<%@ include file="The relative URI of the page to include"%> Directive include has one attribute - file... It includes the text of the specified resource in the JSP file. This directive can be used to place a standard copyright header on every JSP page:<%@ include file="copyright.html" %>The JSP container accesses the include file. If the include file has changed, the container can recompile the JSP page. Directive include treats a resource, such as a JSP page, as a static object. The given URI is usually interpreted relative to the JSP of the page on which the link is located, but as with any relative URI, you can tell the system the position of the resource of interest relative to the home directory of the WEB server by prefixing the URI with a "/" character. The content of the include file is treated as plain JSP text and therefore can include elements such as static HTML, script elements, directives, and actions. Many sites use a small navigation bar on every page. Due to the problems of using HTML frames, this task is often solved by placing a small table on top or in the left half of the page, the HTML code of which is repeated many times for each page of the site. Directive include- this is the most natural way to solve this problem, saving the developer from the nightmare of the routine of copying HTML into each separate file. Since the directive include includes files during page translation, then after making changes to the navigation bar, re-translation of all JSP pages using it is required. If the attached files change quite often, you can use the action jsp: include that connects the file when accessing the JSP page.

JSP declarations

Declarations (Declarations) are designed to define variables and methods in the scripting language, which are later used in the JSP page. Syntax declarations looks like this:<%! код Java %> ads are located in the declaration block and are called in the expression block of the JSP page. The code in the declaration block is usually written in Java, but application servers can use the syntax of other scripts. ads are sometimes used to add additional functionality when working with dynamic data obtained from properties of JavaBeans components. Examples of ads are presented in the table. Announcement can contain multiple lines, such as in the below code for calculating the value of a function fact (int n), which should be equal to 1 when n is less than 2 and n! with a positive value of n;<%! public static int fact (int n) { if (n ads do not produce any output to standard output out... Variables and methods declared in announcements are initialized and made available to scriptlets and other ads at the time the JSP page is initialized.

JSP Scriptlets

Scriptlets include various pieces of code written in the scripting language defined in the directive language... Code snippets must comply with the syntactic constructs of the language scriptlets, i.e., usually the syntax of the Java language. Scriptlets have the following syntax:<% текст скриптлета %>Syntax equivalent scriptlet for XML is: scriptlet text

If in the text scriptlet it is necessary to use the sequence of characters%> exactly as a combination of characters, and not as a tag - an end sign scriptlet, instead of the sequence%>, use the following combination of characters% \>.

The JSP specification provides a simple and straightforward example scriptlet that dynamically changes the content of the JSP page throughout the day.<% if (Calendar.getInstance ().get (Calendar.AM_PM) == Calendar.AM) {%>Good morning<% } else { %>Good Afternoon<% } %>It should be noted that the code inside scriptlet inserted as written and all static HTML text (template text) before or after scriptlet converted using the operator print... This means that scriptlets do not have to contain completed Java chunks, and that leaving open chunks can affect static HTML outside of scriptlet. Scripts have access to the same auto-defined variables as expressions. Therefore, for example, if there is a need to display any information on the page, you must use the variable out. <% String queryData = request.getQueryString (); out.println ("Дополнительные данные запроса: " + queryData); %>

JSP expressions

Expression in a JSP page is an executable expression written in the scripting language specified in the declaration language(how Java rule). Result expressions JSP of required type String, sent to standard output out using the current object JspWriter... If the result is expressions cannot be cast String, either a translation error occurs if the problem was detected at the translation stage, or an exception is thrown ClassCastException if the inconsistency was detected during the execution of the request. Expression has the following syntax: & lt% = expression text%> alternative syntax for expressions JSP when using XML: expression textExecution order expressions in the JSP page from left to right. If expression appears in more than one run-time attribute, then it runs from left to right in that tag. Expression must be a complete expression in a specific script (typically Java). Expressions are executed while the HTTP protocol is running. The expression value is converted to a string and included in the appropriate position in the JSP file. Expressions are commonly used to compute and display the string representation of variables and methods defined in a JSP page declaration block or derived from JavaBeans that are accessible from a JSP. The following code expressions serves to display the date and time of the request for this page: Current time: & lt% = new java.util.Date ()%> To simplify expressions there are several predefined variables that you can use. The most commonly used variables are:

request, HttpServletRequest;
response, HttpServletResponse;
session, HttpSession - associated with the request, if any;
out, PrintWriter - a buffered version of the JspWriter type for sending data to the client.

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

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 via 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 a try (...) catch (...) (...) block that handles exceptions, 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 the execution of 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 correct in terms of 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 (class String), 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 enumerations, 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 autobox / autobox 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 hidden by a 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 (

JSP page syntax. Conditional constructs

JSP directives

Page directive

Taglib directive

Include directive

JSP declarations

JSP Scriptlets

JSP expressions

Purpose, features and benefits of Eclipse

Eclipse workspace

The first Java program

Java syntax basics

Definitions

Program and algorithm concepts (repetition)

Literature on the topic:

Basic Algorithm Constructions (Repetition)

Literature on the topic:

The basics of Java syntax basics

Comments (1)

Literal writing rules

Identifiers

Data types

Declaring Variables

Basic language operations

Mathematical operations

Comparison operations, the result is a boolean value: true or false

Logical operations

Shift operations

Bitwise operations

Operation?:

Assignment operator

Exercise 1

Increment and decrement operators

Conditional if statement

Exercise 2

Compound commands

Switch selection statement

While loop statement

Exercise # 3

For loop operator

Exercise 4

Break and continue statements

Conclusion

additional literature