In the previous chapter, you learned about the ArrayList class. The LinkedList class is almost identical to the ArrayList:
// Import the LinkedList class
import java.util.LinkedList;
public class Main {
public static void main(String[] args) {
LinkedList<String> cars = new LinkedList<String>();
cars.add("Volvo");
cars.add("BMW");
cars.add("Ford");
cars.add("Mazda");
System.out.println(cars);
}
}
The ArrayList class is a resizable array, which can be found in the java.util package.
The difference between a built-in array and an ArrayList in Java, is that the size of an array cannot be modified (if you want to add or remove elements to/from an array, you have to create a new one). While elements can be added and removed from an ArrayList whenever you want. The syntax is also slightly different: Continue reading Java ArrayList
Java does not have a built-in Date class, but we can import the java.time package to work with the date and time API. The package includes many date and time classes. For example:
| Class | Description |
|---|---|
LocalDate |
Represents a date (year, month, day (yyyy-MM-dd)) |
LocalTime |
Represents a time (hour, minute, second and nanoseconds (HH-mm-ss-ns)) |
LocalDateTime |
Represents both a date and a time (yyyy-MM-dd-HH-mm-ss-ns) |
DateTimeFormatter |
Formatter for displaying and parsing date-time objects |
If you don’t know what a package is, read our Java Packages Tutorial.
The Scanner class is used to get user input, and it is found in the java.util package.
To use the Scanner class, create an object of the class and use any of the available methods found in the Scanner class documentation. In our example, we will use the nextLine() method, which is used to read Strings: Continue reading Java User Input (Scanner)
An enum is a special “class” that represents a group of constants (unchangeable variables, like final variables).
To create an enum, use the enum keyword (instead of class or interface), and separate the constants with a comma. Note that they should be in uppercase letters:
enum Level {
LOW,
MEDIUM,
HIGH
}
You can access enum constants with the dot syntax:
Level myVar = Level.MEDIUM;
Enum is short for “enumerations”, which means “specifically listed”.
Another way to achieve abstraction in Java, is with interfaces.
An interface is a completely “abstract class” that is used to group related methods with empty bodies:
// interface
interface Animal {
public void animalSound(); // interface method (does not have a body)
public void run(); // interface method (does not have a body)
}To access the interface methods, the interface must be “implemented” (kinda like inherited) by another class with the implements keyword (instead of extends). The body of the interface method is provided by the “implement” class: Continue reading Java Interface
Data abstraction is the process of hiding certain details and showing only essential information to the user.
Abstraction can be achieved with either abstract classes or interfaces (which you will learn more about in the next chapter).
The abstract keyword is a non-access modifier, used for classes and methods:
In Java, it is also possible to nest classes (a class within a class). The purpose of nested classes is to group classes that belong together, which makes your code more readable and maintainable.
To access the inner class, create an object of the outer class, and then create an object of the inner class: Continue reading Java Inner Classes
Polymorphism means “many forms”, and it occurs when we have many classes that are related to each other by inheritance.
Like we specified in the previous chapter; Inheritance lets us inherit attributes and methods from another class. Polymorphism uses those methods to perform different tasks. This allows us to perform a single action in different ways.
For example, think of a superclass called Animal that has a method called animalSound(). Subclasses of Animals could be Pigs, Cats, Dogs, Birds – And they also have their own implementation of an animal sound (the pig oinks, and the cat meows, etc.): Continue reading Java Polymorphism
In Java, it is possible to inherit attributes and methods from one class to another. We group the “inheritance concept” into two categories:
To inherit from a class, use the extends keyword.
In the example below, the Car class (subclass) inherits the attributes and methods from the Vehicle class (superclass): Continue reading Java Inheritance