How to Handle two different Objects for same Function

I have either one of following Objects, ObjOne and ObjTwo, going into my function, both sharing similar getters/setters.

Currently I have an intermediary, a mapper, used across internal methods, but there might be a cleaner way to do this without a mapper but lacking specific syntax.

public String mapper(Object obj){

   Map<String, String> map = new HashMap<>();
   
   if(obj instanceof ObjOne){
      ObjOne obj1 = (ObjOne)obj;
      map.put("firstKey", obj1.getFirstValue());
   }
   else if(obj instanceof ObjTwo){
      ObjTwo obj2 = (ObjTwo)obj
      map.put("firstKey", obj1.getFirstValue());
   }

   return secondFunction(map);
      
}

private String secondFunction(Map<String, String> map){
   
   return thirdFunction(map.get("firstKey"));
}

Is there such syntax for (ObjOne || ObjTwo)obj).getFirstValue() to feed into thirdFunction herein?

Edit: I imported these Objects, so I can't declare a parent class for them, they do share getters/setters that are convenient for my scenario.

A more OO approach is to compose the objects you don't control within a new object that you do control. Then write your API in terms of the object you control.

final class ObjOne {
    String getFirstValue() {
        return "foo";
    }
}

final class ObjTwo {
    String getFirstValue() {
        return "bar";
    }
}

class MyAdapter {
    final Map<String, String> map = new HashMap<>();

    MyAdapter(ObjOne o1) {
        this(o1.getFirstValue());
    }

    MyAdapter(ObjTwo o2) {
        this(o2.getFirstValue());
    }

    MyAdapter(String firstKey) {
        map.put("firstKey", firstKey);
    }
}

public String secondFunction(MyAdapter adapter) {
    return thirdFunction(adapter.map.get("firstKey"));
}

One suggestion don't pass Object instead do something like this create a base model use here polymorphism. for example.

abstract class BaseObj {

    abstract public String getFirstValue();
}

class ObjOne extends BaseObj{


    @Override
    public String getFirstValue() {
        return  "something useful";
    }
}

class ObjTwo extends BaseObj{


    @Override
    public String getFirstValue() {
        return  "something useful";
    }
}

not sure what is the use case here but you can always mold accordingly.

public String mapper(BaseObj obj){
    Map<String, String> map = new HashMap<>();
    map.put("firstKey", obj.getFirstValue()); //common function call
    return secondFunction(map);

}

private String secondFunction(Map<String, String> map){

    return thirdFunction(map.get("firstKey"));
}

private String thirdFunction(String firstKey) {
    return null;
}