typescript创建一个类
class Person {
// 类的属性,不能使用const/let/var实例
name: string
// 该类的构造方法
constructor(name: string){
this.name = name;
}
// 不带参数的方法
run(): void{
// 这里的name是对象本身构造函数的naem使用的时候需要this.name
console.log(`${this.name} is running...`)
}
// 带参数的方法
work(name: string): void{
console.log(`${name} is working...`)
}
}
// 实例化一个类
var p = new Person("Jack");
p.run();
p.work("wollens")
typescript中的构造方法:
构造方法中的属性和类中的属性的区别:
- 构造函数中的属性可以是变化的,动态接收参数,且在实例化类的时候需要将构造函数的参数传入类中,
且在类实例化时构造方法里的代码就会执行 - 而类中的属性是一个变量,在实例化是不需要传参(当属性前面加类readonly:表示该属性只读不能被改变)
- 补充:
使用readonly关键字会将属性设置为只读的。 只读属性必须在声明时或构造函数里被初始化。且值不能不能被修改,和const类似。
最简单判断该用readonly还是const的方法是看要把它做为变量使用还是做为一个属性。 做为变量使用的话用 const,若做为属性则使用readonly
class test {
// 类属性
name: string = "jack"
age: number = 16
gender: string
// readonly属性不能被修改
readonly num: number = 12
// 构造方法
constructor(gender: string) {
this.gender = gender
console.log(`I'm a ${this.gender}`)
}
run(){
console.log(`${this.name} is running...`)
}
}
var t = new test("male")
console.log(t.name)
t.run()
t.name = "tom"
t.gender = "female"
关于typescript中类的继承
// 创建一个类
class Person {
// 类的属性,不能使用const/let/var实例
name: string
// 该类的构造方法
constructor(name: string){
this.name = name;
}
// 不带参数的方法
run(): void{
// 这里的name是对象本身构造函数的naem使用的时候需要this.name
console.log(`${this.name} is running...`)
}
// 带参数的方法
work(name: string): void{
console.log(`${name} is working...`)
}
}
// 创建一个类继承Person类(typescript中的继承是用extends和super实现)
class goodPerson extends Person {
// 当一个类去继承父类时需要重写父类的构造方法,且super继承父类的属性
gender: string
constructor(name: string, gender: string){
super(name)
this.gender = gender
console.log(`hello I'm ${this.name} ${this.gender}`)
}
eat(food: string){
console.log(`${this.name} is eatting ${food}`)
}
// 子类还可以重构父类的方法
run(){
console.log(`${this.name} is a ${this.gender}`)
}
}
// 实例化这个类
var g = new goodPerson("Tom", "male");
g.eat("drunk");
g.run()
typescript中定义一个抽象方法
// ts中的抽象类方法:子类必须实现父类定义的抽象方法否则会报错
abstract class Animal {
name: string = "pig";
age: number = 12;
abstract eat(): void;
hello() {
console.log("hello everyone")
}
}
// 子类必须实现父类定义的抽象方法否则会报错
class Dog extends Animal {
eat() {
console.log("I'm hungrey")
}
}
var d = new Dog()
d.eat()
typescript中属性的修饰符
TypeScript的访问修饰符有三个,分别是public、private、protected 。
TypeScript的默认访问修饰符是public。
- public声明的属性和方法在类的内部和外部均能访问到。
- protected声明的方法和属性只能在类的内部和其子类能访问。
- private声明的方法和属性只能在其类的内部访问。
class Persons {
public name: string;
protected gender: string;
private age: number;
constructor(name: string, gender: string, age: number){
this.name = name;
this.gender = gender;
this.age = age;
}
run(): void{
console.log(`${this.name} is running...`)
}
work(name: string): void{
console.log(`${name} is working...`)
}
}
var p = new Persons("Jack", "male", 16);
p.run();
console.log(p.name)
console.log(p.gender) //外部不能访问(报错)
console.log(p.age) // 外部不能访问(报错)
p.work("wollens")
关于typescript中的参数属性
- ts中的参数属性
- 在TypeScript中,参数属性可以方便地让我们在一个地方定义并初始化一个成员。
- 参数属性通过给构造函数参数添加一个访问限定符来声明。
class Man {
constructor(public name: string, protected age: number, private gender: string) {
this.name = name;
this.age = age;
this.gender = gender;
}
run() {
console.log(`${this.name} is running...`);
}
eat() {
console.log(`${this.name} is eatting...`);
}
}
var m = new Man("alex", 16, "male")
console.log(m.name)
console.log(m.age) // 私有属性不能被访问
console.log(m.gender) // 私有属性不能被访问
m.run()
m.eat