Is this valid variant of builder pattern?

Let's assume we have User and UserBuilder class in their own package, that we want to be immutable and at consistent state before initialization, defined as follows:

public class User {

private final String firstName, lastName;
private final int age;
private final String adress;
  protected User(UserBuilder buildUser) { //constructor acessible only in same packge
      this.firstName = buildUser.lastName;
      this.lastName = buildUser.lastName;
      this.age = buildUser.age;
      this.adress = buildUser.adress;
  }

  public String getFirstName() {
  return firstName;
  }
  ... // and other getters
}

And the builder class as follows:

public class UserBuilder {

    public final String firstName;
    public final String lastName;
    public int age;
    public String adress;

    public UserBuilder(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public UserBuilder setAge(int age) {
        this.age = age;
        return this;
    }

    public UserBuilder setAdress(String adress) {
        this.adress = adress;
        return this;
    }

    public UserBuilder getUser() {
        return this;
    }

    public User build() {
        return new User(getUser());
    }
}

And finally we build the user in class that is in another package:

  public static void main(String[] args) {
        User user = new UserBuilder("John","Doe")
                .setAge(22)
                .build();   
       // User user = new User(UserBuilder) //error protected constructor                
    }  

Is this considered safe and good design? If not, why?