Basic Java Questions & Answers (Part 1) - Type-Casting

Firas — Thu, 22 Feb 2024 12:22:21 +0000

I’ve compiled a list of questions and answers about fundamental topics in Java that I believe every Java developer should be aware of. This is part 1, covering the concepts of type-casting, upcasting and downcasting.

What is type-casting?

it refers to the process of converting from one data type to another.

What are the conditions for type-casting?

To convert between data types:

the data types must be compatible. We can convert an integer to a float or vice versa, but we can't convert between an integer and a String. A compile error will be thrown in this case.
The data type that we convert into must be larger than the original data type. Otherwise, Java will complain. However, this is still possible with a workaround, which we will discuss in the next section.

What are the categories of type-casting?

There are two types of type-casting:

Widening conversion (implicit casting): If we cast a smaller data type to a larger one, Java compiler will automatically perform the casting. For example, if we want to convert from an integer to a double, we only need to assign the integer value to a double because integers are smaller (32 bits) than doubles (64 bits), so there is no risk of data loss after conversion. Here's a code snippet to demonstrate this:
```
double number = 10;      //output = 10.0, which is a double
```
We declared a double variable and assigned to it an integer value of 10. Since an integer is smaller than a double, the double will easily have more than enough room to store that value.
Narrowing conversion (explicit casting): If we cast a larger data type to a smaller one, Java compiler will complain and will not perform the conversion. For instance, attempting to cast a double to an integer will trigger a compile error. To solve this, we can explicitly cast the value to the smaller data type using the casting operator ():
```
int number = (int) 10.50;  //output = 10, which is an integer
```
Contrary to the previous example, the double value of 10.50 is assigned to an integer. Without an explicit operator, a portion of data would be lost since it's larger than what an integer can hold. So we use the casting operator (int) next to the double value so that it gets converted and stored as an integer.

Type-casting with primitive types vs reference types

type-casting not only works works on primitive types, but on reference types as well, although in slightly different ways due to the inherent difference between primitive and reference type variables.

What is Upcasting?

Upcasting is a process of implicitly casting a subclass to a superclass. It is closely related to inheritance.

Before we further discuss this, let's look an example:

public class Vehicle {
    private String name;

    public Vehicle() {}

        public void driveVehicle() {
            System.out.println("vehicle");
        }
}

public class Car extends Vehicle {
    private String model;

    public Car() {
        super();
    }

        public void driveCar() {
            System.out.println("car");
        }

    public String getModel() {
        return model;
    }
}

As you can see, there are two classes, Vehicle and Car. The Car class extends or inherits Vehicle. In this scenario, when we create an object of type Car, we can either assign it to a reference of type Car class like so:

Car car = new Car();

Or assign it to a reference of type Vehicle, which is the superclass:

Vehicle car = new Car();

This is an example of upcasting where the compiler implicitly casts the subclass to the superclass.

Using upcasting, we can access all methods defined in the superclass from the subclass but we're restricted from calling the methods in the sublcass itself.

If we attempt to call a method in the subclass based on the last example, the compiler will complain:

Vehicle vehicle = new Car();
// vehicle.getModel();    Cannot resolve method 'getModel' in 'Vehicle'

What is Downcasting?

Downcasting is the reverse of upcasting. It’s a process of casting from the superclass to subclass.

Let’s modify the previous example:

// Upcasting
Vehicle vehicle = new Car();

// Downcasting
if(vehicle instanceof Vehicle) {
    Car car = (Car) vehicle;
    car.driveCar();
}

We use instanceof to check if the vehicle reference is an instance of Vehicle class before explicitly downcasting using the (Car) operator. This is a way to prevent ClassCastException at runtime.

Downcasting is particularly useful in cases where we have an instance of a superclass but we need to use the fields and methods of a subclass. Since we can only access superclass fields and methods in this scenario, downcasting is an approach to solve this problem.

There you have it. This is part one of the series of Java questions and answers. I hope what we've discussed so far was helpful. Stay tuned for part two.

How to survive as a junior developer

Firas — Thu, 01 Feb 2024 12:20:14 +0000

Starting a career in programming can feel quite challenging, whether you are a graduate or a professional from another field who decided to try something new. There are plenty of tips for junior developers all over the internet in blogs, articles and Twitter threads, but there is no harm in sharing some tips from my perspective. After all, I've learned a lot throughout my own journey and I would like to share what helped me grow as a developer. So let's talk about it:

Make sure you’re comfortable with the fundamentals of the programming language. Understanding fundamental concepts will make it easier to learn and understand more advanced topics.
Always seek help from colleagues and seniors at work. Never feel embarrassed to ask questions because developers never really stop asking and learning no matter how many years of experience they have.
Always work on your skills. You shouldn’t count too much on the help of others whenever you face a problem or something that you do not understand because as a developer, you need to have good skills such as searching for solutions and analyzing the logic behind the code. This doesn’t contradict the first advice because there are times when you should seek advice and times when depending on yourself is better.
Don’t learn many things all at once. Trust me, I’ve done that and it had some negative impact on me. Instead, focus on what is relevant to your work. You can allocate some other time for other tools or languages that you’re interested in.
Learn by doing, not watching. As a junior developer, you should still be spending some time on tutorials, provided that you always practice what you learn.
Work on side projects. This will expose you to more coding and will force you to practice what you learn at work or in tutorials.
Time management is important. Divide the time of your day between your work, learning and other aspects of your life.
Don’t be afraid to make mistakes. Everyone makes mistakes. Mistakes are a crucial part of the learning process. I’ve learned a lot from mistakes, even the small ones.
It is okay to use google to search or ChatGPT for solutions. In fact, it is well known that developers share problems and solutions online and you’ll likely come across a solution for your problem.
If you’re working remotely, work harder. As a remote developer, you would be restricted to online communication, thus lowering the chances of learning from seniors compared to working in the office, so whenever you connect with them, try to extract as much knowledge as possible. The advantage of remote work, on the other hand, is that you get more freedom compared to your colleagues, so utilize that to learn and hone your skills.
Lastly, think aloud while you code. In other words, provide a commentary to yourself while you code. Explain the thought process in real time.

That's it. I hope you find these tips useful in your career and learning journey. Feel free to comment and share tips of your own.