类的基本示例
（和 C# 或 Java 语法相识）
class Greeter {
// 声明属性
myName: string;
age: number;
static hobby: string; // 静态成员，Greeter.hobby 访问
// 构造方法
constructor(name: string, age: number) {
this.myName = name;
this.age = age;
}
// 一般方法
greet(): string {
return "Hello " + this.myName, +this.age + "岁";
}
// 属性存储器
get name() {
return this.myName;
}
set name(value) {
this.myName = value;
}
}
const greeter = new Greeter("张三", 20);
console.log(greeter.greet());
console.log(greeter.name);
类的只读属性
将属性设置为只读的，只读属性必须在声明时或构造函数里被初始化；
class Person {
public readonly name: string = "abc";
constructor(name: string) {
this.name = name;
}
}
let john = new Person("John");
john.name = 'peter' // error：无法分配到 "name" ，因为它是只读属性
类的继承
class Person {
name: string;
age: number;
constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
getName(): string {
return this.name;
}
setName(name: string): void {
this.name = name;
}
}
class Student extends Person {
stuNo: number;
constructor(name: string, age: number, stuNo: number) {
super(name, age);
this.stuNo = stuNo;
}
getStuNo() {
return this.stuNo;
}
}
let s1 = new Student('zhangsan', 18, 1001);
类的访问修饰符
class Father {
static fatherName: string = 'fatherName';
toString() {
console.log('Father');
}
public name: string; // 完全开放
protected age: number; // 对自己和自己子类开放
private money: number; // 对自己开放,子类和其它类不能访问
constructor(name: string, age: number, money: number) {
this.name = name;
this.age = age;
this.money = money;
}
getName(): string {
return this.name;
}
}
class Child extends Father {
static childName: string = 'childName';
toString() {
super.toString();
console.log('Child');
}
constructor(name: string, age: number, money: number) {
super(name, age, money);
}
public desc() {
console.log(this.name, this.age);
}
}
// 测试
let father = new Father('Dog', 5, 10000);
father.toString()
let child = new Child('边牧', 2, 10000);
child.toString()
Child.fatherName;
Child.childName;
child.age; // error：属性“age”受保护，只能在类“Father”及其子类中访问
child.money; // error：属性“money”为私有属性，只能在类“Father”中访问
抽象类
包含抽象方法（抽象方法一般没有任何的具体内容的实现），也可以包含实例方法，抽象类是不能被实例化，为了让子类进行实例化及实现内部的抽象方法；
做为其它派生类的基类使用，抽象类的目的或者是作用最终都是为子类服务的；
// 定义一个抽象类
abstract class Animal{
// 抽象属性：一般没有这种操作...
// abstract name:string
// 抽象方法只能声明，不能有具体的实现
abstract eat()
// 实例方法
sayHi(){
console.log('hello...')
}
}
// 定义一个子类(派生类)Dog
class Dog extends Animal{
// name:string='小黄'
// 重新的实现抽象类中的方法,此时这个方法就是当前 Dog 类的实例方法了
eat(){
console.log('dog吃...')
}
}
// 定义一个子类(派生类)Cat
class Cat extends Animal{
// name:string='小黄'
// 重新的实现抽象类中的方法,此时这个方法就是当前 Cat 类的实例方法了
eat(){
console.log('cat吃...')
}
}
// 不能实例化抽象类的对象
// const ani:Animal = new Animal()
// 实例化 Dog 的对象
const dog:Dog = new Dog()
const cat:Cat = new Cat()
// 多态：同一个方法，不同的子类有不同的实现
let animals: Animal[] = [dog, cat];
animals.forEach((it) => it.eat());
打赏作者
您的打赏是我前进的动力
微信
支付宝
TypeScript👉 接口和类型兼容性
上一篇
评论
