Blog

Unicode is an international character set that encompasses a vast range of characters, symbols, and scripts from many languages across the globe.

Unicode System in Java

Java programming language, being platform-independent, has built-in support for Unicode characters, allowing developers to create applications that can work seamlessly with diverse languages and scripts.

Before Unicode, there were multiple standards to represent character encoding −

• ASCII − for the United States.
• ISO 8859-1 − for Western European Language.
• KOI-8 − for Russian.
• GB18030 and BIG-5 − for Chinese.

So to support multinational application codes, some character was using single byte, some two. An even same code may represent a different character in one language and may represent other characters in another language.

To overcome above shortcoming, the Unicode system was developed where each character is represented by 2 bytes. As Java was developed for multilingual languages it adopted the Unicode system. The lowest value is represented by \u0000 and the highest value is represented by \uFFFF.

Approaches: Working with Unicode Characters & Values

There are two approaches for working with Unicode characters in Java: Using Unicode Escape Sequences and Directly Storing Unicode Characters.

The first approach involves representing Unicode characters using escape sequences and is useful when the characters cannot be directly typed or displayed in the Java code. The second approach involves directly storing Unicode characters in variables and is more convenient when the characters can be directly typed or displayed.

The choice of approach depends on the specific requirements of the program. However, in general, Approach 2 is simpler and more convenient when the characters can be directly typed or displayed, while Approach 1 is necessary when they cannot.

1. Using Unicode Escape Sequences

One way to store Unicode characters in Java is by using Unicode escape sequences. An escape sequence is a series of characters that represent a special character. In Java, a Unicode escape sequence starts with the characters ‘\u’ followed by four hexadecimal digits that represent the Unicode code point of the desired character.

Example: Use of Unicode Escape Sequences

packagecom.tutorialspoint;publicclassUnicodeCharacterDemo{publicstaticvoid main (String[]args){//Unicode escape sequencechar unicodeChar ='\u0041';// point for 'A'System.out.println("Stored Unicode Character: "+ unicodeChar);}}

Compile and run above program. This will produce the following result −

Output

Stored Unicode Character: A

In the above code snippet, the Unicode escape sequence ‘\u0041’ represents the character ‘A.’ The escape sequence is assigned to the char variable unicodeChar, and the stored character is then printed to the console.

2. Storing Unicode Values Directly

Alternatively, you can directly store a Unicode character in a char variable by enclosing the character in single quotes. However, this approach may not be feasible for characters that cannot be typed directly using a keyboard or are not visible, such as control characters.

Example 1: Assigning Unicode Character to Variable

packagecom.tutorialspoint;publicclassUnicodeCharacterDemo{publicstaticvoidmain(String[] args){// Storing Unicode character directlychar unicodeChar ='A';// Directly storing the character 'A'System.out.println("Stored Unicode Character: "+ unicodeChar);}}

Compile and run above program. This will produce the following result −

Output

Stored Unicode Character: A

In this example, the character ‘A’ is directly enclosed in single quotes and assigned to the char variable unicodeChar. The stored character is then printed to the console.

Example 2: Assigning Unicode Values to Variables

packagecom.tutorialspoint;publicclassUnicodeCharacterDemo{publicstaticvoidmain(String[] args){// Storing Unicode characters using escape sequenceschar letterA ='\u0041';char letterSigma ='\u03A3';char copyrightSymbol ='\u00A9';// Storing Unicode characters directlychar letterZ ='Z';char letterOmega ='Ω';char registeredSymbol ='®';// Printing the stored Unicode charactersSystem.out.println("Stored Unicode Characters using Escape Sequences:");System.out.println("Letter A: "+ letterA);System.out.println("Greek Capital Letter Sigma: "+ letterSigma);System.out.println("Copyright Symbol: "+ copyrightSymbol);System.out.println("\nStored Unicode Characters Directly:");System.out.println("Letter Z: "+ letterZ);System.out.println("Greek Capital Letter Omega: "+ letterOmega);System.out.println("Registered Symbol: "+ registeredSymbol);}}

Compile and run above program. This will produce the following result −

Output

Stored Unicode Characters using Escape Sequences:
Letter A: A
Greek Capital Letter Sigma: Σ
Copyright Symbol: ©

Stored Unicode Characters Directly:
Letter Z: Z
Greek Capital Letter Omega: Ω
Registered Symbol: ®

Example 3: Assigning Unicode Characters and Values to Variables

This example demonstrates how to manipulate the stored Unicode characters. It calculates the difference between the capital letter ‘A’ and the small letter ‘a’ and uses that difference to calculate the capital letter ‘C.’ It then calculates the small letter ‘c’ by adding 32 to the Unicode code point of the capital letter ‘C.’ The manipulated Unicode characters are printed to the console.

packagecom.tutorialspoint;publicclassUnicodeCharacterDemo{publicstaticvoidmain(String[] args){// Storing Unicode characters using escape sequenceschar letterA ='\u0041';char letterSmallA ='\u0061';// Storing Unicode characters directlychar letterB ='B';// Manipulating the stored Unicode charactersint difference = letterA - letterSmallA;char letterC =(char)(letterB + difference);char letterSmallC =(char)(letterC +32);// Printing the manipulated Unicode charactersSystem.out.println("Manipulated Unicode Characters:");System.out.println("Difference between A and a: "+ difference);System.out.println("Calculated Letter C: "+ letterC);System.out.println("Calculated Letter c: "+ letterSmallC);}}

Compile and run above program. This will produce the following result −

Output

Manipulated Unicode Characters:
Difference between A and a: -32
Calculated Letter C: "
Calculated Letter c: B

Java Type Casting (Type Conversion)

Type casting is a technique that is used either by the compiler or a programmer to convert one data type to another. For example, converting int to double, double to int, short to int, etc. Type typing is also known as Type conversion.

There are two types of cast typing allowed in Java programming:

• Widening type casting
• Narrowing type casting

Widening Type Casting

Widening Type Casting is also known as implicit type casting in which a smaller type is converted into a larger type, it is done by the compiler automatically.

Here is the hierarchy of widening type casting in Java:

byte>short>char>int>long>float>double

The compiler plays a role in the type conversion but not the programmers. It changes the type of the variables at the compile time. Also, type conversion occurs from the small data type to large data type only.

Example 1: Widening Type Casting

In the example below, we demonstrated that we can get an error when the compiler tries to convert a large data type to a small data type. Here, we created the num1 integer and num2 double variable. The sum of num1 and num2 will be double, and when we try to store it to the sum of the int type, the compiler gives an error.

packagecom.tutorialspoint;publicclassTester{// Main driver methodpublicstaticvoidmain(String[] args){// Define int variablesint num1 =5004;double num2 =2.5;int sum = num1 + num2;// show outputSystem.out.println("The sum of "+ num1 +" and "+ num2 +" is "+ sum);}}

Compile and run Tester. This will produce the following result −

Output

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	Type mismatch: cannot convert from double to int

	at com.tutorialspoint.Tester.main(Tester.java:9)

Example 2: Widening Type Casting

In the example below, we created the num1 and num2 variables as same in the first example. We store the sum of both numbers in the sum variable of double type. In the output, we can observe the sum of double type.

packagecom.tutorialspoint;publicclassTester{// Main driver methodpublicstaticvoidmain(String[] args){// Define int variablesint num1 =5004;double num2 =2.5;double sum = num1 + num2;// show outputSystem.out.println("The sum of "+ num1 +" and "+ num2 +" is "+ sum);}}

Compile and run Tester. This will produce the following result −

Output

The sum of 5004 and 2.5 is 5006.5

Narrowing Type Casting

Narrowing type casting is also known as explicit type casting or explicit type conversion which is done by the programmer manually. In the narrowing type casting a larger type can be converted into a smaller type.

When a programmer changes the variable type while writing the code. We can use the cast operator to change the type of the variable. For example, double to int or int to double.

Syntax

Below is the syntax for narrowing type casting i.e., to manually type conversion:

double doubleNum =(double) num;

The above code statement will convert the variable to double type.

Example: Narrowing Type Casting

In the example below, we define the num variable of integer type and initialize it with the value. Also, we define the doubleNum variable of double type and store the num variable’s value after converting it to the double.

Next, We created the ‘convertedInt’ integer type variable and stored the double value after type casting to int. In the output, we can observe the value of the double and int variables.

packagecom.tutorialspoint;publicclassTester{// Main driver methodpublicstaticvoidmain(String[] args){// Define int variableint num =5004;// Type casting int to doubledouble doubleNum =(double) num;// show outputSystem.out.println("The value of "+ num +" after converting to the double is "+ doubleNum);// Type casting double to intint convertedInt =(int) doubleNum;// show outputSystem.out.println("The value of "+ doubleNum +" after converting to the int again is "+ convertedInt);}}

Compile and run Tester. This will produce the following result −

Output

The value of 5004 after converting to the double is 5004.0
The value of 5004.0 after converting to the int again is 5004

Data types define the type and value range of the data for the different types of variables, constants, method parameters, returns type, etc. The data type tells the compiler about the type of data to be stored and the required memory. To store and manipulate different types of data, all variables must have specified data types.

Java data types are categorized into two parts −

• Primitive Data Types
• Reference/Object Data Types

Java Primitive Data Types

Primitive data types are predefined by the language and named by a keyword. There are eight primitive data types supported by Java. Below is the list of the primitive data types:

• byte
• short
• int
• long
• float
• double
• boolean

Java byte Data Type

• Byte data type is an 8-bit signed two’s complement integer
• Minimum value is -128 (-2^7)
• Maximum value is 127 (inclusive)(2^7 -1)
• Default value is 0
• Byte data type is used to save space in large arrays, mainly in place of integers, since a byte is four times smaller than an integer.
• Example − byte a = 100, byte b = -50

Java short Data Type

• Short data type is a 16-bit signed two’s complement integer
• Minimum value is -32,768 (-2^15)
• Maximum value is 32,767 (inclusive) (2^15 -1)
• Short data type can also be used to save memory as byte data type. A short is 2 times smaller than an integer
• Default value is 0.
• Example − short s = 10000, short r = -20000

Java int Data Type

• Int data type is a 32-bit signed two’s complement integer.
• Minimum value is – 2,147,483,648 (-2^31)
• Maximum value is 2,147,483,647(inclusive) (2^31 -1)
• Integer is generally used as the default data type for integral values unless there is a concern about memory.
• The default value is 0
• Example − int a = 100000, int b = -200000

Java long Data Type

• Long data type is a 64-bit signed two’s complement integer
• Minimum value is -9,223,372,036,854,775,808(-2^63)
• Maximum value is 9,223,372,036,854,775,807 (inclusive)(2^63 -1)
• This type is used when a wider range than int is needed
• Default value is 0L
• Example − long a = 100000L, long b = -200000L

Java float Data Type

• Float data type is a single-precision 32-bit IEEE 754 floating point
• Float is mainly used to save memory in large arrays of floating point numbers
• Default value is 0.0f
• Float data type is never used for precise values such as currency
• Example − float f1 = 234.5f

Java double Data Type

• double data type is a double-precision 64-bit IEEE 754 floating point
• This data type is generally used as the default data type for decimal values, generally the default choice
• Double data type should never be used for precise values such as currency
• Default value is 0.0d
• Example − double d1 = 123.4

Java boolean Data Type

• boolean data type represents one bit of information
• There are only two possible values: true and false
• This data type is used for simple flags that track true/false conditions
• Default value is false
• Example − boolean one = true

Java char Data Type

• char data type is a single 16-bit Unicode character
• Minimum value is ‘\u0000’ (or 0)
• Maximum value is ‘\uffff’ (or 65,535 inclusive)
• Char data type is used to store any character
• Example − char letterA = ‘A’

Example: Demonstrating Different Primitive Data Types

Following examples shows the usage of variour primitive data types we’ve discussed above. We’ve used add operations on numeric data types whereas boolean and char variables are printed as such.

publicclassJavaTester{publicstaticvoidmain(String args[]){byte byteValue1 =2;byte byteValue2 =4;byte byteResult =(byte)(byteValue1 + byteValue2);System.out.println("Byte: "+ byteResult);short shortValue1 =2;short shortValue2 =4;short shortResult =(short)(shortValue1 + shortValue2);System.out.println("Short: "+ shortResult);int intValue1 =2;int intValue2 =4;int intResult = intValue1 + intValue2;System.out.println("Int: "+ intResult);long longValue1 =2L;long longValue2 =4L;long longResult = longValue1 + longValue2;System.out.println("Long: "+ longResult);float floatValue1 =2.0f;float floatValue2 =4.0f;float floatResult = floatValue1 + floatValue2;System.out.println("Float: "+ floatResult);double doubleValue1 =2.0;double doubleValue2 =4.0;double doubleResult = doubleValue1 + doubleValue2;System.out.println("Double: "+ doubleResult);boolean booleanValue =true;System.out.println("Boolean: "+ booleanValue);char charValue ='A';System.out.println("Char: "+ charValue);}}

Output

Byte: 6
Short: 6
Int: 6
Long: 6
Float: 6.0
Double: 6.0
Boolean: true
Char: A

Java Reference/Object Data Type

The reference data types are created using defined constructors of the classes. They are used to access objects. These variables are declared to be of a specific type that cannot be changed. For example, Employee, Puppy, etc.

Class objects and various types of array variables come under reference datatype. The default value of any reference variable is null. A reference variable can be used to refer to any object of the declared type or any compatible type.

Example

The following example demonstrates the reference (or, object) data types.

// Creating an object of 'Animal' classAnimal animal =newAnimal("giraffe");// Creating an object of 'String' classString myString =newString("Hello, World!");

What is a Java Variable?

A variable provides us with named storage that our programs can manipulate. Each variable in Java has a specific type, which determines the size and layout of the variable’s memory; the range of values that can be stored within that memory; and the set of operations that can be applied to the variable.

Variable Declaration and Initialization

You must declare all variables before they can be used. Following is the basic form of a variable declaration −

data type variable [= value][, variable [= value]...];

Here data type is one of Java’s data types and variable is the name of the variable. To declare more than one variable of the specified type, you can use a comma-separated list.

Example of Valid Variables Declarations and Initializations

Following are valid examples of variable declaration and initialization in Java −

int a, b, c;// Declares three ints, a, b, and c.int a =10, b =10;// Example of initializationbyteB=22;// initializes a byte type variable B.double pi =3.14159;// declares and assigns a value of PI.char a ='a';// the char variable a iis initialized with value 'a'

Java Variables Types

The following are the three types of Java variables:

• Local variables
• Instance variables
• Class/Static variables

1. Java Local Variables

• Local variables are declared in methods, constructors, or blocks.
• Local variables are created when the method, constructor or block is entered and the variable will be destroyed once it exits the method, constructor, or block.
• Access modifiers cannot be used for local variables.
• Local variables are visible only within the declared method, constructor, or block.
• Local variables are implemented at stack level internally.
• There is no default value for local variables, so local variables should be declared and an initial value should be assigned before the first use.

Example 1: Variable’s local scope with initialization

Here, age is a local variable. This is defined inside pupAge() method and its scope is limited to only this method.

publicclassTest{publicvoidpupAge(){int age =0;
  age = age +7;System.out.println("Puppy age is : "+ age);}publicstaticvoidmain(String args[]){Test test =newTest();
  test.pupAge();}}</code></pre>


Output



Puppy age is: 7




Example 2: Variable's local scope without initialization



Following example uses age without initializing it, so it would give an error at the time of compilation.



publicclassTest{publicvoidpupAge(){int age;
  age = age +7;System.out.println("Puppy age is : "+ age);}publicstaticvoidmain(String args&#91;]){Test test =newTest();
  test.pupAge();}}</code></pre>


Output



Test.java:4:variable number might not have been initialized
age = age + 7;
     ^
1 error




2. Java Instance Variables




Instance variables are declared in a class, but outside a method, constructor or any block.



When a space is allocated for an object in the heap, a slot for each instance variable value is created.



Instance variables are created when an object is created with the use of the keyword 'new' and destroyed when the object is destroyed.



Instance variables hold values that must be referenced by more than one method, constructor or block, or essential parts of an object's state that must be present throughout the class.



Instance variables can be declared in class level before or after use.



Access modifiers can be given for instance variables.



The instance variables are visible for all methods, constructors and block in the class. Normally, it is recommended to make these variables private (access level). However, visibility for subclasses can be given for these variables with the use of access modifiers.



Instance variables have default values. For numbers, the default value is 0, for Booleans it is false, and for object references it is null. Values can be assigned during the declaration or within the constructor.



Instance variables can be accessed directly by calling the variable name inside the class. However, within static methods (when instance variables are given accessibility), they should be called using the fully qualified name. ObjectReference.VariableName.




Example of Java Instance Variables



importjava.io.*;publicclassEmployee{// this instance variable is visible for any child class.publicString name;// salary  variable is visible in Employee class only.privatedouble salary;// The name variable is assigned in the constructor.publicEmployee(String empName){
  name = empName;}// The salary variable is assigned a value.publicvoidsetSalary(double empSal){
  salary = empSal;}// This method prints the employee details.publicvoidprintEmp(){System.out.println("name  : "+ name );System.out.println("salary :"+ salary);}publicstaticvoidmain(String args&#91;]){Employee empOne =newEmployee("Ransika");
  empOne.setSalary(1000);
  empOne.printEmp();}}</code></pre>


Output



name  : Ransika
salary :1000.0




3. Java Class/Static Variables




Class variables also known as static variables are declared with the static keyword in a class, but outside a method, constructor or a block.



There would only be one copy of each class variable per class, regardless of how many objects are created from it.



Static variables are rarely used other than being declared as constants. Constants are variables that are declared as public/private, final, and static. Constant variables never change from their initial value.



Static variables are stored in the static memory. It is rare to use static variables other than declared final and used as either public or private constants.



Static variables are created when the program starts and destroyed when the program stops.



Visibility is similar to instance variables. However, most static variables are declared public since they must be available for users of the class.



Default values are same as instance variables. For numbers, the default value is 0; for Booleans, it is false; and for object references, it is null. Values can be assigned during the declaration or within the constructor. Additionally, values can be assigned in special static initializer blocks.



Static variables can be accessed by calling with the class name ClassName.VariableName.



When declaring class variables as public static final, then variable names (constants) are all in upper case. If the static variables are not public and final, the naming syntax is the same as instance and local variables.




Example of Java Class/Static Variables



importjava.io.*;publicclassEmployee{// salary  variable is a private static variableprivatestaticdouble salary;// DEPARTMENT is a constantpublicstaticfinalStringDEPARTMENT="Development ";publicstaticvoidmain(String args[]){
  salary =1000;System.out.println(DEPARTMENT+"average salary:"+ salary);}}</code></pre>


Output



Development average salary:1000

When we consider a Java program, it can be defined as a collection of objects that communicate via invoking each other’s methods. Let us now briefly look into what do class, object, methods, and instance variables mean.

• Object − Objects have states and behaviors. Example: A dog has states – color, name, breed as well as behavior such as wagging their tail, barking, eating. An object is an instance of a class.
• Class − A class can be defined as a template/blueprint that describes the behavior/state that the object of its type supports.
• Methods − A method is basically a behavior. A class can contain many methods. It is in methods where the logics are written, data is manipulated and all the actions are executed.
• Instance Variables − Each object has its unique set of instance variables. An object’s state is created by the values assigned to these instance variables.

First Java Program

Let us look at a simple code that will print the words Hello World.

Example

publicclassMyFirstJavaProgram{/* This is my first java program.
* This will print 'Hello World' as the output
*/publicstaticvoidmain(String&#91;]args){System.out.println("Hello World");// prints Hello World}}</code></pre>


Let's look at how to save the file, compile, and run the program. Please follow the subsequent steps −




Open notepad and add the code as above.



Save the file as: MyFirstJavaProgram.java.



Open a command prompt window and go to the directory where you saved the class. Assume it's C:\.



Type 'javac MyFirstJavaProgram.java' and press enter to compile your code. If there are no errors in your code, the command prompt will take you to the next line (Assumption : The path variable is set).



Now, type ' java MyFirstJavaProgram ' to run your program.



You will be able to see ' Hello World ' printed on the window.




Output



C:\> javac MyFirstJavaProgram.java
C:\> java MyFirstJavaProgram 
Hello World




Basic Syntax



About Java programs, it is very important to keep in mind the following points.




Case Sensitivity − Java is case sensitive, which means identifier Hello and hello would have different meaning in Java.



Class Names − For all class names the first letter should be in Upper Case. If several words are used to form a name of the class, each inner word's first letter should be in Upper Case.Example − class MyFirstJavaClass



Method Names − All method names should start with a Lower Case letter. If several words are used to form the name of the method, then each inner word's first letter should be in Upper Case.Example − public void myMethodName()



Program File Name − Name of the program file should exactly match the class name.When saving the file, you should save it using the class name (Remember Java is case sensitive) and append '.java' to the end of the name (if the file name and the class name do not match, your program will not compile).But please make a note that in case you do not have a public class present in the file then file name can be different than class name. It is also not mandatory to have a public class in the file.Example − Assume 'MyFirstJavaProgram' is the class name. Then the file should be saved as 'MyFirstJavaProgram.java'



public static void main(String args[]) − Java program processing starts from the main() method which is a mandatory part of every Java program.




Java Identifiers



All Java components require names. Names used for classes, variables, and methods are called identifiers.



In Java, there are several points to remember about identifiers. They are as follows −




All identifiers should begin with a letter (A to Z or a to z), currency character ($) or an underscore (_).



After the first character, identifiers can have any combination of characters.



A key word cannot be used as an identifier.



Most importantly, identifiers are case sensitive.



Examples of legal identifiers: age, $salary, _value, __1_value.



Examples of illegal identifiers: 123abc, -salary.




Java Modifiers



Like other languages, it is possible to modify classes, methods, etc., by using modifiers. There are two categories of modifiers −




Access Modifiers − default, public , protected, private



Non-access Modifiers − final, abstract, strictfp




We will be looking into more details about modifiers in the next section.



Java Variables



Following are the types of variables in Java −




Local Variables



Class Variables (Static Variables)



Instance Variables (Non-static Variables)




Java Arrays



Arrays are objects that store multiple variables of the same type. However, an array itself is an object on the heap. We will look into how to declare, construct, and initialize in the upcoming chapters.



Java Enums



Enums were introduced in Java 5.0. Enums restrict a variable to have one of only a few predefined values. The values in this enumerated list are called enums.



With the use of enums it is possible to reduce the number of bugs in your code.



For example, if we consider an application for a fresh juice shop, it would be possible to restrict the glass size to small, medium, and large. This would make sure that it would not allow anyone to order any size other than small, medium, or large.



Example



classFreshJuice{enumFreshJuiceSize{SMALL,MEDIUM,LARGE}FreshJuiceSize size;}publicclassFreshJuiceTest{publicstaticvoidmain(String args[]){FreshJuice juice =newFreshJuice();
  juice.size =FreshJuice.FreshJuiceSize.MEDIUM;System.out.println("Size: "+ juice.size);}}</code></pre>


Output



The above example will produce the following result −



Size: MEDIUM




Note − Enums can be declared as their own or inside a class. Methods, variables, constructors can be defined inside enums as well.



Java Keywords



The following list shows the reserved words in Java. These reserved words may not be used as constant or variable or any other identifier names.



Sr.No
Reserved Words & Description
1
abstractAs per dictionary, abstraction is the quality of dealing with ideas rather than events.
2
assertassert keyword is used in Java to define assertion. An assertion is a statement in Java which ensures the correctness of any assumptions which have been done in the program.
3
booleanboolean datatype is one of the eight primitive datatype supported by Java. It provides means to create boolean type variables which can accept a boolean value as true or false.
4
breakThe break statement in Java programming language has the following two usages −When the break statement is encountered inside a loop, the loop is immediately terminated and the program control resumes at the next statement following the loop.It can be used to terminate a case in the switch statement.
5
bytebyte datatype is one of the eight primitive datatype supported by Java. It provides means to create byte type variables which can accept a byte value.
6
casecase keyword is part of switch statement which allows a variable to be tested for equality against a list of values.
7
catchAn exception (or exceptional event) is a problem that arises during the execution of a program.
8
charchar datatype is one of the eight primitive datatype supported by Java.
9
classJava is an Object-Oriented Language. As a language that has the Object-Oriented feature.
10
constfinal keyword is used to define constant value or final methods/classes in Java.
11
continueThe continue keyword can be used in any of the loop control structures.
12
defaultdefault keyword is part of switch statement which allows a variable to be tested for equality against a list of values.
13
doA do...while loop is similar to a while loop, except that a do...while loop is guaranteed to execute at least one time.
14
doubledouble datatype is one of the eight primitive datatype supported by Java.
15
ifAn if statement can be followed by an optional else statement, which executes when the Boolean expression is false.
16
enumThe Java Enum class is the common base class of all Java language enumeration types.
17
extendsextends is the keyword used to inherit the properties of a class. Following is the syntax of extends keyword.
18
finalfinal keyword is used to define constant value or final methods/classes in Java.
19
finallyfinally keyword is used to define a finally block. The finally block follows a try block or a catch block. A finally block of code always executes, irrespective of occurrence of an Exception.
20
floatfloat datatype is one of the eight primitive datatype supported by Java. It provides means to create float type variables which can accept a float value.
21
forA for loop is a repetition control structure that allows you to efficiently write a loop that needs to be executed a specific number of times.
22
gotogoto statement is not supported by Java currrenly. It is kept as a reserved keyword for future. As an alternative, Java supports labels with break and continue statement.
23
ifAn if statement consists of a Boolean expression followed by one or more statements.
24
implementsGenerally, the implements keyword is used with classes to inherit the properties of an interface.
25
importimport keyboard is used in context of packages.
26
instanceofinstanceof keyword is an operator which is used only for object reference variables.
27
intint datatype is one of the eight primitive datatype supported by Java.
28
interfaceAn interface is a reference type in Java. It is similar to class. It is a collection of abstract methods.
29
longlong datatype is one of the eight primitive datatype supported by Java.
30
native
31
new
32
packagePackages are used in Java in order to prevent naming conflicts, to control access, to make searching/locating and usage of classes, interfaces, enumerations and annotations easier, etc.
33
privateMethods, variables, and constructors that are declared private can only be accessed within the declared class itself.
34
protectedThe protected access modifier cannot be applied to class and interfaces.
35
publicA class, method, constructor, interface, etc. declared public can be accessed from any other class.
36
return
37
shortBy assigning different data types to variables, you can store integers, decimals, or characters in these variables.
38
staticThe static keyword is used to create variables that will exist independently of any instances created for the class.
39
strictfp
40
superThe super keyword is similar to this keyword.
41
switchA switch statement allows a variable to be tested for equality against a list of values.
42
synchronized
43
thisthis keyword is a very important keyword to identify an object. Following are the usage of this keyword.
44
throwIf a method does not handle a checked exception, the method must declare it using the throws keyword.
45
transientSerialization is a concept using which we can write the state of an object into a byte stream so that we can transfer it over the network (using technologies like JPA and RMI).
46
tryA method catches an exception using a combination of the try and catch keywords.
47
void
48
volatile
49
whileA while loop statement in Java programming language repeatedly executes a target statement as long as a given condition is true.



Comments in Java



Java supports single-line and multi-line comments very similar to C and C++. All characters available inside any comment are ignored by Java compiler.



Example



publicclassMyFirstJavaProgram{/* This is my first java program.
* This will print 'Hello World' as the output
* This is an example of multi-line comments.
*/publicstaticvoidmain(String&#91;]args){// This is an example of single line comment/* This is also an example of single line comment. */System.out.println("Hello World");}}</code></pre>


Output



Hello World




Using Blank Lines



A line containing only white space, possibly with a comment, is known as a blank line, and Java totally ignores it.



Inheritance



In Java, classes can be derived from classes. Basically, if you need to create a new class and here is already a class that has some of the code you require, then it is possible to derive your new class from the already existing code.



This concept allows you to reuse the fields and methods of the existing class without having to rewrite the code in a new class. In this scenario, the existing class is called the superclass and the derived class is called the subclass.



Interfaces



In Java language, an interface can be defined as a contract between objects on how to communicate with each other. Interfaces play a vital role when it comes to the concept of inheritance.



An interface defines the methods, a deriving class (subclass) should use. But the implementation of the methods is totally up to the subclass.