Mercury13

class C {
  public static class Inner1 {
    private static int x = 0;
  }  
  public static class Inner2 {
    static void foo() {
      ++Inner1.x;
    }
  }
}

class D extends C.Inner1 {
   static void bar() {
     //++x;  не работает
   }
}

#include <iostream>
#include <concepts>

class A {};
class AA : public A {
public:
    static constexpr const char* AData = "AA";
};

class B {};
class BB : public B {
public:
    static constexpr const char* BData = "BB";
};

// Через концепции
template <class T>
concept ASon = std::derived_from<T, A>;

template <class T>
concept BSon = std::derived_from<T, B>;

template <ASon T>
void foo(const T&) {
    std::cout << T::AData << std::endl;
}

template <BSon T>
void foo(const T&) {
    std::cout << T::BData << std::endl;
}

template <class T> constexpr bool FALSE_V = false;

// Через if consexpr
template <class T>
void bar(const T&) {
    if constexpr (std::is_base_of_v<A, T>) {
        std::cout << T::AData << std::endl;
    } else if constexpr (std::is_base_of_v<B, T>) {
        std::cout << T::BData << std::endl;
    } else {
        static_assert(FALSE_V<T>);
    }
}

int main()
{
    foo(AA());
    foo(BB());
    bar(AA());
    bar(BB());
    return 0;
}

// Пишет вот такой код
class A implements Serializable { }
class B extends A {}

// А читает вот такой
class A implements Serializable { }
class AHalf extends A {
  private void readObjectNoData() throws ObjectStreamException {}
}
class B extends AHalf {}