How to wait loading of data in TypeScript observer?

You should generalize getClassesAndSubjects adjusting it to return a value, in this case an Observable. Instead of having it call subscribe, it will now be composable.

getClassesAndSubjects(school: number, whenDate: string) {
  return this.classService.getClassesAndSubjects(school, whenDate)
    .map(data => {
      if ('errors' in data) { // type guard
        throw Error(data.errors);
      }
      return data;
    });
}

const c = new ClassObj();

c.getClassesAndSubjects(1,'2018-01-01').subscribe(classesAndSubjects => {
  this.classesAndSubjects = classesAndSubjects;
}, handleError);


// outside of the class!
export function handleError(error: any) {
  console.log("ERROR loading GetClassesAndSubjects: " + error);
}

Note that getClasses was a pointless method, it may as well not exist and if it were to, a get property would be cleaner. Also, it has a most confusing name in the context of its sister method getClassesAndSubjects given what it returns. So I just removed the method.

Addendum:

async/await having been brought up and being an elegant way to lift writing asynchronous programming from the tedium and unmaintainability of callbacks, I'll just show how this would work with async/await over standard Promises.

import 'rxjs/add/operator/toPromise';
// ...

async getClassesAndSubjects(school: number, whenDate: string) {
  const data = await this.classService.getClassesAndSubjects(school, whenDate)
    .toPromise();
  if ('errors' in data) { // type guard
    throw Error(data.errors);
  }
  return data;
}

// ...

const c = new ClassObj();

try {
  this.classesAndSubjects = await this.getClassesAndSubjects(1,'2018-01-01');
}
catch (e) {
  handleError(e);
}

The advantages are strong, being able to use standard syntactic constructs without any adjustments, maintaining the clarity of linear control flow over, and above all dealing with regular values and exceptions the whole way down. There is no need for the subscribe vs return dilemma with this approach as everything is compositional. In that way we sidestep the entire reason for the question. Sure it's less powerful, but its also simpler.

getClassesAndSubjects performs an asynchronous operation, so, when you call getClasses the operation has not yet finished. You need to return an observable or a promise from getClassesAndSubjects:

public getClassesAndSubjects(school: number, whenData: string): Observable<your-type> {
    const observable = this.classService.GetClassesAndSubjects(school, whenDate);
    observable.subscribe(data => {
      if (!data.hasOwnProperty('errors')) {
        this.classesSubjects = data;

      }
    }, error => {
      console.log("ERROR loading GetClassesAndSubjects: " + error);
    });

    return observable;
}

Now:

a.getClassesAndSubjects(1,'2018-01-01').subscribe(value => {
     a.getClasses();
});

If a function performs asynchronous operations, any action that depends of the results of such operation, must take into account that, and wait for the operation to complete.

You can also use async/await. In this case, the asynchronous function must return a Promise:

public async getClassesAndSubjects(school: number, whenData: string): Promise<your-type> {
    const observable = this.classService.GetClassesAndSubjects(school, whenDate);
    observable.subscribe(data => {
      if (!data.hasOwnProperty('errors')) {
        this.classesSubjects = data;

      }
    }, error => {
      console.log("ERROR loading GetClassesAndSubjects: " + error);
    });

    return observable.toPromise();
}

And now, wherever you want to use it:

async function whatever() {
    // ...
    await a.getClassesAndSubjects(1, '2018-01-01');
    a.getClasses();
}

By doing this, the execution of function whatever gets suspended until the promise returned by a.getClassesAndSubjects is fulfilled or rejected, so, when a.getClasses is executed, the data is there. Of course, the fact that this function gets 'suspended' does not mean the application get suspended, too. What happens is that, under the hood, the async function gets broken into parts, and the second part (after the await) gets executed inside a Promise.then method. But the compiler doest that for you, so the solution is much more elegant.

You need to remember that any function in which you use await must be declared as async.