A text file can be created with the following command:

File file = new File("file.txt");

In this case, a text file named file.txt will be created, and the developer is free to write text to that file.

FileWriter fw = new FileWriter("file.txt");
BufferedWriter bw = new BufferedWriter(fw);
bw.write("Hello, World!");
fw.close();
bw.close();

The library also enables developers to read text files, line by line.

FileReader fr = new FileReader("file.txt");
BufferedReader br = new BufferedReader(fr);
String line = br.readLine(); // reads a single line
fr.close();
br.close();

It is important to note that the close() method must be invoked once the file handling operation is over. If they aren’t closed, then the application will eventually crash due to resource mismanagement. Additionally, the example above is still vulnerable to crashing despite calling close() explicitly — if an exception occurs while the BufferedReader is reading a line, then the file handlers will never close.

Fortunately, Java offers a syntax that will automatically invoke this close() method for the developer, regardless of whether or not exceptions occur.

try (FileWriter fw = new FileWriter("file.txt", true); BufferedWriter bw = new BufferedWriter(fw)) {
    bw.write("Hello, World!");
} catch (IOException e) {
    e.printStackTrace();
}

Text File Handling was originally published in Introduction to Application Development with Java on Medium, where people are continuing the conversation by highlighting and responding to this story.

Exceptions are data structures that are generated when the intended functionality is disrupted. They are used to identify issues, provide users with messages, provide developers with information about the problematic event and so on.

For example, an IndexOutOfBoundsException can be triggered by attempting to access the tenth element of an array with nine elements.

int indexOfTenthElement = 9; // arrays start with index 0

System.out.println(arrayWithNineElements[indexOfTenthElement]); // throws an IndexOutOfBoundsException

An exception that is not handled will crash an application.

Handling Exceptions

Exceptions can be handled with try / catch blocks — these keywords allow developers to provide the software with multiple paths of execution, depending on whether or not a specific exception occurs.

try {
  int indexOfTenthElement = 9;
  System.out.println(arrayWithNineElements[indexOfTenthElement]); // throws an IndexOutOfBoundsException
} catch (IndexOutOfBoundsException ex) {
  System.out.println("The index was out of bounds with message: ".concat(ex.getMessage()));
}

An additional finally keyword can be used to execute additional statements, regardless of whether or not the catch block is invoked.

try {
  int indexOfTenthElement = 9;
  System.out.println(arrayWithNineElements[indexOfTenthElement]); // throws an IndexOutOfBoundsException
} catch (IndexOutOfBoundsException ex) {
  System.out.println("The index was out of bounds with message: ".concat(ex.getMessage()));
} finally {
  System.out.println("Finished executing!");
}

Exception Handling was originally published in Introduction to Application Development with Java on Medium, where people are continuing the conversation by highlighting and responding to this story.

public static void main(String args[]) {
    String bossFirstName = "Michael";
    String bossLastName = "Scott";
    String bossFullName = getFullName(bossFirstName, bossLastName);
}

static String getFullName(String firstName, String lastName) {
    return firstName.concat(" ").concat(lastName);
}

A parameter is a variable that indicates an input value that is expected by a method upon invocation. In this case, String firstName and String lastName are the parameters in the second example; as long as two pieces of text are supplied (regardless of their variable names), the method will be able to combine the text with a space in between.

An argument is the actual value that is passed into a method. In the example above, getFullName(bossFirstName, bossLastName) is the moment that bossFirstName and bossLastName become arguments; those variables are passed into the method, and the associated values will be combined with a space between them.

A signature is the name of the method, combined with the list of accepted parameters. The getFullName method has a signature of getFullName(String firstName, String lastName). This signature is used to indicate a method’s uniqueness to the compiler, so that when it is invoked with arguments the compiler knows which code to execute.

A return type indicates the type of data that the method returns.

static String getFullName(String firstName, String lastName) {
    return firstName.concat(" ").concat(lastName);
}

The code above defines a method that returns a new String, which is equal to the first argument combined with the second. This returned String can be stored in a new variable.

String bossFullName = getFullName(bossFirstName, bossLastName);

Some methods will not return any values, such as methods that print text. These are marked with a void return type.

public static void main(String args[]) {
    String name = "Bob";
    print(name);
}

static void print(String text) {
    System.out.println(text); // nothing returned; text is printed and method terminates
}

As indicated above, a returned value needs to be stored in another variable or passed directly into another method. Otherwise, the value disappears.

getFullName(bossFirstName, bossLastName); // does nothing

String bossFullName = getFullName(bossFirstName, bossLastName); // stores the full name in a variable
System.out.println(getFullName(bossFirstName, bossLastName)); // prints the full name

Writing Methods was originally published in Introduction to Application Development with Java on Medium, where people are continuing the conversation by highlighting and responding to this story.

An array is a data structure that holds a group of values with the same type as one another.

int[] integers = new int[]{2, 4, 5}; // 'integers' contains 2, 4 and 5

The number of values that an array can hold must be defined when the array is instantiated.

int[] integers = new int[]{2, 4, 5}; // compiler knows size is three
int[] integers = int[3]; // compiler knows size is three

The values within an array are called elements, and each element is referenced by specifying it’s position in sequence, known as the index.

int[] integers = new int[]{2, 4, 5};

System.out.println(integers[0]); // prints 2
System.out.println(integers[2]); // prints 5
System.out.println(integers[3]); // throws an error
integers[1] = 6;
System.out.println(integers[1]); // prints 6 instead of 4

Aside from the basic functionality that comes with all complex types in Java, an array cannot perform operations of its own.

Collections

A collection is a data type in Java that serves as a version of an array with build in functionality.

Collection<String> names = new ArrayList<>(); // collection instantiation syntax will be explained later

names.add("Bob");
names.add("Jon");
System.out.println(names.get(1)); // prints 'Jon'

Collection size is not fixed upon instantiation and it is able to perform its own operations, but it is slightly less efficient than an array in terms of element modification and access.

Types of Collections

Elements are inserted, accessed and removed depending on the specific type of collection. Each has its own advantages and challenges.

Lists

List<String> names = new ArrayList<>();

• Position based on number, starting at zero (called an index)
• Allows for access by index
• Allows for duplicates
• Performance slows as size grows

Sets

Set<String> uniqueNames = new HashSet<>();

• Position based on number, starting at zero
• Does not allow for access by index
• Does not allow duplicates
• Performance slows as size grows

Queues

Queue<String> foodOrders = new ArrayDeque<>();

• The first element in is the first element out
• Allows for duplicates
• Performance slows as size grows

Maps

Map<String, String> employeeJobTitles = new HashMap<>();
employeeJobTitles.put("Bob", "Software Developer");

System.out.println(employeeJobTitles.get("Bob")); // prints 'Software Developer'

• Key based (stores job titles based on the employee’s name)
• Keys cannot be duplicated, but values can (only one Bob, but can have multiple Software Developers)
• Performance isn’t impacted on the same scale as other collection types as the size grows
• Even though Map is a part of the collection framework, it does not inherit the default Collection functionality.

Arrays and Collections was originally published in Introduction to Application Development with Java on Medium, where people are continuing the conversation by highlighting and responding to this story.

If / Else Statements

Consider a message that is printed on the screen of an ATM — if someone withdraws twenty dollars from a total of forty dollars, they’ll see a success message. If they try to withdraw twenty dollars from a balance of ten dollars, they will receive an error message for over drafting.

int total = 100;
int withdrawAmount = 20;

if (withdrawAmount > total) {
  System.out.println("Error: Overdraft"); // withdrawl greater than total
} else if (withdrawAmount < total) {
  System.out.println("Success: Withdrew from account"); // withdrawl less than total
} else {
  System.out.println("Withdrew all cash"); // withdrawl equal to total
}

Because withdrawAmount is less than total, the first print statement is skipped, the second print statement is executed, and the third print statement is ignored entirely.

Switch Statements

The switch statement can also be used to determine the flow of control based on a value.

int number = 6;

switch (number) {
    case 1:
        // execute logic if the input value matches the first expected value
        break;
    case 5:
        // execute logic if the input value matches the second expected value
        break;
    default:
        // execute logic if the input value does not match any expected values
}

The default statement is optional, and in this case it will be executed since number is not equal to one or five.

Looping

A loops is used to conditionally and repeatedly execute a block of code. The continue statement skips the remainder of the current loop iteration, and the break statement terminates the associated loop entirely.

The ‘while’ Loop

A while loop is a combination of a conditional statement and a block of code; upon invocation, the block of code will be repeatedly executed until the condition is met.

int i = 0;
while (i < 10) {
    System.out.println(i); // prints ten integers, 0 - 9
    i++; // if this line was missing, the loop would execute forever because 'i' would always be less than ten
}

The while loop checks the condition before executing the logic. The do while loop checks the condition after executing the logic.

int i = 0;
do {
    System.out.println(i); // prints ten integers, 0 - 9
    i++;
} while (i < 10);

The ‘for’ Loop

A for loop is used to execute a block of code a pre determined number of times.

for (int num = 3; num > 1; num--) { // start with 3, execute when greater than one, subtract one every time
  System.out.println(num); // prints 3, 2
}

The control variable (in the case above, named num) can be decalred within the loop such as the example above, or outside of the loop.

int num = 3;
for (num; num > 1; num--) { // start with 3, execute when greater than one, subtract one every time
  System.out.println(num); // prints 3, 2
}

Control Flow was originally published in Introduction to Application Development with Java on Medium, where people are continuing the conversation by highlighting and responding to this story.

Arithmetic operators are symbols that are used to carry out arithmetic, assignment, relational and logical operations. Assignment operators change the value of the variable on the left side of the equation. Relational operators compare values to one another (== is equals, != is not equals) and logical operators are used to evaluate some combination of boolean conditions.

• Arithmetic: +, -, *, /
• Assignment: =, +=, *=
• Relational: >, <, ==, !=, >=, <=
• Logical: &, &&, |, ||

int total = 3 + 4; // assignment and arithmetic, value is 7
int total += 1; // assignment, value is 8
boolean totalIsLarge = total >= 10; // assignment and relational, value is false
boolean totalIsSmallAndGreaterThanOne = total < 10 && total > 1; // assignment, relational, logical and relational

Operator Precedence

The order of operations, from highest precedence to lowest, is as follows.

• Post-Unary: Operators that are applied after the value they operate on is returned
• Pre-Unary: Operators that are applied before the value they operate on is returned
• Parenthesis: Used to prioritize specific operations over others
• Single Unary: Operates on a single operand, which can be a variable or an expression
• Multiplicative: Multiplication, division and modulus
• Additive: Addition and subtraction
• Relational and Equality: Compares two values to each other
• Logical: Determines a presence of specified conditions
• Ternary: Returns one of two values depending on the outcome of a relational operation
• Assignment: Assigns a value to the variable on the left of the equation

Relational Operators

Relational operators are used to compare two values or expressions and determine their relationship. These operators return a boolean result, either true or false, based on the specified relationship.

boolean firstNumberLessThanOrEqualToSecondNumber = 5 <= 8; // returns true
boolean thirdNumberLessThanOrEqualToFourthNumber = 9 <= 9; // returns true
boolean fourthNumberIsLessThanFirstNumber = 10 < 5; // returns false

Relational operators are also used to compare two values or expressions and determine whether or not they’re equal. These operators return a boolean result, either true or false.

boolean equalToEachOther = 5 == 5; // returns true because they are equal
boolean equalToEachOther = 5 != 4; // returns true because they are not equal

Pre and Post Unary Operators

Pre and post unary operators are responsible for incrementing or decrementing primitive variables values.

double x = 1.5;

++x; // x = 2.5
--x; // x = 1.5

The Math Class

The Math class provides a library of methods that are useful for working with numbers. For example a random double value between 0 and 1 can be generated with the following code:

double value = Math.random(); // can be 0, non inclusive of 1

Another example is the ability to return the minimum or maximum of two values:

int a = 3;
int b = 4;
int minimum = Math.min(a, b); // returns 3

Operators was originally published in Introduction to Application Development with Java on Medium, where people are continuing the conversation by highlighting and responding to this story.

These values are referenced through user defined variables, and can be in one of two states. A declared variable has reserved system memory for the future value, but does not reference an actual value.

String name; // does not assign a value to name; reserves space in memory

An instantiated variable holds an actual value.

String name = "Jim";

Java recognizes two categories of data types; primitive, and complex.

Primitive Data Types

Primitive data types are predefined by the language, and are used to represent ‘simple’ data types such as numbers, characters, etc. The value possesses only state; a value that is of a primitive type cannot perform any operations, but operations can still be applied to the value.

As mentioned previously the value is stored directly in the variable. This location in computer memory is known as the ‘stack’, which is relatively close to the running application for quick access.

Examples of primitive type variable instantiations include:

int age = 22;
char grade = 'A';
double cost = 20.00
boolean isQualified = true;

Complex Data Types

Complex data types are predefined by the language, by libraries and can be defined by developers. They posses behavior in addition to state.

Complex values are stored in a memory location known as the ‘heap’, which lives further from the running application than the stack does. In order to bridge this gap, a reference to the value’s location in the heap is stored within the stack. This reference is known as a ‘pointer’. This can be confirmed by printing the location in memory of objects, which is what Java does by default.

Object firstObject = new Object();
Object copyOfFirstObject = firstObject;
Object secondObject = new Object();

System.out.println(firstObject);
System.out.println(copyOfFirstObject); # prints the same thing as firstObject
System.out.println(secondObject); #does not print the same thing as firstObject, even though both are blank

The String variable is a complex type, used to represent strings of characters (simple text).

String firstName = "Bob";
String lastName = "Doe";
String fullName = firstName.concat(" ").concat(lastName); // firstName is performing an operation

Integral Types

Integral types refer to data types used to store integer values. These data types represent whole numbers, without any fractional or decimal components.

• byte is a sequence of eight bits that can have a value between -128 and 127
• short is a sequence of sixteen bits (2 bytes) with a range between -32,768 and 32,767
• int is a sequence of thirty two bits (4 bytes) with a range between -2,100,000,000 and 2,100,000,000
• long is a sequence of sixty four bits (8 bytes) with a range between -9.2 x ¹⁰¹⁸ and 9.2 x ¹⁰¹⁸

Floating Point Types

Floating-point types are used to represent numbers with a fractional part, including real numbers such as decimal values and scientific notation.

• float is a sequence of thirty two bits (4 bytes) with a range between 1.4 x 10^-45 and 3.4 x 1⁰³⁸
• double is a sequence of sixty four bits (8 bytes) with a range between 4.9 x 10^-324 and 1.8 x 1⁰³⁰⁸

Both the float and the double round the last digit after the decimal point, if the value contains too many digits. A double can store a decimal value that is twice the size (not value) of a float.

The reason that these types have such a large range because of the automatic scientific notation conversion. If the absolute value (not size) is too large, the representation will automatically switch to scientific notation.

The boolean Primitive

The boolean is used to indicate a binary value, and can be only true or false.

boolean isEqual = (1 == 1); // returns true

The char Primitive

The char primitive is used almost exclusively to represent Unicode characters such as a letter, digit, symbol, etc.

char newline = '\n';

Narrowing, Widening and Casting

Narrowing is when a number is converted from a larger data type to a smaller data type.

long theLong = 5L;
int theInt = (int) theLong;

If a number is too large then narrowing will result in a completely different number, in a phenomenon called overflow.

Widening is when a number is converted from a smaller data type to a larger data type.

int theInt = 5;
long theLong = (long) theInt;

Casting is the process of converting on data type to another.

Underscores in Numeric Literals

Underscores can be used almost anywhere within a number; however, they cannot be used at the beginning or the end, nor can they be used immediately before or after a decimal point.

Scientific Notation

In Java, scientific notation can only be used with float and double. A float can have eight digits, a double can have sixteen; any larger numbers will result in an automatic conversion to scientific notation and a loss in precision.

double number = 5.88e12;
float anotherNumber = 5.0e-8f;

Data Types was originally published in Introduction to Application Development with Java on Medium, where people are continuing the conversation by highlighting and responding to this story.

Version Control Locally

Git can be downloaded from https://git-scm.com/downloads. When downloading to Windows, Git Bash must be included as well. This is an alternative to the Command Prompt, that allows developers to execute Git commands.

Open the Git Bash application if the device is Windows, and open the Terminal if the device is a Mac. Create a directory to store projects in, navigate into this directory, create a Java project and navigate into the Java project directory.

>> mkdir projects
>> cd projects

>> mvn archetype:generate -DgroupId=com.example -DartifactId=app-name -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

>> cd app-name

Initialize version control and begin tracking project changes by running the following Git command:

>> git init

Create a file so that Git can ignore unnecessary files while tracking changes.

>> touch .gitignore

Open this file in IntelliJ and paste the following contents:

target/
.idea/
*.iml

The target/ directory should be ignored because it only holds compiled files and an executable, which should be generated from source files every time. The .idea/ directory and .iml files should be ignored because they both contain information specific to each developer’s personal IDE.

Prepare to save all new files to the history of changes stored by Git.

>> git add .

This will add all new files to the staging index; they aren’t formally recorded by Git, but they’re now in a state where they can be saved with the following command:

>> git commit -m "Initial commit"

This will save all of the new files with Git, along with a message that says “Initial commit”.

Any time files or directories are created, updated or deleted, these changes can be saved by adding the files to the staging index and executing a commit command.

Version Control on the Web

Projects that are tracked via version control can be uploaded to or downloaded from web based platforms, such as GitHub and Bitbucket. In order for developer devices to securely communicate with these platforms, a secure connection must be configured between the two.

In IT, a protocol is a set of rules that define how data is transmitted and processed between systems over a network. The type of protocol that these version control platforms require is known as SSH, which stands for Secure Shell. SSH requires messages to be encrypted across the network, so that hackers can’t view sensitive information.

In order to encrypt these messages, a key must be created locally in order to establish an identity. Validate that no key exists by attempting to change into the SSH directory and list the contents. If there is no .ssh directory or there are no contents within the file, then there is no SSH key and one must be created.

>> cd ~/.ssh
>> ls

If an SSH key needs to be created, run the following command:

>> ssh-keygen

This will create a private key to be used locally, and a public key to be used with other websites.

Start the device’s SSH software and add the private key.

>> eval $(ssh-agent)
>> ssh-add ~/.ssh/id_rsa

Print the public key and copy the value.

>> cat ~/.ssh/id_rsa.pub

If the platform is Bitbucket, paste the public key value under Personal BitBucket Settings / SSH Keys and establish an SSH connection with the Bitbucket server.

>> ssh -T git@bitbucket.org

If the platform is GitHub, paste the public key value under Settings / SSH and GPG keys / Add new SSH Key and establish an SSH connection with the GitHub server.

>> ssh -T git@github.com

Summary

• Version control software called Git was downloaded to track changes to projects locally. If the device is not Mac, then Git Bash was also downloaded.
• If an SSH key did not already exist, then public and private keys were both generated.
• The private key was registered with the device’s SSH software.
• The public key was used to establish asecure connection to a web based platform.

Introduction to Version Control was originally published in Introduction to Application Development with Java on Medium, where people are continuing the conversation by highlighting and responding to this story.

In many languages, developers write code according to a specified set of rules within source files. The content of these files can be understood by developers thanks to keywords, numbers and indentation that provide context. When the source files are ready to run as software, they are translated to a file that is no longer readable by humans. This file is known as an executable, and it allows the developer to run their software.

Installing the Java Programming Language

This guide focuses on the Java programming language, as it enables developers to conveniently build enterprise grade software. It is secure, widely supported and there are many existing libraries (pre written code) available for use when developing software.

Java comes with everything required to create and run software. The Java Runtime Environment is the module used to run software, and the Java Development Kit is used to create software. The JRE is included within the JDK.

After creating an Oracle account, Java can be downloaded from https://www.oracle.com/java/technologies/downloads/#jdk17-windows. Once this has been downloaded, two system properties will need to be updated. These properties are known as environment variables, and they will be used to associate keywords with file paths. This allows the system to know where Java is installed, so that it can run the software. Add a System Environment Variable named JAVA_HOME and set it to the file path of the Java install. Then, add the text $JAVA_HOME/bin to the system path variable.

Installing the Maven Build Tool

The next step is to install a piece of software known as Maven. This is a build tool — among other utilities, it is used to configure the way that the project is compiled, the way that the application is named and versioned, and to import additional libraries of code. It can be downloaded from https://maven.apache.org/download.cgi, and requires the configuration of two additional environment variables. The user variable MAVEN_HOME must be set to the path of the Maven install, and the text $MAVEN_HOME/bin should be added to the system Path variable.

Once Maven has been installed, the application can be created by running the following command from the Command Prompt:

mvn archetype:generate -DgroupId=com.example -DartifactId=application-name -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

Installing the IntelliJ Integrated Development Environment

The last step is to download the tool that is used to read and edit code, called an Integrated Development Environment (IDE). There is a robust and free product known as IntelliJ Community Edition that can be downloaded from https://www.jetbrains.com/idea/download/?var=1&section=windows.

Once IntelliJ is running, open the project directory titled application-name. A few additional steps may be necessary to make sure that IntelliJ is configured for the version of Java that is installed. Start by selecting File, Project Structure and validating that the SDK and language level match the desired version of Java. In this case, Java 17.

Navigate to the Modules tab, and make sure the Language level is set.

Finally, select File, Settings, (Build, Execution, Deployment), Compiler and Java Compiler. Make sure that the Target bytecode version is set.

Code can be written in the App.java file. The existing template may have to be expanded by selecting the small arrow.

Now, lines of code can be added in between the braces on lines ten and twelve.

The code can be compiled and executed by pressing the green button on line nine, and the output appears at the bottom of the screen.

Summary

• The Java programming language was installed and two system properties called environment variables were configured.
• The Maven build tool was installed and two environment variables were configured.
• A Java application was created by running a Maven command from the command line.
• The IntelliJ code editor was installed, and the Java version being used by IntelliJ was validated in several places.
• The application code was expanded in the editor and executed.

Configuring a Java Development Environment was originally published in Introduction to Application Development with Java on Medium, where people are continuing the conversation by highlighting and responding to this story.