Java Fundamentals

5 (1 reviews total)
By Gazihan Alankus , Rogério Theodoro de Brito , Basheer Ahamed Fazal and 2 more
  • Instant online access to over 7,500+ books and videos
  • Constantly updated with 100+ new titles each month
  • Breadth and depth in over 1,000+ technologies

About this book

Since its inception, Java has stormed the programming world. Its features and functionalities provide developers with the tools needed to write robust cross-platform applications. Java Fundamentals introduces you to these tools and functionalities that will enable you to create Java programs.

The book begins with an introduction to the language, its philosophy, and evolution over time, until the latest release. You'll learn how the javac/java tools work and what Java packages are - the way a Java program is usually organized. Once you are comfortable with this, you'll be introduced to advanced concepts of the language, such as control flow keywords. You'll explore object-oriented programming and the part it plays in making Java what it is. In the concluding chapters, you'll get to grips with classes, typecasting, and interfaces, and understand the use of data structures, arrays, strings, handling exceptions, and creating generics.

By the end of this book, you will have learned to write programs, automate tasks, and follow advanced courses on algorithms and data structures or explore more advanced Java courses.

Publication date:
March 2019
Publisher
Packt
Pages
408
ISBN
9781789801736

 

Chapter 1. Introduction to Java

Note

Learning Objectives

By the end of this lesson, you'll be able to:

  • Describe the working of the Java ecosystem

  • Write simple Java programs

  • Read input from the users

  • Utilize classes in the java.util package

 

Introduction


In this first lesson, we are embarking on our study of Java. If you are coming to Java from a background of working with another programming language, you probably know that Java is a language for programming computers. But Java goes beyond just that. It's more than a very popular and successful language that is virtually present everywhere, it is a collection of technologies. Besides the language, it encompasses a very rich ecosystem and it has a vibrant community working on many facets to make the ecosystem as dynamic as it can be.

 

The Java Ecosystem


The three most basic parts of the Java ecosystem are the Java Virtual Machine (JVM), the Java Runtime Environment (JRE), and the Java Development Kit (JDK), which are stock parts that are supplied by Java implementations.

Figure 1.1: A representation of the Java ecosystem

Every Java program runs under the control of a JVM. Every time you run a Java program, an instance of JVM is created. It provides security and isolation for the Java program that is running. It prevents the running of the code from clashing with other programs within the system. It works like a non-strict sandbox, making it safe to serve resources, even in hostile environments such as the internet, but allowing interoperability with the computer on which it runs. In simpler terms, JVM acts as a computer inside a computer, which is meant specifically for running Java programs.

Note

It is common for servers to have many JVMs in execution simultaneously.

Up in the hierarchy of stock Java technologies is the JRE. The JRE is a collection of programs that contains the JVM and also many libraries/class files that are needed for the execution of programs on the JVM (via the java command). It includes all the base Java classes (the runtime) as well as the libraries for interaction with the host system (such as font management, communication with the graphical system, the ability to play sounds, and plugins for the execution of Java applets in the browser) and utilities (such as the Nashorn JavaScript interpreter and the keytool cryptographic manipulation tool). As stated before, the JRE includes the JVM.

At the top layer of stock Java technologies is the JDK. The JDK contains all the programs that are needed to develop Java programs, and it's most important part is the Java Compiler (javac). The JDK also includes many auxiliary tools such as a Java disassembler (javap), a utility to create packages of Java applications (jar), system to generate documentation from source code (javadoc), among many other utilities. The JDK is a superset of the JRE, meaning that if you have the JDK, then you also have the JRE (and the JVM).

But those three parts are not the entirety of Java. The ecosystem of Java includes a very large participation of the community, which is one of the reasons for the popularity of the platform.

Note

Research into the most popular Java libraries that are used by the top Java projects on GitHub (according to research that has been repeated in 2016 and 2017) showed that JUnit, Mockito, Google's Guava, logging libraries (log4j, sl4j), and all of Apache Commons (Commons IO, Commons Lang, Commons Math, and so on), marked their presence, together with libraries to connect to databases, libraries for data analysis and machine learning, distributed computing, and almost anything else that you can imagine. In other words, for almost any use that you want to write programs to, there are high chances of an existing library of tools to help you with your task.

Besides the numerous libraries that extend the functionality of the stock distributions of Java, there is a myriad of tools to automate builds (for example, Apache Ant, Apache Maven, and Gradle), automate tests, distribution and continuous integration/delivery programs (for example, Jenkins and Apache Continuum), and much, much more.

 

Our First Java Application


As we briefly hinted before, programs in Java are written in source code (which are plain text, human-readable files) that is processed by a compiler (in the case of Java, javac) to produce the Java bytecode in class files. The class files containing Java bytecode are, then, fed to a program called java, which contains the Java interpreter/JVM that executes the program that we wrote:

Figure 1.2: The process of compilation in Java

Syntax of a Simple Java Program

Like all programming languages, the source code in Java must follow particular syntaxes. Only then, will the program compile and provide accurate results. Since Java is an object-oriented programming language, everything in Java is enclosed within classes. A simple Java program looks similar to this:

public class Test { //line 1
    public static void main(String[] args) { //line 2
        System.out.println("Test"); //line 3
    } //line 4
} //line 5

Every java program file should have the same name as that of the class that contains main (). It is the entry point into the Java program.

Therefore the preceding program will compile and run without any errors only when these instructions are stored in a file called Test.java.

Another key feature of Java is that it is case-sensitive. This implies that System.out.Println will throw an error as it is not capitalized correctly. The correct instruction should be System.out.println.

main() should always be declared as shown in the sample. This is because, if main() is not a public method, it will not be accessed by the compiler, and the java program will not run. The reason main() is static is because we do not call it using any object, like you would for all other regular methods in Java.

Note

We will discuss these the public and static keywords later in this book, in greater depth.

Comments are used to provide some additional information. The Java compiler ignores these comments.

Single line comments are denoted by // and multiline comments are denoted by /* */.

Exercise 1: A Simple Hello World Program

  1. Right-click the src folder and select New | Class.

  2. Enter HelloWorld as the class name, and then click OK.

  3. Enter the following code within the class:

    public class HelloWorld{    
    public static void main(String[] args) {  // line 2
            System.out.println("Hello, world!");  // line 3
        }
    }
  4. Run the program by clicking on Run | Run 'Main'.

    The output of the program should be as follows:

    Hello World!

Exercise 2: A Simple Program for Performing Simple Mathematic Operations

  1. Right-click the src folder and select New | Class.

  2. Enter ArithmeticOperations as the class name, and then click OK.

  3. Replace the code inside this folder with the following code:

    public class ArithmeticOperations {
        public static void main(String[] args) {
                System.out.println(4 + 5);
                System.out.println(4 * 5);
                System.out.println(4 / 5);
                System.out.println(9 / 2);
        }
    }
  4. Run the main program.

    The output should be as follows:

    9
    20
    0
    4

    In Java, when you divide an integer (such as 4) by another integer (such as 5), the result is always an integer (unless you instruct the program otherwise). In the preceding case, do not be alarmed to see that 4 / 5 gives 0 as a result, since that's the quotient of 4 when divided by 5 (you can get the remainder of the division by using a % instead of the division bar).

    To get the result of 0.8, you would have to instruct the division to be a floating-point division instead of an integer division. You can do that with the following line:

    System.out.println(4.0 / 5);

    Yes, this does mean, like most programming languages, there is more than one type of number in Java.

Exercise 3: Displaying Non-ASCII Characters

  1. Right-click the src folder and select New | Class.

  2. Enter ArithmeticOperations as the class name, and then click OK.

  3. Replace the code in this folder with the following code:

    public class HelloNonASCIIWorld {
        public static void main(String[] args) {
                System.out.println("Non-ASCII characters: ☺");
                System.out.println("∀x ∈ ℝ: ⌈x⌉ = −⌊−x⌋");
                System.out.println("π ≅ " + 3.1415926535); // + is used to concatenate 
        }
    }
  4. Run the main program.

    The output for the program should be as follows:

    Non-ASCII characters: ☺
    ∀x ∈ ℝ: ⌈x⌉ = −⌊−x⌋
    π ≅ 3.1415926535

Activity 1: Printing the Results of Simple Arithmetic Operations

To write a java program that prints the sum and the product of any two values, perform the following steps:

  1. Create a new class.

  2. Within main(), print a sentence describing the operation on the values you will be performing along with the result.

  3. Run the main program. Your output should be similar to the following:

    The sum of 3 + 4 is 7
    The product of 3 + 4 is 12

    Note

    The solution for this activity can be found on page 304.

Getting Input from the User

We previously studied a program that created output. Now, we are, going to study a complementary program: a program that gets input from the user so that the program can work based on what the user gives the program:

import java.io.IOException; // line 1

public class ReadInput { // line 2
    public static void main(String[] args) throws IOException { // line 3
        System.out.println("Enter your first byte");
        int inByte = System.in.read(); // line 4
        System.out.println("The first byte that you typed: " + (char) inByte); // line 5
        System.out.printf("%s: %c.%n", "The first byte that you typed", inByte); // line 6
    } // line 7
} // line 8

Now, we must dissect the structure of our new program, the one with the public class ReadInput. You might notice that it has more lines and that it is apparently more complex, but fret not: every single detail will be revealed (in all its full, glorious depth) when the time is right. But, for now, a simpler explanation will do, since we don't want to lose our focus on the principal, which is taking input from the user.

First, on line 1, we use the import keyword, which we have not seen yet. All Java code is organized in a hierarchical fashion, with many packages (we will discuss packages in more detail later, including how to make your own).

Here, hierarchy means "organized like a tree", similar to a family tree. In line 1 of the program, the word import simply means that we will use methods or classes that are organized in the java.io.Exception package.

On line 2, we, as before, create a new public class called ReadInput, without any surprises. As expected, the source code of this program will have to be inside a source file called ReadInput.java.

On line 3, we start the definition of our main method, but, this time, add a few words after the closing parentheses. The new words are throws IOException. Why is this needed?

The short explanation is: "Because, otherwise, the program will not compile." A longer version of the explanation is "Because when we read the input from the user, there may be an error and the Java language forces us to tell the compiler about some errors that our program may encounter during execution."

Also, line 3 is the line that's responsible for the need of the import in line 1: the IOException is a special class that is under the java.io.Exception hierarchy.

Line 5 is where the real action begins: we define a variable called inByte (short for "byte that will be input"), which will contain the results of the System.in.read method.

The System.in.read method, when executed, will take the first byte (and only one) from the standard input (usually, the keyboard, as we already discussed) and give it back as the answer to those who executed it (in this case, we, in line 5). We store this result in the inByte variable and continue the execution of the program.

With line 6, we print (to the standard output) a message saying what byte we read, using the standard way of calling the System.out.println method.

Notice that, for the sake of printing the byte (and not the internal number that represents the character for the computer), we had to use a construct of the following form:

  • An open parenthesis

  • The word char

  • A closing parenthesis

We use this before the variable named inByte. This construct is called a type cast and will be explained in much more detail in the lessons that follow.

On line 7, we use a different way to print the same message to the standard output. This is meant to show you how many tasks may be accomplished in more than one way and that there is "no single correct" way. Here, we use the System.out.println function.

The remaining lines simply close the braces of the main method definition and that of the ReadInput class.

Some of the main format strings for System.out.printf are listed in the following table:

Table 1.1: Format strings and their meaning

There are many other formatting strings and many variables, and you can find the full specification on Oracle's website.

We will see some other common (modified) formatted strings, such as %.2f (which instructs the function to print a floating-point number with exactly two decimal digits after the decimal point, such as 2.57 or -123.45) and %03d (which instructs the function to print an integer with at least three places possibly left filled with 0s, such as 001 or 123 or 27204).

Exercise 4: Reading Values from the User and Performing Operations

To read two numbers from the user and print their product, perform the following steps:

  1. Right-click the src folder and select New | Class.

  2. Enter ProductOfNos as the class name, and then click OK.

  3. Import the java.io.IOException package:

    import java.io.IOException;
  4. Enter the following code within the main() to read integers:

    public class ProductOfNos{
    public static void main(String[] args){
    System.out.println("Enter the first number");
    int var1 = Integer.parseInt(System.console().readLine());
    System.out.println("Enter the Second number");
    int var2 = Integer.parseInt(System.console().readLine());
  5. Enter the following code to display the product of the two variables:

    System.out.printf("The product of the two numbers is %d", (var1 * var2));
    }
    }
  6. Run the program. You should see an output similar to this:

    Enter the first number
    10
    Enter the Second number
    20
    The product of the two numbers is 200

Well done, this is your first Java program.

 

Packages


Packages are namespaces in Java that can be used to avoid name collisions when you have more than one class with the same name.

For example, we might have more than one class named Student being developed by Sam and another class with the same name being developed by David. We need a way to differentiate between the two classes if we need to use them in our code. We use packages to put the two classes in two different namespaces.

For example, we might have the two classes in two packages:

  • sam.Student

  • david.Student

The two packages look as follows in File Explorer:

Figure 1.3: Screenshot of the sam.Student and david.Student packages in File Explorer

All the classes that are fundamental to the Java language belong to the java.lang package. All the classes that contain utility classes in Java, such as collections, classes for localization, and time utilities, belong to the java.util package.

As a programmer, you can create and use your own packages.

Rules to Follow When Using Packages

Here are a few rules to be considered while using packages:

  • Packages are written in lowercase

  • To avoid name conflicts, the package name should be the reverse domain of the company. For example, if the company domain is example.com, then the package name should be com.example. So, if we have a Student class in that package, the class can be accessed with com.example.Student.

  • Package names should correspond to folder names. For the preceding example, the folder structure would be as follows:

    Figure 1.4: Screenshot of the folder structure in File Explorer

To use a class from a package in your code, you need to import the class at the top of your Java file. For example, to use the Student class, you would import it as follows:

import com.example.Student;
public class MyClass {

}

Scanner is a useful class in the java.util package. It is an easy way of inputting types, such as int or strings. As we saw in an earlier exercise, the packages use nextInt() to input an integer with the following syntax:

sc = new Scanner(System.in);
int x =  sc.nextIn()

Activity 2: Reading Values from the User and Performing Operations Using the Scanner Class

To read two numbers from the user and print their sum, perform the following steps:

  1. Create a new class and enter ReadScanner as the class name

  2. Import the java.util.Scanner package

  3. In the main() use System.out.print to ask the user to enter two numbers of variables a and b.

  4. Use System.out.println to output the sum of the two numbers.

  5. Run the main program.

    The output should be similar to this:

    Enter a number: 12
    Enter 2nd number: 23
    The sum is 35.  

Note

The solution for this activity can be found on page 304.

Activity 3: Calculating the Percent Increase or Decrease of Financial Instruments

Users expect to see the daily percentage of increase or decrease of financial instruments such as stocks and foreign currency. We will ask the user for the stock symbol, the value of the stock on day 1, the value of the same stock on day 2, calculate the percent change and print it in a nicely formatted way. To achieve this, perform the following steps:

  1. Create a new class and enter StockChangeCalculator as the class name

  2. Import the java.util.Scanner package:

  3. In the main() use System.out.print to ask the user for the symbol of the stock, followed by the day1 and day2 values of the stock.

  4. Calculate the percentChange value.

  5. Use System.out.println to output the symbol and the percent change with two decimal digits.

  6. Run the main program.

    The output should be similar to:

    Enter the stock symbol: AAPL
    Enter AAPL's day 1 value: 100
    Enter AAPL's day 2 value: 91.5
    AAPL has changed -8.50% in one day.

    Note

    The solution for this activity can be found on page 305.

 

Summary


This lesson covered the very basics of Java. We saw some of the basic features of a Java program, and how we can display or print messages to the console. We also saw how we can read values using the input consoles. We also looked at packages that can be used to group classes, and saw an example of Scanner in java.util package.

In the next lesson, we will cover more about how values are stored, and the different values that we can use in a Java program.

About the Authors

  • Gazihan Alankus

    Gazihan Alankus holds a PhD in computer science from Washington University in St. Louis. Currently, he is an assistant professor at the Izmir University of Economics in Turkey. He teaches and conducts research on game development, mobile application development, and human-computer interaction. He is a Google developer expert in Dart and develops Flutter applications with his students in his company Gbot, which he founded in 2019.

    Browse publications by this author
  • Rogério Theodoro de Brito

    Rogério Theodoro de Brito has a bachelor's degree in computer science and a master's degree in computational biology, both from the University of São Paulo, Brazil. Academically, he is a free/open source software (FOSS) enthusiast and teaches various subjects in computer science and IT at the Mackenzie Presbyterian University in São Paulo, Brazil. He was the technical reviewer of Packt's edX E-Learning Course Marketing. After completing his master's degree, he started his role as an academic instructor and has been working with many languages, such as C, C++, Java, C, Perl, and Python. He writes, co-writes, and maintains a number of projects with two of the most prominent learning platforms, coursera-dl and edx-dl, and is dedicated to helping users of Massive Open Online Courses (MOOCs) download materials for their study from MOOC platforms. He is very excited by using the Java language to build Android applications.

    Browse publications by this author
  • Basheer Ahamed Fazal

    Basheer Ahamed Fazal works as a technical architect at a renowned Software as a Service-based product company in India. He had advanced his career with technology organizations such as Cognizant, Symantec, HID Global, and Ooyala. He has seasoned his programming and algorithmic abilities by solving complex problems around agile product development, including those to do with microservices, Amazon Web Services, Google Cloud-based architectures, application security, and big data- and AI- driven initiatives. Apart from his technical career, he has emerged as a professional trainer and has conducted various training sessions on Java, Python, application security, machine learning, and more. He holds a bachelor's degree in electronics and communication engineering from Anna University, Chennai, and has a Scrum Master Certification from Scrum Alliance.

    Browse publications by this author
  • Vinicius Isola

    Vinicius Isola has a diverse background with a bachelors' degree in physics from the University of Campinas. In 1999, he started learning how to program ActionScript, when Macromedia Flash was taking over the internet. In 2002, while taking a 10-month course on Visual Basic, he used it to build a simulation of life using Cellular Automata combined with Genetic Algorithms for his scientific initiation program at university. At the beginning of 2005, he got his first job in the computer world at a call center. He was then promoted to a data support position where he learned a lot about SQL and databases. Also in 2005, he decided to learn Java and took a 5-day course at Sun Microsystems. After that, he started using Java to build tools to help him at work, automating multiple workflows and saving him a lot of time, freeing up more time to learn new technologies.

    In 2007, he got his first software engineering job at IBM, working with Java and Apache Struts. Between 2008 and 2010, he worked for multiple consulting companies, gaining a lot of experience on distributed systems. In mid-2010, he started building a Java course, which drove him to start his own programming school in the beginning of 2011. In mid-2011, he had to shut down his school and go back to working full-time as a software engineer.

    At the end of 2011, he moved to Boston, Massachusetts, and since then has worked for multiple companies, including Amazon, HubSpot, and Panorama Education. During this time, he has worked with many programming languages, databases, and technologies, including Android, Javascript, Node.js, Python, Ruby on Rails, MySQL, PostgreSQL, Apache Kafka, and Apache HBase. Nowadays, he works as a full-time software engineer at Everbridge and spends his spare time learning new programming languages, such as Go, and building tools to help developers implement powerful continuous integration and continuous deployment of automated pipelines.

    Browse publications by this author
  • Miles Obare

    Miles Obare leads the data engineering team at Betika, a Nairobi-based sports betting firm. He works on building real-time, scalable backend systems. Formerly, he worked as a data engineer for a fintech start-up, where his role involved developing and deploying data pipelines and machine learning models to production. He holds a degree in electrical and computer engineering and often writes about distributed systems.

    Browse publications by this author

Latest Reviews

(1 reviews total)
Excelente material y bien distribuido en el libro

Recommended For You

Learn Java 12 Programming

A comprehensive guide to get started with Java and gain insights into major concepts such as object-oriented, functional, and reactive programming

By Nick Samoylov
Hands-On Design Patterns with Java

Understand Gang of Four, architectural, functional, and reactive design patterns and how to implement them on modern Java platforms, such as Java 12 and beyond

By Dr. Edward Lavieri
Expert Python Programming - Third Edition

Refine your Python programming skills and build professional grade applications with this comprehensive guide

By Michał Jaworski and 1 more
The JavaScript Workshop

Cut through the noise and get real results with a step-by-step approach to beginner JavaScript development

By Joseph Labrecque and 7 more