There are multiple ways to handle that.

Class Number {

   static Int inc(Int n) {
      return n+1
   }

}

import static Number.inc

Class Tracker {

    Integer height = 0;

    incHeight() {
        this.height = inc(this.height)
    }

}

class Tracker extends Numbers {

    Integer height = 0;

    incHeight() {
        this.height = this.inc(this.height)
    }

}

Or

interface Number {

   default Int inc(Int n) {
      return n+1
   }

}

class Tracker implements Numbers {

    Integer height = 0;

    incHeight() {
        this.height = this.inc(this.height)
    }

}

Or my pick

class Number { //or extend the Integer class and add your methods

    int num = 0;

    inc() { 
     this.num +=1
  
     }

}

class Tracker { Number trackingId; }

class Building { Number height; }

t = Tracker()

t.height.inc()

b = Building()

b.height.inc()

All OOP does is really give you a way to group state and methods, how you use it is up to you. There is a reason almost all big software is written this way and not in Lisp.

Do you see the problem? What you wrote is the problem with oop. Gotta tear your whole program apart and rewrite it. You had to create new things and rewrite your methods.

With functional you don’t rewrite. You recompose what you already have.

It means oop is not modular. You didn’t create modules that can be reused. Nothing could be reused so you had to reconfigure everything.

Take a look at the Interable interfae in Java if you want some good examples of reusable functions.

It enables map, filter, stream, reduce, groupby, etc on lists, sets, etc

or collections class which gives sort, min, max, replaceAll, etc