Java seems redundant for a complete beginner when creates new objects

I'm sorry if this question seems stupid, I'm a complete beginner and the way Java constructs new objects seems redundant for me. Using the rectangle package for example:

import java.awt.Rectangle

Rectangle box = new Rectangle(5,10,20,30)

So why do we write Rectangle twice? just writing

box = new Rectangle(5,10,20,30)

isn't enough? writing this way it's clear that my object will be created from the Rectangle constructor

It's not always redundant to specify both the type of the variable and the class of the object that you instantiate.

The two may be different.

For example, instead of your example, you can write

Shape box = new Rectangle(5,10,20,30);

which allows you to program to the interface (Shape) instead of a specific implementation (Rectangle).

If you want the type of the variable to be the same as the class you instantiate, you can use var as of Java 10:

var box = new Rectangle(5,10,20,30);

Other than that, you have to tell the compiler when you are declaring a new variable.

If you just write

box = new Rectangle(5,10,20,30);

the compiler expects the box variable to already be declared somewhere within the scope of that statement. Adding the type of the variable (or var) lets the compiler know this is a new variable.

The reason you need to write both is a semantic difference.

If you only write box = ..., then you assign a value to a preexisting variable or field called box. But it has to exist in that scope before the assignment!

If you write Rectangle box = ... instead, you define a new variable at that scope and assign it a value.

The reason you can't write Rectangle box = (5, 10, 20, 30); is, that there can potentially be many different Classes that conform to the class Rectangle. The reason is the inherent character of classes in Java, that they are extendible (with a bunch of exceptions). This means that the type of the variable (Rectangle) does not always have to be the very same as the type of the actual object.

I think the important concept to get across here is the distinction between object and variable.

In

    Rectangle box = new Rectangle(5,10,20,30)

the right-hand side, 'new Rectangle...' creates an object, and returns a reference to that object.

The left-hand side, 'Rectangle box', declares a variable that is capable of holding a reference to a Rectangle (or to any other object subclassed from Rectangle, but that's not in this lesson).

These things can stand separately: you can create objects without immediately saving the value in a newly-declared variable; for a hypothetical example, maybe you'd want

    draw(new Rectangle(5,10,20,30));

to create a rectangle, display it somehow, and then you don't need to refer to the rectangle ever again. And likewise you can declare a variable without immediately initializing it to anything.

    Rectangle box;

Of course in this case you'll eventually need to assign a value to box for it to be useful, but it doesn't have to be done on declaration.

And lastly, as mentioned in other answers,

   Rectangle box = …

and

   box = …

are quite different. The first declares a new variable, the second uses an existing variable. If we made the second case an implicit declaration, then you're vulnerable to typing errors: maybe you typed 'b0x' instead of 'box', and now you have a bug in that 'box' did not get the expected value. For this reason, most but not all programming languages require explicit declaration of variables.

And yes, Java is somewhat wordy.

A statement of the form

Foo f = new Bar(....);

says two things. First, it says the type of the variable f is Foo. On the right-hand side, you are saying that you are creating an object of type Bar. This is allowed if Foo is a supertype of Bar. Both variables and objects in Java have type.

Definition of classes and variables are explicit in Java. Also note you can use different implementation of interfaces and or use subclasses. For example you can define an interface which cannot be used stand alone - e.g. java.util.List. Depending in the implementation it'll execute different code under the hood and is replaceable later on (ArrayList vs. LinkedList for example).

In your example you have Rectangle - which is a subclass and also implements interfaces. So all of this would be valid assignments:

Shape        box1 = new Rectangle(5,10,20,30);
Serializable box2 = new Rectangle(5,10,20,30);
Cloneable    box3 = new Rectangle(5,10,20,30);

This makes it easier for future devs to understand which interfaces you developed against, enabling you to replace rectangle later on.

Indeed there's some redundancy compared to some newer languages, but not the non-verbose syntax you suggested has it's downsides by it's own. Definition and assignment have the same syntax. So if you want to create a variable 'box' that is already existing you're assigning a value to the pre-existing variable. In the explicit notiation you create a name clash and get a compiler error:

No compiler error:

Rectangle box; // This is not needed for some languages like JS
...
box = new Rectangle(5,10,20,30);
box = new Rectangle(6,11,21,31);

Compiler error:

Rectangle box = new Rectangle(5,10,20,30);
Rectangle box = new Rectangle(6,11,21,31);

Same problem can be faced with method interfaces. Especially it it's not your code and some poor devs did a bad job in coding and documenting:

Python:

def my_function(name):
    print(name)

Java:

public static void myFunction(String name){
    System.out.print(name);
}

(Please note python supports typing as well, but you are not forced to).

People will argue less code will lead to more visibility and cleaner code, but having worked in many enterprise scale projects I'd pick explicit redundancy over slink and double-functional syntax any time.