What is the biggest drawbacks if I were to create type of everything, instead of using Strings and primitive types?

Normally it would look like:

```
String name = person.getName();
int age = person.getAge();

```

But now "everything" is objectified, you seldom handle Strings (unless you need specific String manipulation).

```
Name name = person.getName();
Age age = person.getAge();

```

Where `Name` and `Age` would be (in this example) simple container classes:

```
public class Name {

    private final String name;

    public Name(final String name) {
        this.name = name;
    }

    @Overide
    public String toString() {
        return name;
    }

}

```

However, in the future, they can have more more methods and validations, etc.

But the bottom line is that you basically create types for everything.

I know this makes the code more type safe, but what are the biggest drawbacks for this kind of code convention?