TypeScript基本语法---10类

相关概念

  • 类(Class):定义了一件事物的抽象特点,包含它的属性和方法
  • 对象(Object):类的实例,通过 new 生成
  • 面向对象(OOP)的三大特性:封装、继承、多态
  • 封装(Encapsulation):将对数据的操作细节隐藏起来,只暴露对外的接口。外界调用端不需要(也不可能)知道细节,就能通过对外提供的接口来访问该对象,同时也保证了外界无法任意更改对象内部的数据
  • 继承(Inheritance):子类继承父类,子类除了拥有父类的所有特性外,还有一些更具体的特性
  • 多态(Polymorphism):由继承而产生了相关的不同的类,对同一个方法可以有不同的响应。比如 CatDog 都继承自 Animal,但是分别实现了自己的 eat 方法。此时针对某一个实例,我们无需了解它是 Cat 还是 Dog,就可以直接调用 eat 方法,程序会自动判断出来应该如何执行 eat
  • 存取器(getter & setter):用以改变属性的读取和赋值行为
  • 修饰符(Modifiers):修饰符是一些关键字,用于限定成员或类型的性质。比如 public 表示公有属性或方法
  • 抽象类(Abstract Class):抽象类是供其他类继承的基类,抽象类不允许被实例化。抽象类中的抽象方法必须在子类中被实现
  • 接口(Interfaces):不同类之间公有的属性或方法,可以抽象成一个接口。接口可以被类实现(implements)。一个类只能继承自另一个类,但是可以实现多个接口



作者:MrWelson
链接:https://www.jianshu.com/p/ae672b7a26e3
来源:简书
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

es6类

TypeScript 是面向对象的 JavaScript。

类描述了所创建的对象共同的属性和方法

TypeScript 支持面向对象的所有特性,比如 类、接口等。

TypeScript 类定义方式如下:

class class_name { 
    // 类作用域
}

定义类的关键字为 class,后面紧跟类名,类可以包含以下几个模块(类的数据成员):

  • 字段 − 字段是类里面声明的变量。字段表示对象的有关数据。

  • 构造函数 − 类实例化时调用,可以为类的对象分配内存。

  • 方法 − 方法为对象要执行的操作。

使用 class 定义类,使用 constructor 定义构造函数。

通过 new 生成新实例的时候,会自动调用构造函数。

 this 关键字表示当前类实例化的对象。注意构造函数的参数名与字段名相同。

class Animal {
    userName: string; // 定义属性
    constructor(name) {  // 定义构造函数对实例进行初始化
        this.userName = name; // 属性赋值
    };
    sayHi() {  // 定义方法
        return `My name is ${this.userName}`;
    }
}

/** 
 * 创建实例化对象
 * 我们使用 new 关键字来实例化类的对象,语法格式如下:
 * var object_name = new class_name([ arguments ])
*/
let cat = new Animal('Tom');
console.log(cat.sayHi()); //My name is Tom

类的继承

TypeScript 支持继承类,即我们可以在创建类的时候继承一个已存在的类,这个已存在的类称为父类,继承它的类称为子类。

类继承使用关键字 extends子类除了不能继承父类的私有成员(方法和属性)和构造函数,其他的都可以继承

TypeScript 一次只能继承一个类,不支持继承多个类,但 TypeScript 支持多重继承(A 继承 B,B 继承 C)。

语法格式如下:

class child_class_name extends parent_class_name

继承类的方法重写

类继承后,子类可以对父类的方法重新定义,这个过程称之为方法的重写。

其中 super 关键字是对父类的直接引用,该关键字可以引用父类的属性和方法

// 类的继承
class Cat extends Animal {
    color: string;
    constructor(name,color) {
        super(name);  // 调用父类Animal的 contructor(name)
        this.color = color;
    };
    sayHi() {
        // super.sayHi():调用父类的 sayHi()
        return super.sayHi() + '我是一只' + this.color + '色的猫';
    }
}

let cat2 = new Cat('Tom','橘黄');
console.log(cat2.sayHi()); //My name is Tom我是一只橘黄色的猫
let cat3 = new Cat('Jerry','yellow');
cat3.color = '黄'
console.log(cat3.sayHi()); //My name is Jerry我是一只黄色的猫

存取器

使用 getter 和 setter 可以改变属性的赋值和读取行为:

class Animal2{
    userName: string;
    constructor(name) {
        this.userName = name;
    };
    get userName() {
        return 'muzidigbig';
    };
    set userName(value) {
        console.log('setter: ' + value);
    }
}
let a = new Animal2('Kitty'); // setter: Kitty
a.userName = 'Tom';// setter: Tom
console.log(a.userName);// muzidigbig

实例属性和方法

js中的属性和方法:

// js中
function Person(name) {
  this.name = name; // 实例属性
  this.eat = function(){ console.log('eat') };  // 实例方法
}
Person.age = 19; // 静态属性
Person.sleep = function(){ console.log('sleep') }; // 静态方法

// 访问实例方法和属性:
var tom = new Person('tom');
console.log(tom.name) // tom
tom.eat();
tom.sleep() // error: tom.sleep is not a function

// 访问静态方法和属性:
console.log(Person.age); // 19
Person.sleep();
Person.eat(); // error: Person.eat is not a function

ES6 中实例的属性只能通过构造函数中的 this.xxx 来定义:

class Animal {
    constructor(){
            this.name = 'tom';
        }
    eat() {}
}

let a = new Animal();
console.log(a.name); // tom

ES7 提案中可以直接在类里面定义:

// ts
class Animal {
    name = 'tom';
    eat() {}
}

let a = new Animal();
console.log(a.name); // Jack

静态属性和方法

ES7 提案中,可以使用 static 定义一个静态属性或方法。静态方法不需要实例化,而是直接通过类来调用:

// ts
class Animal {
    static num = 42;
    static isAnimal(a) {
        return a instanceof Animal;
    }
}

console.log(Animal.num); // 42
let a = new Animal('Jack');
Animal.isAnimal(a); // true
a.isAnimal(a); // TypeError: a.isAnimal is not a function

访问修饰符

public

公有属性或方法,可以在任何地方被访问到,默认所有的属性和方法都是 public

private

私有属性或方法,不能在声明它的类的外部访问,也不可以在子类中访问

protected

受保护的属性或方法,它和 private 类似,区别是它可以在子类中访问

// 访问修饰符
class Person {
    public name: string;
    private idCard: number;
    protected phone: number;
    constructor (name,idCard,phone) {
        this.name = name;
        this.idCard = idCard;
        this.phone = phone;
    }
}

let tom = new Person('Tom',42000,13986358544);
console.log(tom.name); // Tom

// console.log(tom.idCard);//error TS2341: Property 'idCard' is private and only accessible within class 'Person'.

// console.log(tom.phone); //error TS2445: Property 'phone' is protected and only accessible within class 'Person' and its subclasses.

class Teacher extends Person {
    constructor(name,idCard,phone) {
        super(name,idCard,phone);
        console.log(this.name);
        console.log(this.phone);
        // console.log(this.idCard); //error TS2341: Property 'idCard' is private and only accessible within class 'Person'.
    }
}

多态

同一个父类的多个子类,可以有不同结果的同名方法

class Person {
  eat(){ console.log('eat') }
}
class A extends Person {
  eat(){ console.log('A eat') }
}
class B extends Person {
  eat(){ console.log('B eat') }
}

抽象类/抽象方法 abstract

abstract 用于定义抽象类和其中的抽象方法。

  1. 抽象类是提供给其他类继承的基类(父类),是不允许被实例化
  2. 抽象方法只能包含在抽象类中
  3. 子类继承抽象类,必须实现抽象类中的抽象方法
abstract class Animal {
    abstract eat(); // 抽象方法
    // 普通方法
    sleep(){
      console.log('sleep')
    }
}

let a = new Animal(); // 报错,抽象类不能被实例化

class Cat extends Animal {
    eat(){ 
        // 父类的eat方法必须被实现
      console.log('eat')
    }
}

类与接口

类可以实现接口。

前面介绍了 接口 可以用来描述 对象(object)的形状,这一章主要介绍 接口类(class)的行为 进行抽象。

类实现接口 implements

实现(implements)是面向对象中的一个重要概念。一个类只能继承自另一个类,不同类之间可能会有一些共有特性,提取多个类的共有特性,作为一个接口,再用 implements 关键字来实现就可以大大提高面向对象的灵活性。

举例: 人是一个类,人需要吃东西。动物是一个类,动物也需要吃东西。这种情况就可以把 吃东西 提取出来作为一个接口:

interface Ieat {
   eat();
}

class Person implements Ieat{
  eat(){}
}

class Animal implements Ieat {
  eat(){}
}


 

 

 

 

©️2020 CSDN 皮肤主题: 技术黑板 设计师:CSDN官方博客 返回首页