Will this be considered a deep copy return?

I created a Entity class - "User" with Generated Value - "Id".

Below is the snippet of the code:

@Transient
private User u;

public User(){
    super();
}

public User(String name, Integer age, Occupation oc, Integer salary){
    this.name = name;
    .
    .
    .
}

//Getters
    public Integer getUniqueID() {
    u = new User(this.name, this.age, this.oc, this.salary);
    return u.uniqueID;
}

public String getName() {
    u = new User(this.name, this.age, this.oc, this.salary);
    return u.name;
}
.
.
.

Will this be considered a deep copy return? Any encapsulation breach?

To make a deep copy of a User you would need to copy the Occupation as well; the other fields are irrelevant. It is often a good idea to include a copy constructor in your class:

public User(User other){
    this(other.name, other.age, other.oc, other.salary);
}

You can make it a "deep" copy constructor like this:

public User(User other){
    this(other.name,
            other.age,
            other.oc == null ? null : new Occupation(other.oc),
            other.salary);
}

Alternatively, you could create the copy of the Occupation in the other constructor:

public User(String name, Integer age, Occupation oc, Integer salary){
    this.name = name;
    this.age = age;
    this.oc = oc == null ? null : new Occupation(oc),
    this.salary = other.salary;
}

You can also add method to make a copy of a user:

public User copy() {
    return new User(name, age, oc, salary);
}

And and another one to make a deep copy:

public User deepCopy() {
    return new User(name, age, oc == null ? null : oc.deepCopy(), salary);
}

assuming you have a similar deepCopy method in class Occupation.

It's sometimes a good idea to copy objects in getters and setters:

public Occupation getOccupation() {
    return oc == null ? null : new Occupation(oc);
}

public void setOccupation(Occupation oc) {
    this.oc = oc == null ? null : new Occupation(oc);
}

Of course, making a copy of an object has a cost, and sometimes you actually don't want to copy objects, but rather reference the same object from two or more objects. You have to decide which fields have to be copied, and how deep.

Note that immutable objects don't ever need to be copied, and should be used as much as possible.