【TypeScript】-- TS之面向对象

面向对象

1.接口

接口可以理解为一个特殊的类 / 特殊的对象，是抽象到极致的抽象类，接口中只能存在抽象方法和属性，抽象方法就是没有方法体的方法。

接口通过interface关键字来声明；

使用类去实现接口时， 接口就是标准，类会按照接口这个标准去实现

使用类去实现接口时必须具备接口中具有的的属性和方法

类接口 

类使用接口用implements 关键字；

类中可以拥有属于自己的属性和方法

interface StudentInterFace{
    name;
    say(msg:string):void; // 未实现的方法
    // 抽象方法：没有方法体的方法
}
 
 
 
// 类使用implements关键字实现接口
class Student implements StudentInterFace{
    // 必须包含接口里面的属性和方法
    name;
    say(msg:string):void{
        console.log(this.name + msg);
    }
    // 可以拥有属于自己的属性和方法
    constructor(name){
        this.name = name;
    }
    foo(){
    }
}
let student:StudentInterFace = new Student('zhaaoziyn');
student.say('fff')

对象接口 

// 对象接口  创建出来的对象可以使用接口去实现
enum Gender{
    mal='南',
    feml='女'
}
class Person{
    name:string;
    age:number;
    gender:Gender;
}
interface PropInterFace{
    data:Array<Person>;
    visible:boolean;
}
let prop:PropInterFace = {
    data:[
        {name:"xigua",age:12,gender:Gender.feml},
        {name:"may",age:27,gender:Gender.mal}
    ],
    visible:true
}
console.log(prop);

 多态(一个对象多种形态)

若父类类型得引用指向子类的实例对象，则通过该引用可以访问到父类的属性与方法，但是无法访问子类的属性与方法；

如果子类对父类得特性进行重写，通过该引用调用的重写特性依旧为子类特性。

重写

重写 如果子类中方法签名与父类一致 则会对父类方法进行重写

// 类
// es6 类是构造函数的另一种写法
// 类是创建对象的模板 一个类可以创建多个对象
class Person{
    name:string;
    age:number;
    // weight?:number;
    // say():void{
    //     console.log('不许说话');
    // }
}
 
// 多态的前提是子类实现了对父类的继承
class Student extends Person{
    stuNo:string;
    say():void{
        console.log('会说话就多说点');
        
    }
} 
// new创建一个Student的实例对象s1
// let s1:Person = new Student(); 
let s1:Student = new Student();  // 多态
s1.name = 'haha';
s1.age = 14;
s1.stuNo = '111'
// 子类继承了父类
// 子类对父类的方法进行了重写 会调用子类的方法
s1.say(); //会说话就多说点
console.log(s1); // Student { name: 'haha', age: 14 }
 
// 字面量模式创建对象 如果加了Student的类型限制
// 那么Student里面的属性与方法必须拥有
let s2:Student={
    stuNo:'100000',
    name:'zzy',
    age:17,
    say() {
        console.log('听说你也想说话？');
    },
}
/**
 *  多态：一种对象多种形态
 * 子类继承了父类，若父类类型的引用指向了子类对象s1,
 * 则实例无法调用子类对象特性(属性、方法)，但可以调用父类对象特性
 * 
 * 重写：
 * 如果子类方法签名与父类一致，子类对父类的方法会进行重写 
 * 并且会会调用子类里面的方法
 */

抽象类

什么是抽象类? ​ 一般情况下，抽象类无法创建对象，抽象类中可以存在抽象方法，没有方法体得方法就是 ​ 抽象方法只有抽象签名，抽象类中可以存在抽象方法和非抽象方法，一个类中具有抽象方法， ​ 那个该类一定是抽象类 ​ 存在得意义？ ​ 为了让其它类继承抽象类，并强制要求子类实现抽象方法;

子类继承抽象类：

1. 子类必须实现抽象类中得方法
2. 子类成为抽象类

// 抽象类 里面存在抽象方法
// 抽象方法 没有方法体的方法
// 抽象类存在的意义：让其他类去继承抽象类
// 无法创建抽象类本身的实例对象
abstract class Teacher {
    abstract study():void;
    // 没有abstract修饰的，有方法体的方法不就是非抽象方法
    // 有抽象方法的类一定是抽象类
    log():void{
        console.log('not a abstract');
        
    }
}
// 子类继承抽象类
// 1.子类必须包含抽象类里的抽象方法
class Student1 extends Teacher{
    study(): void {
        console.log('好好学习');
    }
    cook():void{
        console.log('天天吃泡面');
    }
}
let s3:Teacher = new Student1();
s3.study(); // 好好学习
 
// 2. 自身也成为抽象类
// abstract class Student2 extends Teacher{
    
// }

访问修饰符

用于修饰类中的成员属性及成员方法（实例属性、实例方法）

访问权限:

public 公开 当前类、子类、其他类

protected 受保护 当前类、子类

private 私有 当前类

class Person2{
	public name:string;
	protected age:number;
	private weight:number;
	readonly gender:string;
	constructor(name,age,weight,gender){
		this.name=name;
		this.age=age;
		this.weight=weight;
		this.gender=gender;
	}
	protected foo(){
		console.log(this.name);
		console.log(this.age);
		console.log(this.weight);
	}
}
class Student2 extends Person2{
	constructor(name,age,weight,gender){
		super(name,age,weight,gender);
	}
	bar(){
		super.foo()
		// super 父类的引用
		console.log(this.name);
		// console.log(super.age);
	}
};
let s4:Student2=new Student2('terry',12,40,'male');
console.log(s4.name);
// s4.gender='female';  会报错，因为该属性是只读的
s4.bar();

readonly修饰符

你可以使用 readonly关键字将属性设置为只读的。 只读属性必须在声明时或构造函数里被初始化。

class Octopus {
 readonly name: string;
 readonly numberOfLegs: number = 8;
 constructor (theName: string) {
     this.name = theName;
 }
}
let dad = new Octopus("Man with the 8 strong legs");
dad.name = "Man with the 3-piece suit"; // 错误! name 是只读的.

可选属性

有时我们希望不要与接口中的属性与方法完全一致，那么可以用 ? 表示一个可选属性：

interface Person {
    name: string;
    age?: number;
}
 
let tom: Person = {
    name: 'Tom'
};
interface Person {
    name: string;
    age?: number;
}
 
let tom: Person = {
    name: 'Tom',
    age: 25
};