4.typescript类

1.类

 Class Person {
		name!: string
		age: number
	
		constructor(name: string, age: number){
			this.name = name
			this.age = age
		}
		
		running(){
			console.log(this.name+ ' running ')
		}
		eating(){
			console.log(this.name+ ' eating ')
		}
}

2.类的继承（extends）

 Class Student extends Person {
		sno: number
	
		constructor(name: string, age: number, sno: number){
			super(name,age)
			this.sno = sno
		}
		
		studying(){
			console.log(this.name+ 'studyning ')
		}
}

3.类的多态

不同的数据类型进行同一操作，表现出不同的行为
定义：为不同数据类型的实体（子类实体）提供统一的接口（父类类型的引用）
示例：函数的形参只写父类引用（统一参数），且此函数接受父类实例对象和任意子类实例对象，以此来统一按需调用不同的类的相同方法

 Class Animal {
		action(){
			console.log('animal action')
		}
}

 Class Dog extends Animal {
		action(){
			console.log('dog running!')
		}
}

 Class Fish extends Animal {
		action(){
			console.log('fish swimming!')
		}
}

//animal: dog/fish
function makeActions(animal:Animal[]){
	anmials.forEach(an =>{
		an.action()
	}
}

makeActions([new Dog(),new Fish()])

父类引用指向子类对象
多态的目的：写出更加通用性的代码

const animal:Animal = new Dog()
animal.action()

4.类的成员修饰符

public、private、protected
①public 修饰的是在任何地方可见、公有的属性或方法，默认编写的属性就是public的；
②private 修饰的是仅在同一类中可见、私有的属性或方法；（子类和实例对象也不能）
③protected 修饰的是仅在类自身及子类中可见、受保护的属性或方法；
public是默认的修饰符，也是可以直接访问的，我们这里来演示一下protected和private。

class Person {
	protected name: string

	constructor(name: string) {
		this.name = name
	}
}

class Student extends Person {
	constructor(name: string) {
		super(name)
	}

	running(){
		console.log(this.name+ ' running ')
	}
}

class Person {
	private name: string

	constructor(name: string) {
		this.name = name
	}
}

const p = new Person("bai")
//Property 'name' is private and only accessible...
//console.log(p.name)

5.只读属性readonly

如果有一个属性我们不希望外界可以任意的修改，只希望确定值后直接使用，那么可以使用readonly：

class Person {
	readonly name: string

	constructor(name: string) {
		this.name = name
	}
}

const p = new Person("bai")
// Cannot assign to 'name' xxxx
//p.name = "xiao"

6.getters/setters

在前面一些私有属性我们是不能直接访问的，或者某些属性我们想要监听它的获取(getter)和设置(setter)的过程，
这个时候我们可以使用存取器

class Person {
	private _name: string

	set name(newName){
		this._name = newName
	}

	get name(){
		return this._name 
	}

	constructor(name: string) {
		this.name = name
	}
}

const p = new Person("xiao")
p.name = "bai"
console.log(p.name)

7.静态成员

前面我们在类中定义的成员和方法都属于对象级别的, 在开发中, 我们有时候也需要定义类级别的成员和方法。
在TypeScript中通过关键字static来定义：

class Student {
	static time:string = "20:00"

	static attendClass() {
		console.log('123')
	}
}

console.log(Student.time)
Student.attendClass()

8.抽象类abstract

• 以abstract开头的类是抽象类
• 抽象类和其他类区别不大，只是不能用来创建对象
• 抽象类就是专门用来被继承的类
• 抽象类中可以添加抽象方法抽象方法只能定义抽象类中，子类必须对抽象方法进行重写

//以abstract开头的类是抽象类
// 抽象类和其他类区别不大，只是不能用来创建对象
// 抽象类就是专门用来被继承的类
// 抽象类中可以添加抽象方法
abstract class Animal{
    //属性
    name:string;
    age:number;
    //构造函数,对象创立之前调用。
    constructor(name:string,age:number){
        //this表示当前实例
        this.name=name;
        this.age=age;
    }
    //抽象方法，，没有方法体
    //抽象方法只能定义抽象类中，子类必须对抽象方法进行重写
    abstract sayHello():void;
}
//dog类继承Animal类
class Dog extends Animal{
    run(){
        console.log(this.name+"跑");
    }
    //这里重写没有报错
    sayHello(): void {
        console.log('I am a dog!');
    }
}
//cat类继承Animal类
class Cat extends Animal{

    //子类重写父类的函数
   sayHello(): void {
    //调用当前类的父类
    //   super.sayHello()  没有实现会报错
   }
}

 const dog= new Dog("小狗",12);
 

9.类的类型

类本身也是可以作为一种数据类型的：

class Person {
	name: string;
	constructor(name: string){
		this.name = name
	}
	running(){
		console.log(this.name + 'running')
	}
}

const p1:Person = new Person("why")
const p2:Person = {
	name："kebe",
	running: function(){
		console.log(this.name+"running")
	}
}