Does this code use the Proxy or Singleton pattern, or both of them?

public interface SomeObject {
    void process();
}

public class SomeObjectImpl implements SomeObject {
 
    public SomeObjectImpl() {
        ...
    }
     
    @Override
    public void process() {
        ...
    }
}

public class AnotherObject implements SomeObject {
    private SomeObject object;
 
    @Override
    public void process() {
        if (object == null) {
            object = new SomeObjectImpl();
        }
        object.process();
    }
}

I think it's the Singleton pattern because it states that a class must ensure that only a single instance should be created and a single object can be used by all other classes. In the example, when SomeObject is null an instance is created as required.

However, it also looks like the Proxy pattern is used, because SomeObject is the proxy.

Is this code really using both patterns? Or is the Proxy pattern used only?

The Singleton Pattern's purpose is to ensure that only one instance of the singleton class ever exists.

Does the given code ensure that? No, because nothing prevents you from creating as many instances as you like from the two classes SomeObjectImpl and AnotherObject (by just invoking their default constructor).

Hint: See the Wikipedia page on Singleton Pattern for implementation examples in different languages... and once you've seen how to create singletons – then forget about using them in real code, ever – as it's the best way for creating untestable software ⚡ and having global variable(s) ⚡ gluing everything together.

The Proxy Pattern's purpose is to control the access to an object or to provide some additional functionality upon accessing an object.

Does the given code look something like that? Yes.

The two classes SomeObjectImpl and AnotherObject implement the interface SomeObject. That interface (in terms of the Proxy Pattern) represents the Subject providing some action, i.e. the process method. The SomeObjectImpl class is then the acutal implementation; the RealSubject (as named by the Proxy Pattern). While AnotherObject class simply delegates to the actual implemenation SomeObjectImpl, i.e. it's a Proxy.

Given that code, the Proxy's purpose (or additional functionality) is to cache an instance of SomeObjectImpl for subsequent process calls. This makes sense when the object creation is a costly operation. For example, when the process method implementation requires the setup of some external resources or requires "big" upfront memory allocations, ...