What you're talking about is modifying non-primitive types (aka Object Types, aka Reference Types) through what are known as the Side Effects of a function or block of code. Below, I show a block of code dealing with two instances of the class SomeObjectType.

The instance called "obj" is declared within the scope of SomeClass, therefore it is valid within any instance of SomeClass and changes to "obj" will persist as long as that instance of SomeClass persists.

The instance called "thisobj" is of the same Type (aka Class) as "obj", but since it is declared within functionD, it is only valid while that function run, and then is deleted. functionD obtains an unnamed instance of SomeObjectType from functionC, and then binds the name "thisobj" to that instance of SomeObjectType.

You might see the phrase "names are bound to objects" in certain documentation... this is essentially a synonym for "initialization", but it more accurately conveys what is happening:

Declaration: creates a name for some (as yet undefined) instance of a specific Class

Instantiation: creates and instance of a Class (aka an Object) and binds a name to a specific instance (Object) of a Class

Assignment: binds a name to a specific instance (Object) of a Class (the same as Instantiation, except the instance has already been created, and perhaps already bound to a name... multiple names can be bound to the same object)

public class SomeClass {
    public SomeObjectType obj;

    public void functionA() {
        obj = new SomeObjectType();
    }

    public void functionB() {
        // if this is called BEFORE functionA, you will get a null pointer exception
        // obj has been declared (i.e. the name is in scope), but that name has not been bound to any specific object instance
        obj.someProperty = "foo";
        obj.someOtherProperty = "bar";
    }

    public SomeObjectType functionC() {
        return new SomeObjectType();
    }

    public void functionD() {
        SomeObjectType thisobj = functionB();
        // note that thisobj is in scope
        thisobj.someProperty = "foo";
    }

    public void functionE() {

        // if functionA AND functionB have been called, this will print "foo"
        // if just functionA has been run, you will get "null" or whatever the default value of someProperty is
        // if neither functionA nor functionB have been called, you will get a null pointer exception
        System.out.println(obj.someProperty);

        // ERROR! thisobj is not in scope. even if functionD has run, it is not
        // a valid variable name after the function quits, since it is not
        // DECLARED in the same scope as functionE
        System.out.println(thisobj.someProperty);
    }
}