1、TypeScript 类
一、类的基本构成
类里面有有两个部分 1、属性 2、方法
//class 定义一个 City 类
class City{
1、声明实例属性
name: string;
clevel: number;
在属性前使用 static 关键字定义类属性（静态属性）
static country = "中国";
在属性前面加上readonly，属性会变成只读属性，只能读取不能修改。
readonly provice = "湖南";
//constructor 构造函数
//构造函数会在对象创建时调用
constructor(name: string, clevel: number){
this.name = name;
this.clevel = clevel;
}
//一般方法
about(){
//about方法放在了哪里? -类的原型对象 上，供实例使用
//about中的this就是Person实例
consloe.log(this)
console.log(`欢迎来到${this.name},长沙是${this.clevel}级城市`);
}
static hello(){
console.log("你好，长沙。")
}
}
创建对象的实例
const c1 = new City("长沙", 1);
console.log(c1.name);
console.log(c1.provice);
c1.about();
//class中的方法默认开启了局部的严格模式，所以about中的this为undefined
const quanju = c1.about;
quanju();
console.log(City.country);
City.hello();
1.1、定义属性
直接定义的属性是实例属性，需要通过对象的实例去访问
const c1 = new City("长沙", 1);
c1.name;
在属性前使用 static 关键字定义类属性（静态属性）,直接通过类访问。
City.country;
1.1、定义方法
直接定义的方法是实例方法，需要通过对象的实例去访问
const c1 = new City("长沙", 1);
c1.about();
在属性前使用 static 关键字定义类方法（静态方法）,直接通过类访问。
City.hello();
二、类的继承简介(extends)和 super关键字
(function(){
// 定义一个动物的类
class Animal{
name: string;
age: number;
constructor(name: string, age: number){
this.name = name;
this.age = age;
}
say(){
console.log("动物在叫");
}
}
/**
* class Dog extends Animal
* 此时 Animal 被称为父类，Dog 被称为子类
* 继承父类后，子类会拥有父类所有的属性和方法
* 通过继承我们可以把多个类中共有的代码写在一个父类中
* 这样只需要写一次就能让所有的子类拥有父类的属性和方法
*/
// 定义一个狗类
// 使 Dog 类继承 Animal 类
class Dog extends Animal{
height: number;
width: number;
constructor(name: string, age: number, height: number, width: number){
/**
* 在子类中写了构造函数，则在子类的构造函数中必须调用 父类 的构造函数(通过super调用)
*/
super(name, age);//调用父类的构造函数
this.height = height;
this.width = width;
}
run(){
console.log(`${this.name},在愉快的奔跑。`);
super.say();//调用父类的方法
};
/**
* 如果子类中添加了和父类相同的方法，则子类的方法会覆盖父类的方法
* 这种子类覆盖掉父类的形式，我们称之为方法的重写
*/
say(){
console.log("汪汪汪---")
};
}
// 定义一个猫类
// 使 Cat 类继承 Animal 类
class Cat extends Animal{
say(){
console.log("喵喵喵---")
};
}
let dog = new Dog("旺财", 4, 80, 100);
console.log(dog);
dog.say();
dog.run();
let cat = new Cat("菲菲", 3);
console.log(cat);
cat.say();
})();
三、抽象类
(function(){
// 定义一个动物的类
/**
* 以 abstract 开头的类就是抽象类
* 抽象类和其他的类差别不大，只是不能用来创建对象
* 抽象类就是专门用来继承的类
* 抽象类中可以添加抽象方法
*/
abstract class Animal{
name: string;
age: number;
constructor(name: string, age: number){
this.name = name;
this.age = age;
}
/**
* 定义一个抽象方法
* 抽象方法使用 abstract 开头，没有方法体
* 抽象方法只能定义在抽象类中，子类必须对抽象方法进行重写
*/
abstract say(): void;
}
// 定义一个狗类
class Dog extends Animal{
height: number;
width: number;
constructor(name: string, age: number, height: number, width: number){
super(name, age);//调用父类的构造函数
this.height = height;
this.width = width;
}
say(){
console.log("汪汪汪---")
};
}
let dog = new Dog("旺财", 4, 80, 100);
console.log(dog);
dog.say();
})();
四、接口
(function(){
/**
* 接口用来定义一个类结构，用来定义一个类中应包含那些属性和方法
* 接口定义类的时候限制了类的结构
* 属性: 接口中所有的属性都不能有实际的值
* 接口只定义对象的结构，而不考虑实际值
* 方法: 接口中所有的方法都是抽象方法
*/
interface myInter{
name: string;
say(): void;
}
/**
* 定义类时可以实现接口
* 实现接口就是使类满足接口 定义的类结构
*/
class MyClass implements myInter{
name: string;
constructor(name: string){
this.name = name;
}
say(): void{
console.log("大家好！！！")
}
}
})();
五、属性的封装
(function(){
// 定义一个人类
class Person{
/**
* TS 可以在属性前添加属性修饰符
* public 修饰的属性可以在任意位置访问（修改） 默认值
* private 私有属性，只能在类内部进行访问（修改）
* 通过在类中添加方法，使得私有属性可被外部访问
* protected 受保护的属性，只能在当前类和当前类的子类中访问（修改）
*/
private _name: string;
private _age: number;
protected height: number
constructor(name: string, age: number, height: number){
this._name = name;
this._age = age;
this.height = height;
}
// 定义一个方法,用来获取 age 属性
getAge(){
return this._age;
}
// 定义一个方法,用来设置 age 属性
setAge(age: number){
if(age >= 0){
this._age = age;
}
}
// TS中 getter 的方式获取属性
get name(){
return this._name;
}
// TS中 setter 的方式获取属性
set name(name: string){
this._name = name;
}
}
class Students extends Person{
getHeight(){
return this.height;
}
}
let stu = new Students("学生", 18, 176);
console.log(stu.getHeight())
/**
* 现在属性值是在对象中设置的，属性值可以任意的的被修改
* 属性值可以任意被修改将会导致对象中的数据非常不安全
*/
let per = new Person("LBipanda", 18, 178)
console.log(per);
per.getAge();
per.setAge(22);
console.log(per.name);
console.log(per.name = "wudi");
})();
