01_类的简介 使用class 关键字定义一个类 对象中主要包含了两个部分，属性和方法
class Person {
直接定义属性是 实例属性，需要通过对象的实例去访问
name: string = '小李';
age: number = 18;
属性前面使用static 关键字可以定义类属性（静态属性）
可以通过类去访问
static age:number = 19;
readonly属性 只读不可修改
readonly cals = '二班
定义方法
如果方法以static开头则方法就是类方法。可以直接通过
类去调用。
sayHel() { return 22 }
}
const per = new Person();
02_构造函数
class Dog {
name: string;
age: number;
constructor 构造函数
构造函数会在对象创建时调用
constructor(name:string,age: number) {
在实例方法中，this 就表示当前的实例
在构造函数中当前对象就是当前创建的那个对象
可以通过this向新创建的对象中添加属性
this.age = age;
this.name = name;
}
bark() {
console.log(this,'===hh')
return '汪汪!'
}
}
const dog = new Dog('小李',12);
(function(){
class Animal {
name: string;
age: number;
constructor(name:string,age:number) {
this.name = name;
this.age = age;
}
sayHel() {
return '叫!'
}
} // 使dog类继承animal类
animal 被称为父类，Dog被称为子类
使用继承后，子类拥有父类的属性和方法
通过继承可以将多个类中共有的代码写到一个父类中
这样只需要写一次即可让所有的子类都同时拥有父类的属性和方法
如果在子类中添加一个与父类中相同的方法，会覆盖调父类的方法，被称为方法的重写
class Dog extends Animal{
sayHel() {
return ${this.name} 在叫！
}
}
// 定义猫的类
class cat extends Animal{
}
const dog = new Dog('小哈',12);
const Dat = new cat('sdi',15);
})()
03_继承
(function(){
class Animal {
name: string;
age: number;
constructor(name:string,age:number) {
this.name = name;
this.age = age;
}
sayHel() {
return '叫!'
}
}
// 使dog类继承animal类
/*
animal 被称为父类，Dog被称为子类
使用继承后，子类拥有父类的属性和方法
通过继承可以将多个类中共有的代码写到一个父类中
这样只需要写一次即可让所有的子类都同时拥有父类的属性和方法
如果在子类中添加一个与父类中相同的方法，会覆盖调父类的方法，被称为方法的重写
*/ class Dog extends Animal{
sayHel() {
return ${this.name} 在叫！
}
}
// 定义猫的类
class cat extends Animal{
}
const dog = new Dog('小哈',12);
const Dat = new cat('sdi',15);
console.log(dog.sayHel())
console.log(dog)
})()
04_super
(function(){
class Animal{
name:string;
constructor(name:string) {
this.name = name;
}
sayHello() {
console.log('ijjj')
return 'hhhh'
}
}
class Dog extends Animal{
age: number;
constructor(name:string,age:number) {
// 如果在子类中写了构造函数，在子类构造函数中必须对父类构造器进行调用
super(name); // 调用父类的构造函数
this.age = age;
}
sayHell() {
// 在类的方法中super就表示当前类的父类
super.sayHello()
}
}
const dog = new Dog('小华',333);
})()
05_抽象类
(function(){
/* 以abstract 开头的类是抽象类
抽象类和其他类的区别不大，只是不能用来创建对象
抽象类就是专门用来被继承的类
抽象类中可以添加抽象方法 */
abstract class Animal
name:string;
constructor(name:string) {
this.name = name;
}
// sayHello() {
// console.log('ijjj')
// return 'hhhh'
// }
// 定义一个抽象方法
// 抽象方法使用abstract开头，没有方法体
// 抽象方法只能定义在抽象类中，子类必须对抽象方法进行重写
abstract sayHello(): void;
}
class Dog extends Animal{
age: number;
constructor(name:string,age:number) {
// 如果在子类中写了构造函数，在子类构造函数中必须对父类构造器进行调用
super(name); // 调用父类的构造函数
this.age = age;
}
sayHello() {
// 在类的方法中super就表示当前类的父类
// super.sayHello()
}
}
const dog = new Dog('小华',333);
})()
06_接口的定义
(function(){
/*
接口用来定义一个类结构，用来定义一个类中应该包含哪些属性和方法
同时接口也可以当成类型声明去使用
*/ interface myInterface{
name:String;
age:Number;
}
const obj: myInterface = {
name:'小李',
age:12
}
/*
接口可以在定义类的时候去限制类的结构
接口中的所有的属性都不能有实际的值
接口只定义对象的结构，而不考虑实际的值
在接口中所有的方法都是抽象的方法
*/ interface myInter {
name:String;
} /* 定义类时，可以始类去实现一个接口
实现接口就是使类满足接口的要求
*/
})()
07_属性的封装
(function(){
// 定义一个表示人的类
class Person { /*
Ts可以在属性前添加属性的修饰符
public 修饰的属性可以在任意位置访问（修改）默认值
private 私有属性，私有属性只能在类内部进行访问（修改）
-- 通过类中添加方法使得私有属性可以被外部访问
protected 受包含的属性，只能在当前类和当前类的子类中访问修改
*/ private name: string;
private age: number;
constructor(name:string,age:number) {
this.name = name;
this.age = age
} /* setter 方法用来设置属性
它们被称为属性的存取器
*/ // getName() {
// return this.name;
// } // setName(seName: string) {
// this.name = seName;
// }
// getAge() {
// return this.age;
// } // setAge(setAge: number) {
// if(setAge >= 0){
// this.age = setAge;
// }
// }
// TS中设置getter方式
get named() {
return this.name
} set named(setName: string) {
this.name = setName;
}
}
const pre = new Person('小李',18);
/* 现在属性是在对象中设置的，属性可以任意的被修改
属性可以任意被修改将会导致对象中的数据变得非常不安全
*/ // pre.name = '小华';
// pre.age = -20;
// console.log(pre.named('小明'));
// console.log(pre.named());
// console.log(pre.setAge(-312));
// console.log(pre.getAge());
class A {
protected name: string;
constructor(names: string) {
this.name = names;
}
}
class B extends A {
getName() {
return this.name;
}
} const b = new B('小华');
})()
08_泛型
/* any 类型直接跳过类型检测
*/ function fanxing(name: any): any {
return name;
} /* 泛型： 在定义函数或者类型时，遇到类型不明确就可以使用泛型
*/ function fanxin(name:T): T{
return name;
} // 可以直接调用具有泛型的函数
fanxin('小李') // 不指定泛型，Ts可以自动对类型进行检测
fanxin(188) // 指定泛型
function fanxi<T,K>(name:T,age: K): T{
return name
} fanxi('晓华',18);
fanxi<string,number>('徐爱',20)
interface Innerface{
length: number;
} // T extends Inter 表示泛型T必须时Inter实现类（子类）
function pig(a:T): number {
return a.length
} class Myclass {
name:T;
constructor(name:T) {
this.name = name;
}
} const mc = new Myclass('小张');
