Variables, Data Types, and Operators

Welcome to our lesson on variables, data types, and operators in Java! As a JavaScript developer, you’ll find some familiar concepts here, but also some exciting new ones. Let’s dive in and explore how Java handles these fundamental programming elements.

Static Typing vs Dynamic Typing

One of the most significant differences you’ll encounter is Java’s static typing system. Unlike JavaScript’s dynamic typing, Java requires you to declare the type of each variable explicitly. This approach has its advantages:

// Java
int age = 30;
String name = "Alice";

// JavaScript equivalent
let age = 30;
let name = "Alice";

While it might seem more verbose at first, static typing helps catch errors early and can lead to more robust code.

Primitive Types

Java has eight primitive types, which are the building blocks for all other data types:

  1. byte: 8-bit integer
  2. short: 16-bit integer
  3. int: 32-bit integer
  4. long: 64-bit integer
  5. float: 32-bit floating-point
  6. double: 64-bit floating-point
  7. boolean: true or false
  8. char: 16-bit Unicode character

Here’s how you might use these:

byte smallNumber = 127;
int regularNumber = 1000000;
long bigNumber = 1234567890L; // Note the 'L' suffix for long literals
float decimalNumber = 3.14f; // Note the 'f' suffix for float literals
double preciseDecimal = 3.14159265359;
boolean isJavaFun = true;
char letter = 'A';

In JavaScript, you typically use number for all numeric types and boolean for true/false values. The concept of char doesn’t exist in JavaScript; you’d use a single-character string instead.

Variable Declaration and Initialization

In Java, you can declare and initialize variables separately or in one line:

// Declaration and initialization in separate steps
int count;
count = 10;

// Declaration and initialization in one line
String message = "Hello, Java!";

This is similar to JavaScript, but remember that in Java, you can’t change the type of a variable once it’s declared.

Type Inference with var (Java 10+)

Starting from Java 10, you can use the var keyword for local variable type inference:

var name = "Alice"; // Inferred as String
var age = 30; // Inferred as int

This might look familiar to JavaScript’s let, but remember that Java is still statically typed. The type is inferred at compile-time and can’t be changed later.

Operators in Java

Many operators in Java work similarly to JavaScript:

// Arithmetic operators
int sum = 5 + 3;
int difference = 10 - 4;
int product = 6 * 7;
int quotient = 20 / 4;
int remainder = 15 % 4;

// Comparison operators
boolean isEqual = (5 == 5);
boolean isNotEqual = (5 != 3);
boolean isGreater = (10 > 5);
boolean isLessOrEqual = (7 <= 7);

// Logical operators
boolean andResult = true && false;
boolean orResult = true || false;
boolean notResult = !true;

One key difference is that Java doesn’t have the === and !== operators. In Java, == compares primitives by value and objects by reference.

Conclusion

In this lesson, we’ve explored how Java handles variables, data types, and operators. While there are similarities with JavaScript, Java’s static typing and primitive types offer a different approach to managing data in your programs.

In our next lesson, we’ll dive into control structures and functions in Java, building on what we’ve learned here. You’ll see how Java’s approach to these fundamental programming concepts compares to what you’re familiar with in JavaScript. Get ready to expand your programming toolkit even further!

Previous Lesson Next Lesson