Introduction of Java

Two-part introduction to the Java programming tutorial is for software developers who are
new to Java technology. Work through both rising and moving parts with object-oriented
programming (OOP) and real-world application development using Java-language and platform.

 Java is a simple, robust and secure programming language. Here are the key features of Java:

This first part is a step-by-step introduction to OOP using Java language. The tutorial starts with
an overview of the Java platform and language, followed by instructions for setting up a
development environment, combined with the Java Development Kit (JDK) and the Eclipse IDE.
After getting acquainted with the components of your development environment, you start learning
basic Java syntax.

Prerequisites

This tutorial is for software developers who are not yet experienced with Java code or the Java
platform. The tutorial includes an summary or you can say overview of OOP concepts.

System requirements

To complete the exercises in this tutorial, you will install and set up a development environment
consisting of:

JDK 8 from Oracle

Eclipse IDE for Java Developers

Java platform overview

Java technology is mainly used to develop and make applications for a hige range of environments,
from consumer devices to heterogeneous enterprise systems. In this section, get a high-level view
of the Java platform and its components.

Many Java developers are constantly referring to the official Java API documents called Javadoc.
Three locations are planned in Javadoc. The top left lane shows all API packages, and the bottom left
shows lessons for each set. The main panel shows the details for the currently selected package or
class. For example, if you click java.utilpackage in the top left, then click the ArrayList class below, you see the details on the right side of the ArrayList, including the description of how to use it and its methods.

As any programming language, the Java language has own structure, syntax rules, and programming paradigm.

The Java language's programming paradigm is literally based on the perception of OOP, which the language's features support.

The Java language is a C-language derivative, as its syntax guideline look much like C's. For example, code

blocks are modularized into process and delimited by braces ({ and }), and variables are acknowledge before

they are used.

The Java compiler

Working on the Java platform, you write source code in .java files and then compile them. The compiler checks your code opposed to the language's syntax rules, then writes out bytecode in .class files. Bytecode is a set of guidelines targeted to run on a Java virtual machine (JVM). In this level adding of abstraction, the Java compiler differs from other language compilers, which write out instructions suitable for the CPU chipset the program will run on.

The JVM

During the runtime, JVM reads and interprets .class files. The program executes the instructions on the original hardware platform, for which JVM was written. JVM interprets the bytecode in the same way as the CPU interprets assembly-language instructions. The difference is that JVM is a piece of software specifically written for a particular platform. JVM is the heart of the Java language's "right-ons, run-anne-somewhere" theory.

Your code can run on any chipset for which an appropriate JVM implementation is available. JVM is available for major platforms such as Linux and Windows, and java language subsets have been implemented in JVM for mobile phones and Hobbit chips.

The garbage collector

Rather than forcing you to keep up with memory allocation (or use a third-party library to do so), the
Java platform gives data management out of the box. When your Java application creates an object
instance at during time, the JVM naturally allocates memory space for that object from the heap— a
pool of memory set aside for your program to work or use. The Java garbage collector runs in the
background, keeping track of which objects the application no longer needs and reclaiming memory