Clases

En caso de que queramos poder instanciar una clase, necesitaremos un constructor, ya que ha diferencia de lenguajes como java no tiene un contructor por defecto. es por eso que si queremos utilizar la palabra reservada new tenemos que crear un constructor con la palabra reservada constructor.

class Startup {

     private text: String;

     constructor (texto: String) {

         this.text = texto;

     }

     public main () : number {

         console.log(this.text);
         return 0;

     }

}

let s = new Startup("Hola mundo");
s.main();

class Startup {

     public static main(): number {

         console.log('Hola mundo');
         return 0;

     }

}

Startup.main();

Otro ejemplo podría ser este:

Typescript

//------ calculos.ts ------
class Calculo {
    // variables de clase declaradas y asignadas
    private x: number = 0;
    private y: number = 0;

    // constructor
    constructor (x: number, y: number){
        // métodos del constructor
        this.setX(x);
        this.setY(y);
    }

    // Setters
    public setX(x: number) : void{
        this.x = x;
    }

    public setY(y: number) : void{
        this.y = y;
    }

    // Getters
    public getX(): number {
        return this.x;
    }

    public getY(): number {
        return this.y;
    }

    public sumar() : number {
        return (this.getX() + this.getY());
    }

    public restar() : number{
        return ( this.mayor() - this.menor() );
    }

    public menor() : number {
        if(this.getX() >= this.getY()) {
            return this.getY();
        }
        return this.getX();
    }

    public mayor() : number {
        if(this.getX() >= this.getY()) {
            return this.getX();
        }
        return this.getY();
    }
}

let calculo = new Calculo(30,10);

console.log(calculo.restar());

Javascript

//------ calculos.js ------
var Calculo = (function () {
    // constructor
    function Calculo(x, y) {
        // variables de clase declaradas y asignadas
        this.x = 0;
        this.y = 0;
        // métodos del constructor
        this.setX(x);
        this.setY(y);
    }
    // Setters
    Calculo.prototype.setX = function (x) {
        this.x = x;
    };
    Calculo.prototype.setY = function (y) {
        this.y = y;
    };
    // Getters
    Calculo.prototype.getX = function () {
        return this.x;
    };
    Calculo.prototype.getY = function () {
        return this.y;
    };
    Calculo.prototype.sumar = function () {
        return (this.getX() + this.getY());
    };
    Calculo.prototype.restar = function () {
        return (this.mayor() - this.menor());
    };
    Calculo.prototype.menor = function () {
        if (this.getX() >= this.getY()) {
            return this.getY();
        }
        return this.getX();
    };
    Calculo.prototype.mayor = function () {
        if (this.getX() >= this.getY()) {
            return this.getX();
        }
        return this.getY();
    };
    return Calculo;
}());
var calculo = new Calculo(30, 10);
console.log(calculo.restar());

Otro ejemplo algo más visual sería el siguiente:

class Greeter {
    greeting: string;
    constructor(message: string) {
        this.greeting = message;
    }
    greet() {
        return "Hello, " + this.greeting;
    }
}

let greeter = new Greeter("world");

let button = document.createElement('button');
button.textContent = "Say Hello";
button.onclick = function() {
    alert(greeter.greet());
}

document.body.appendChild(button);

TypeScript también admite que las clases tengan propiedades estáticas compartidas por todas las instancias de la clase, la manera natural de acceder a estos atributos estáticos sería:

class Something {
  static instances = 0;
  constructor() {
    // Acedemos directamente mediante el nombre de la clase
    Something.instances++;
  }
}
var s1 = new Something();
var s2 = new Something();
console.log(Something.instances); // 2