43. Xlinting default constructors We know that a Java class with no explicit constructor gets automatically an “invisible” default constructor for setting default values of the instance variables. The following House class falls in this scenario: public class House { private String location; private float price; …} If this is exactly what we wanted then […]
Category: Defining a day period
Revealing a common mistake with Strings 3 – Objects, Immutability, Switch Expressions, and Pattern Matching
WARNING 4! NPE when accessing index value of null array/collection Consider the following code written by a client of ChainSaw: ChainSaw myChainSaw = ChainSaw.initChainSaw(“QWE-T800”);ChainSaw[] friendsChainSaw = new ChainSaw[]{ ChainSaw.initChainSaw(“Q22-T450”), ChainSaw.initChainSaw(“QRT-T300”), ChainSaw.initChainSaw(“Q-T900”), null, // ops! ChainSaw.initChainSaw(“QMM-T850”), // model is not supported ChainSaw.initChainSaw(“ASR-T900”)};int score = myChainSaw.performance(friendsChainSaw); Creating an array of ChainSaw was quite challenging in this example. […]
Taking on the hard way to discover equals() – Objects, Immutability, Switch Expressions, and Pattern Matching
50. Taking on the hard way to discover equals() Check out the following code: Integer x1 = 14; Integer y1 = 14;Integer x2 = 129; Integer y2 = 129;List<Integer> listOfInt1 = new ArrayList<>( Arrays.asList(x1, y1, x2, y2));listOfInt1.removeIf(t -> t == x1 || t == x2);List<Integer> listOfInt2 = new ArrayList<>( Arrays.asList(x1, y1, x2, y2));listOfInt2.removeIf(t -> t.equals(x1) || […]
Rewriting equals() via type patterns for instanceof – Objects, Immutability, Switch Expressions, and Pattern Matching
55. Rewriting equals() via type patterns for instanceof It is not mandatory to rely on instanceof for implementing the equals() method, but it is a convenient approach to write something as follows: public class MyPoint { private final int x; private final int y; private final int z; public MyPoint(int x, int y, int z) […]
Tackling type patterns for instanceof and streams – Objects, Immutability, Switch Expressions, and Pattern Matching
57. Tackling type patterns for instanceof and streams Let’s consider a List<Engine> where Engine is an interface implemented by several classes such as HypersonicEngine, HighSpeedEngine, and RegularEngine. Our goal is to filter this List and eliminate all RegularEngine that are electric and cannot pass our autonomy test. So, we can write a code as follows: […]
Adding guarded pattern labels in switch – Objects, Immutability, Switch Expressions, and Pattern Matching
59. Adding guarded pattern labels in switch Do you remember that type patterns for instanceof can be refined with extra boolean checks applied to the binding variables to obtain fine-grained use cases? Well, we can do the same for the switch expressions that use pattern labels. The result is named guarded pattern labels. Let’s consider […]
Dealing with completeness (type coverage) in pattern labels for switch – Objects, Immutability, Switch Expressions, and Pattern Matching
61. Dealing with completeness (type coverage) in pattern labels for switch In a nutshell, switch expressions and switch statements that use null and/or pattern labels should be exhaustive. In other words, we must cover with explicit switch case labels all the possible values. Let’s consider the following example: class Vehicle {}class Car extends Vehicle {}class […]
Dealing with completeness (type coverage) in pattern labels for switch 3 – Objects, Immutability, Switch Expressions, and Pattern Matching
This code compiles! There is no default label and no total pattern but the switch expression covers all possible values. How so?! This interface is declared as sealed via the sealed modifier: public sealed interface ClassDescextends ConstantDesc, TypeDescriptor.OfField<ClassDesc> Sealed interfaces/classes were introduced in JDK 17 (JEP 409) and we will cover this topic in chapter […]
Understanding the unconditional patterns and nulls in switch expressions – Objects, Immutability, Switch Expressions, and Pattern Matching
62. Understanding the unconditional patterns and nulls in switch expressions Let’s imagine that we use JDK 17 and we have the following code: private static String drive(Vehicle v) { return switch (v) { case Truck truck -> “truck: ” + truck; case Van van -> “van: ” + van; case Vehicle vehicle -> “vehicle: ” […]
Defining a day period – Working with Date and Time
63. Defining a day period Let’s imagine that we want to say hello to a friend from another country (different time zone) via a message such as Good morning, Good afternoon, and so on based on his local time. So, having access to AM/PM flags is not enough, because we consider that a day (24 […]