在面向对象语言中，类是一种面向对象计算机编程语言的构造，是创建对象的蓝图，描述了所创建的对象共同的属性和方法。class
1、基本示例
class Person {
// 声明属性
name: string
// 构造方法
constructor(name: string) {
this.name = name;
}
// 一般方法
sayHi() {
console.log(`hello ${this.name}`);
}
}
// 创建类的实例
let person = new Person('李四');
// 调用实例的方法
person.sayHi();
2、静态属性
只能通过类访问的属性或方法。
class Person {
name: string = '张三'
static age: number = 18
constructor() {
console.log(this.age); // 报错
console.log(Person.age); // 18
}
sayHi() {
console.log(`hello ${this.name}`);
}
}
let p1 = new Person();
console.log(Person.age); // 18
3、类修饰符
- public 公有的 属性不添加修饰符默认为公有的 可以在任何地方被访问
- private 私有的 不能在声明它的类的外部访问
- protected 受保护的 和privite类似 区别是它的子类中是允许访问的
- readonly 将属性设置为只读状态 不可更改
3.1、示例
class Person {
public name: string
private age: number
protected sex: string
constructor(name: string, age: number, sex: string) {
this.name = name;
this.age = age;
this.sex = sex;
}
sayHi() {
console.log(`hello ${this.name}`);
}
}
let p = new Person('张三', 18, '男');
console.log(p);
console.log(p.age); // 报错 私有属性 只能在类中被访问
console.log(p.sex); // 报错 受保护的 只能在类中或子类中被访问
当构造函数的修饰符是private时，该类不允许被继承或者实例化。
class Person {
public name: string
private constructor(name: string) {
this.name = name;
}
sayHi() {
console.log(`hello ${this.name}`);
}
}
let p = new Person('张三'); // 报错 构造函数是类私有的 只能在类中访问
当构造函数的修饰符是private时，该类不允许被继承或者实例化。
class Person {
public name: string
protected constructor(name: string) {
this.name = name;
}
sayHi() {
console.log(`hello ${this.name}`);
}
}
class Son extends Person{
constructor(name: string) {
super(name);
}
}
let p = new Person('张三'); // 报错 构造函数是受保护的 只能在类中访问
let son = new Son('张三');
3.2、readonly
class Person {
readonly name: string
constructor(name: string) {
this.name = name;
}
sayHi() {
console.log(`hello ${this.name}`);
}
}
let p = new Person('张三');
p.name = '李四'; // 报错 name是只读属性
readonly 可以在构造函数中被更改
class Person {
readonly name: string = '张三'
constructor(name: string = '李四') {
this.name = name;
}
sayHi() {
console.log(`hello ${this.name}`);
}
}
let p = new Person();
console.log(p.name); // 李四
let p1 = new Person('王五');
console.log(p1.name); // 王五
3.3、参数属性
构造函数中的参数 一旦使用修饰符后 类中就多了一个属性 这叫做参数属性
class Person {
constructor(readonly name: string = '李四') {
}
sayHi() {
console.log(`hello ${this.name}`);
}
}
let p = new Person();
console.log(p.name); // 李四
4、存取器
让我们可以有效的控制对对象中成员的访问 通过getters和setters来实现。
class Person {
firstName: string = 'A'
lastName: string = 'B'
get fullName () {
return `${this.firstName}_${this.lastName}`;
}
set fullName (value) {
let arr = value.split('-');
this.firstName = arr[0];
this.lastName = arr[1];
}
}
let p = new Person();
console.log(p.fullName); // A_B
p.fullName = 'A-C';
console.log(p.fullName); // A_C
5、继承 extends
继承是一种联结类与类的层次模型。指的是一个类继承另外的一个类的功能，并可以增加新功能的能力，继承是类与类或者接口与接口之间最常见的关系。
class Person {
name: string
age: number
sex: string
constructor(name: string = 'jack', age: number = 18, sex: string = '男') {
this.name = name;
this.age = age;
this.sex = sex
}
sayHi(str: string = 'and you?') {
console.log(`姓名：${this.name}-年龄：${this.age}-性别：${this.sex} ${str}`);
}
}
class Son extends Person {
constructor(name: string, age: number, sex: string) {
super(name, age, sex);
}
}
let persons = new Person();
let son = new Son('jack1', 20, '男');
persons.sayHi();
son.sayHi(); // 继承父类里的sayHi方法
6、多态
父类型的引用指向了子类型的对象，不同类型的对象针对相同的方法，产生了不同的行为。
class Animal {
name: string
constructor(name: string = '小花猫') {
this.name = name;
}
eat(food: string = '鱼') {
console.log(`${this.name}---${food}`);
}
}
class Dog extends Animal {
constructor(name: string) {
super(name);
}
eat(food: string = '骨头') {
console.log(`${this.name}---${food}`);
}
}
class Pig extends Animal {
constructor(name: string) {
super(name);
}
eat(food: string = '大白菜') {
console.log(`${this.name}---${food}`);
}
}
let ani: Animal = new Animal();
ani.eat();
let dogs: Dog = new Dog('阿黄');
dogs.eat();
let pigs: Pig = new Pig('天蓬元帅');
pigs.eat();
let dogs1: Animal = new Dog('阿黄');
dogs.eat();
let pigs1: Animal = new Pig('天蓬元帅');
pigs.eat();
function getEat(ani: Animal) {
ani.eat();
}
getEat(dogs1);
getEat(pigs1);
7、抽象类 abstract
抽象类做为其它子类的基类使用。它们不能被实例化，因为它里面包含一个或多个抽象方法。所谓的抽象方法，是指不包含具体实现的方法。抽象类中的抽象方法必须在子类中实现。
abstract class Animal {
abstract cry()
run() {
console.log('run');
}
}
let ani = new Animal(); // 报错
抽象类不允许被实例化，只能在子类中实现抽象方法
abstract class Animal {
abstract cry()
run() {
console.log('run');
}
}
class Dog extends Animal {
cry() {
console.log('dog cry');
}
}
let dog = new Dog();
dog.cry();
dog.run();
