PHP.CodeCompared.To/Java

Java has no top-level code: every statement lives inside a method, every method inside a class. The runtime calls public static void main(String[] args) as the entry point. Output goes through System.out.println, which adds a newline. This boilerplate is the price of Java's structure — far heavier than PHP's bare echo.

Java source is compiled by javac to portable .class bytecode, which the JVM then runs (and JIT-compiles to native code while running). Unlike PHP's direct interpretation, there is a build step — but the JVM is one of the most heavily optimized runtimes in existence.

Java's printf mirrors PHP's, with one quirk: use %n for a platform-correct newline rather than \n. Java has no string interpolation, so you build strings with + concatenation, which auto-converts the int to text here.

Every variable has a static type, declared explicitly or inferred with var (Java 10+) for locals. There is no $ sigil. Unlike PHP's dynamic $count, the type is fixed at compile time, so reassigning a String to count would not compile.

Java splits numbers into primitives (int, double, boolean, …) that hold raw values and their object wrappers (Integer, Double, …). Autoboxing converts between them, but the distinction matters: only objects can be null or stored in a generic collection — and wrapper equality has a famous trap (see the gotchas).

A trap for PHP developers: 7 / 2 is integer division giving 3 when both operands are int, unlike PHP where / always yields a float. Make one operand a double for 3.5. There is no ** operator — use Math.pow, which returns a double.

Strings are objects with chainable methods (text.trim().toUpperCase()) instead of the free functions strtoupper(trim($text)). The names are camelCase, and the methods return new strings because Java strings are immutable — see the next example.

Java String objects are immutable: every "modification" allocates a new string. Repeated concatenation in a loop is therefore wasteful, so the idiom is StringBuilder, a mutable buffer you append to and then convert with toString(). PHP's .= has no such concern.

Java's text blocks (triple-quoted, Java 15+) are the counterpart to PHP heredoc/nowdoc for multi-line strings, with automatic indentation stripping. They have no interpolation, so combine them with .formatted(...) (an instance form of String.format) to splice in values.

PHP's one array type splits into typed collections: List<T> for ordered sequences and Map<K, V> for key-value data, each generic over its element types. Note List.of / Map.of create immutable collections, and you access elements with .get(...), not [].

A mutable ArrayList exposes methods — add, size, contains — replacing array_push, count, and in_array. Sorting goes through the Collections utility class. The new ArrayList<>(...) diamond infers the type argument from the variable's declaration.

Key existence is containsKey and the safe lookup with a default is getOrDefault — the parallel of PHP's array_key_exists and ??. Iterating uses entrySet() with getKey() / getValue(); a HashMap has no guaranteed order, so this sums rather than relying on insertion order.

The structure matches PHP almost exactly. The only differences are the keyword else if (two words, not elseif) and that a condition must be a real boolean — Java has no truthiness, so if (someString) does not compile.

Java's switch expression (arrow form) returns a value like PHP's match, with no fall-through and multiple labels per arm (case 6, 7). Use yield inside a { } block arm for multi-statement cases. The compiler checks exhaustiveness when switching over an enum or sealed type.

The classic three-part for is identical to PHP's. The enhanced for — for (String letter : items) — is Java's foreach, using a colon instead of as and a declared loop-variable type (or var).

Java has no free functions: a "function" is a static method on a class. The return type comes before the name and each parameter is typed. Because main is static, helper methods it calls directly must also be static (or belong to an instance).

Java supports overloading: several methods may share a name if their parameter types differ, and the compiler picks the right one by the argument types. PHP forbids this — you would use a union-typed parameter and branch at runtime, as on the left.

Java's varargs int... numbers collect trailing arguments into an array — the direct parallel of PHP's ...$numbers. A varargs parameter must be the last one, and you can also pass an existing array where it is expected.

A Java constructor is a method named after the class — there is no __construct and no PHP-style constructor property promotion, so you declare the field and assign this.name explicitly. Member access uses a dot, and this (no $) is the receiver.

Inheritance uses extends and abstract as in PHP, with super(...) calling the parent constructor (PHP's parent::__construct). The @Override annotation is optional but recommended — it makes the compiler verify you really are overriding a parent method.

Interfaces use implements just like PHP, but Java interfaces may also carry default methods with a body (since Java 8) — here describe() — letting an interface supply shared behavior, which PHP achieves with its separate "trait" feature.

Static fields and methods belong to the class, accessed with a plain dot (Counter.increment()) rather than PHP's :: scope-resolution operator and self::. A static member is shared across all instances, exactly as in PHP.

A Java record (Java 16+) generates a constructor, accessors (a.x()), value-based equals/hashCode, and a readable toString from one line — comparable to PHP 8.1's readonly class but with far less boilerplate. Records are immutable. Note value equality uses .equals(), not == (see the gotchas).

A sealed interface or class names exactly which types may extend it via permits — a closed hierarchy the compiler knows is complete. PHP has no equivalent. Combined with records and a switch, sealed types let the compiler verify you have handled every case, as in the next section.

Generics are a real compile-time feature: <T> before the return type declares a type parameter, so firstItem(List.of(10)) returns an Integer and the string call a String. PHP can only approximate this with @template docblocks read by Psalm or PHPStan. (Java erases generics at runtime — see the gotchas.)

Classes can be generic: Box<T> holds a typed value, giving compile-time safety PHP's mixed cannot. A bounded wildcard like Box<? extends Number> accepts any numeric box, letting the method call Number methods on the contents. This is the machinery behind List<T> and Map<K, V>.

Pattern matching for instanceof tests the type and binds a typed variable in one step: value instanceof String text gives you text already typed as String, with no cast. It replaces PHP's is_string-then-use pattern and the manual casts older Java required.

Switching over a sealed type with record patterns (Java 21+) both matches the variant and deconstructs it — case Circle(double radius) binds the component directly. Because the type is sealed, the compiler knows the switch is exhaustive and needs no default. PHP's match can only compare scalar values.

Java enums are full classes that can carry fields and methods, much like PHP 8.1 enums. A method can switch (this) over the cases, and switching over an enum is checked for exhaustiveness. To attach backing values, you give the enum a constructor and a field rather than the : string syntax PHP uses.

The Stream API chains filter and map left-to-right and is lazy until a terminal operation like collect runs — far more readable than PHP's inside-out array_map(array_filter(...)). The lambdas (n -> n * 2) are Java's arrow functions.

Streams provide aggregate operations — sum, max, min, average, count — and a general reduce (the counterpart to array_reduce) taking a seed and a combiner. The Integer::intValue and Integer::compare are method references, Java's shorthand for a lambda that just calls one method.

The Collectors.groupingBy collector turns the manual "build a map of lists" loop into one declarative call, and passing TreeMap::new keeps the keys sorted (PHP's ksort). This composability — collectors nested inside collectors — is the Stream API's real power.

The try/catch/finally structure matches PHP's, and you read the message with getMessage(). IllegalArgumentException here is an unchecked exception (extends RuntimeException), so it need not be declared — unlike checked exceptions, covered next.

Java's distinctive checked exceptions have no PHP equivalent: a method that can throw a checked exception (anything not a RuntimeException) must declare it with throws, and the compiler forces every caller to either catch it or declare throws in turn. It makes failure paths explicit, at the cost of more ceremony.

Try-with-resources declares a resource in parentheses after try; any object implementing AutoCloseable is closed automatically when the block exits, even on an exception. It replaces the manual try ... finally fclose() dance — the parallel of the using statement in C#.

The single most common Java bug for newcomers: for objects, == compares reference identity (are these the same object?), not value. To compare values you must call .equals(). PHP's == compares values, so this distinction catches every PHP developer at least once — always use .equals() for strings and objects.

A subtle consequence of ==-as-identity: Java caches boxed Integer values from −128 to 127, so == on small numbers accidentally works, while the same code on larger numbers fails. Never compare boxed numbers with == — use .equals() or unbox to int. PHP's value semantics sidestep this entirely.

Any object reference can be null, and calling a method on it throws a NullPointerException — Java has no ?-> operator. The modern idiom is Optional<T>, whose map and orElse chain safely, roughly matching PHP's ?-> and ??. Many APIs still return raw nullable references, so null-checking remains a fact of life.

Java's int is a fixed 32-bit signed type that silently wraps around on overflow — Integer.MAX_VALUE + 1 becomes the most negative int, with no error and no promotion. Use long (64-bit) for larger values, or Math.addExact to throw on overflow. PHP's ints are 64-bit and promote to float instead.