Because myMember property is accessed in parent constructor (init() is called during super() call), there is no way how it can be defined in child constructor without hitting a race condition.

There are several alternative approaches.

init hook

init is considered a hook that shouldn’t be called in class constructor. Instead, it is called explicitly:

new B();
B.init();

Or it is called implicitly by the framework, as a part of application lifecycle.

Static property

If a property is supposed to be a constant, it can be static property.

This is the most efficient way because this is what static members are for, but the syntax may be not that attractive because it requires to use this.constructor instead of class name if static property should be properly referred in child classes:

class B extends A {
    static readonly myMember = { value: 1 };

    init() {
        console.log((this.constructor as typeof B).myMember.value);
    }
}

Property getter/setter

Property descriptor can be defined on class prototype with get/set syntax. If a property is supposed to be primitive constant, it can be just a getter:

class B extends A {
    get myMember() {
        return 1;
    }

    init() {
        console.log(this.myMember);
    }
}

It becomes more hacky if the property is not constant or primitive:

class B extends A {
    private _myMember?: { value: number };

    get myMember() {
        if (!('_myMember' in this)) {
            this._myMember = { value: 1 }; 
        }

        return this._myMember!;
    }
    set myMember(v) {
        this._myMember = v;
    }

    init() {
        console.log(this.myMember.value);
    }
}

In-place initialization

A property may be initialized where it’s accessed first. If this happens in init method where this can be accessed prior to B class constructor, this should happen there:

class B extends A {
    private myMember?: { value: number };

    init() {
        this.myMember = { value: 1 }; 
        console.log(this.myMember.value);
    }
}

Asynchronous initialization

init method may become asynchronous. Initialization state should be trackable, so the class should implement some API for that, e.g. promise-based:

class A {
    initialization = Promise.resolve();
    constructor(){
        this.init();
    }
    init(){}
}

class B extends A {
    private myMember = {value:1};

    init(){
        this.initialization = this.initialization.then(() => {
            console.log(this.myMember.value);
        });
    }
}

const x = new B();
x.initialization.then(() => {
    // class is initialized
})

This approach may be considered antipattern for this particular case because initialization routine is intrinsically synchronous, but it may be suitable for asynchronous initialization routines.

Desugared class

Since ES6 classes have limitations on the use of this prior to super, child class can be desugared to a function to evade this limitation:

interface B extends A {}
interface BPrivate extends B {
    myMember: { value: number };
}
interface BStatic extends A {
    new(): B;
}
const B = <BStatic><Function>function B(this: BPrivate) {
    this.myMember = { value: 1 };
    return A.call(this); 
}

B.prototype.init = function () {
    console.log(this.myMember.value);
}

This is rarely a good option, because desugared class should be additionally typed in TypeScript. This also won’t work with native parent classes (TypeScript es6 and esnext target).

One approach you could take is use a getter/setter for myMember and manage the default value in the getter. This would prevent the undefined problem and allow you to keep almost exactly the same structure you have. Like this:

class A {
    constructor(){
        this.init();
    }
    init(){}
}

class B extends A {
    private _myMember;
    constructor(){
        super();
    }
    init(){
        console.log(this.myMember.value);
    }

    get myMember() {
        return this._myMember || { value: 1 };
    }

    set myMember(val) {
        this._myMember = val;
    }
}

const x = new B();

Try this:

class A {
    constructor() {
        this.init();
    }
    init() { }
}

class B extends A {
    private myMember = { 'value': 1 };
    constructor() {
        super();
    }
    init() {
        this.myMember = { 'value': 1 };
        console.log(this.myMember.value);
    }
}

const x = new B();

Super has to be first command. Remeber that typescript is more “javascript with documentation of types” rather than language on its own.

If you look to the transpiled code .js it is clearly visible:

class A {
    constructor() {
        this.init();
    }
    init() {
    }
}
class B extends A {
    constructor() {
        super();
        this.myMember = { value: 1 };
    }
    init() {
        console.log(this.myMember.value);
    }
}
const x = new B();

Do you have to call init in class A?

That works fine, but I don’t know if you have different requirements:

class A {
  constructor(){}
  init(){}
}

class B extends A {
  private myMember = {value:1};
  constructor(){
      super();
      this.init();
  }
  init(){
      console.log(this.myMember.value);
  }
}

const x = new B();

More often than not, you can defer the call of init() to a time just before it is needed by hacking into one of your getters.

For example:

class FoodieParent {
  public init() {
    favoriteFood = "Salad";
  }

  public _favoriteFood: string;
  public set favoriteFood(val) { this._favoriteFood = val; }
  public get favoriteFood() {
    if (!this._favoriteFood) {
      this.init();
    }
    return this._favoriteFood;
  }

  public talkAboutFood() {
    // init function automatically gets called just in time, because "favoriteFood" is a getter
    console.log(`I love ${this.favoriteFood}`);
  }
}

// overloading the init function works without having to call `init()` afterwards
class FoodieChild extends FoodieParent {
  public init() {
    this.favoriteFood = "Pizza"
  }
}

Like this :

 class A
{
     myMember; 
    constructor() {

    }

    show() {
        alert(this.myMember.value);
    }
}

class B extends A {
    public myMember = {value:1};

    constructor() {
        super();
    }
}

const test = new B;
test.show();