This lesson introduces you to the Java language.
it might be tempting to skip this lesson if you've already learned
another language or have learned a bit of Java before, but I go over
some details that many other books and courses skip over. These
details will make it easier to understand how we write programs and
this will in turn help you solve problems more easily.
It is assumed that you are already familiar with the concept
of files and folders/directories, and that you know how to manage
your files and organize them into folders/directories (including
creating directories, copying/moving files, etc). If you are
unfamiliar with these things or need a refresher, watch the following
Java was originally designed as a language that would be embedded in appliances
that would talk to one another. For example, you maybe have heard stories about a
"smart kitchen": You take a bag of frozen peas out of the fridge and place it on
the counter. The fridge notes the bag of peas missing and it updates an electronic
shopping list so you'll know to buy another bag of peas. The counter feels the weight
of something so it reads the bar code and recognizes a bag of frozen peas. It immediately
warms up so that the peas can be defrosted. The microwave remembers that you like to
nuke your peas in a bit of water so it sets the timer and waits for you to put the pot
of peas inside so it can turn itself on. All of these devices mentioned - the fridge,
the counter, the microwave, the electronic shopping list - need to be able to communicate
with each other. In 1991 a team of developers (called the "Green Team" and led by
James Gosling) at Sun developed
Java as part of a special
project that resulted in a device controller called the "*7" (Star Seven). The *7 needed
a robust, platform-independent language but the developers were not satisfied with the
performance of existing languages. Team member James Gosling developed Java to solve the problem.
In order to be able to make appliances work well, the original language was developed
to be small and compact, secure and reliable, and portable. Why?
Small and Compact: Bloated, complex code that required
a lot of space would not fit well with small appliances that have only limited storage space!
Secure and Reliable: You wouldn't want your fridge talking to the neighbor's
fridge about your dieting habits, nor would you want your program to crash, causing the toaster to
Portable: The language had to work on many different types of appliances,
which all might have different machine languages!
is Canadian (from Calgary, Alberta) and was named an Officer of the Order of Canada
in 2007 for his lifetime contributions to computer science. The Order of Canada is the highest honour a
Canadian civilian can receive
and the "Officer" grade is the second highest.
Today these features of Java make it a great tool for writing applications
that must be run on different platforms
A perfect example of this is programs that
a network such as the Internet. The original Java web-based programs were called
but we don't use applets anymore because of changes to browser security.
Many internet applications are not completely run on the server: sometimes
all or portions of an application are downloaded to the user's computer.
If these applications were very large, it would take longer to download,
and most users don't wish to wait a long time for an application to
start working. Furthermore, larger applications take up more memory, which
means less memory for other applications and tasks, and that slows down
applications. The fact that Java is small and compact means that it
won't have excessive download times and won't take up as much memory.
You don't need me to tell you how important security and reliability
is right now with internet applications: we hear stories all the time
on the news and in technical publications about big hacks and security
breaches. A developer wants to be able to write code that makes
their application trustworthy to the users. Java has several
components that make it possible to create secure and reliable
A developer of an application needs to be assured that their application
can run on any kind of machine. Many different kinds of machines and
devices access the internet and use/download internet applications, so
developers need to know that their application can run on any one of
these different devices without any problems. Java makes this easier
because it's portable and platform independent: it can run on any device that
has a Java Virtual Machine (which, as you'll see later, is pretty
standard these days).
Java is Object Oriented
Java is an object oriented programming language. Object Oriented
Programming (OOP) is a method of programming that focuses on
defining classes that model or represent objects
in a system. A class defineds what data or properties an object
has and what behaviours an object can perform. For example, in
an application that kept track of drivers in a ride-sharing app,
a Driver class might define that driver objects have a name,
car make and model, license plate, and current status (available,
completing a trip, not available, etc). A Driver class might
also define that a driver object has behaviours for picking up
a customer, completing a trip, dropping off a customer, changing
their status, or rating a customer.
The Java language already comes with many classes that can
be used as building blocks to create applications. these
classes can also be used to create even more complex building
blocks, which can also be used to create applications.
In this course we will focus on console applications,
which means that our programs won't have a GUI
(Graphical User Interface) component.
Don't be too disappointed about not learning to create user interfaces
right away: it's better to become comfortable and proficient with
the foundations of programming before moving on to UI
programming. You'll learn how to write Java GUI
applications in the UI programming course.
Who invented Java? What was it originally created for?
What are the three characteristics of Java that made is an
excellent language for internet and mobile device programming?
What is OOP?
Versions of Java: Which Should You Use?
There are a few different flavours of Java. These are called APIs,
or Application Program Interfaces. Each API is meant for a specific
The Java APIs contain pre-defined classes and interfaces.
These are the building blocks used to write programs in Java.
The API is always growing and being improved, so you should keep up with any changes
and update when it's necessary for your projects. API Documentation
is the set of documentation (usually it's web-based) that describes the different classes
and what they do. The Java 17 API is at https://docs.oracle.com/en/java/javase/17/docs/api/index.html
and it's a good idea to learn how to use it so you can learn more about the classes
you'll be introduced to.
The Java APIs:
Java SE - Standard Edition: Used for regular desktop applications, and this
is also the foundation for other APIs.
Java EE - Enterprise Edition: Used for web applications that require both
server-side and client-side Java code.
Java ME - Mobile Edition: Used for machines that have limited resources such as smart
devices and tablets
We'll be using Java SE in this course. In term 3, you'll use Java EE. If you
take any courses on mobile development in 3rd year, you'll use Java ME.
The Java SE contains 2 parts:
SDK/JDK - Software/Java Development Kit
Some versions say "SDK", some use "JDK". They mean the same thing!
The current version of Java calls it the JDK.
The JDK includes the tools and utilities used by programmers to make Java programs.
For example: the Compiler, interpreter, debugger, and other programs you'll use in other Java
JRE - Java Runtime Environment
A machine must have a Java runtime environment in order to run Java programs:
Any machine running Java programs must have the JRE.
The JRE contains the JVM (Java Virtual Machine), which is the actual program that
runs Java programs.
The JRE also contains the JFC, or Java Foundation Classes. These are
classes or building blocks that you can use to create applications,
or more complex building blocks for other applications.
The Java Virtual Machine (JVM) mentioned above is what makes Java
portable or platform independent:
if a computer has a Java Virtual Machine, it can run Java programs. Most
operating systems these days come with a JVM installed. Even most modern
browsers come with a JVM embedded within them. Even if you come across
a computer that doesn't have a JVM, you can easily download one for
free from the Java web site.
What are the 3 main Java APIs? What is OpenJDK?
What is the JDK? What is the JRE?
What is a JVM and why is it important?
How we Write Java Programs
So how does the process of writing programs work for Java?
Jav is platform independent.
This means it can run on any platform, regardless of where it was compiled!
How does this work?
Java source code is written and compiled just like a regular language, except
that it isn't compiled into machine code: it's compiled into bytecode.
Bytecode is "not quite machine code" - it can be run on any machine,
as long as that machine has an interpreter. An interpreter
takes a line of bytecode, interprets it into machine code, and then executes that
machine code. Then it reads and interprets the next line of bytecode and
executes it, then the next, etc until it either runs out of bytecode
(your program has finished) or a run-time error occurs (you'll learn more
about runtime errors later in the course). A run-time error causes the
program to stop working, or "crash".
How does this work on different platforms? An interpreter is part of a computer's
Java Virtual Machine or JVM. A JVM is
needed on any machine that wants to run Java programs. So if you write
and compile a Java program on a Linux machine, you can then run that program
on a PC as long as that PC has a JVM. The JVM's interpreter can read the
bytecode and interpret it into the PC's native machine language.
This is why Java is often called and interpreted language:
because the bytecode is interpreted as it's executed rather than a
compiled language, where all the code is compiled into one big block
of machine language and then executed. Think of an interpreted language
like an interpreter that is listening to someone speak and interpreting
that language into another language as it's being spoken (similar to what
you often see at international news conferences or when someone is
interpreting sign language for someone else). A compiled language
would be similar to someone listening to the whole speech and recording it,
and then sitting down and interpreting the entire speech and then
reciting it in a different language, and giving you that audio file
so you can listen to the interpreted version.
When you write Java source code, this code is saved in a file with the
.java file extension. That is then compiled by the compiler program
javac.exe. This javac.exe file is included in the Java installation.
We write or code Java source code in an editor or an IDE (Integrated
Development Environment). In these tutorials, we will use
or IntelliJ IDEA,
but if you prefer something else, that's fine.
A successful compilation creates a bytecode file with the same name
as your source code file, except it has the .class extension instead of
.java. You then execute the bytecode file using the java.exe
interpreter program. The java.exe program is also included when
you install Java on your machine.
Once you are able to successfully compile your code, a Bytecode
file is created. This is the file that can now be run or executed
by the interpreter. An interpreter reads in a line
of bytecode and then executes those instructions. Then it reads the
next line and executes those instructions. It continues until it
runs out of bytecode (in which case your program is finished) or
if it encounters a run-time error or exception (which basically means
your program has crashed due to some unexpected circumstance).
With all of this in mind, we can summarize the creation of a java application into these steps:
Type the source code in an editor (such as Notepad++ or IntelliJ).
Compile the source code into a class file using the Java compiler.
If you are notified of any syntax errors, fix them and repeat step 2.
Run the Java class file using the Java interpreter.
What is meant by "platform independent"? Is Java platform independent?
What is bytecode?
What is an interpreter and what does it do?
What's the difference between an interpreted language
and a compiled language?
In Java, what file extension does a source file have?
What extension does a bytecode file have?
What program file is the Java compiler? What program File
is the Java interpreter?