typeScript中的类
1.1 类的定义
1.2 继承
1.3 类里面的修饰符
1.4 静态属性 静态方法
1.5 抽象类 继承 多态
1. 类的定义
class Person{
name:string; //属性 前面省略了public关键词
constructor(n:string){ //构造函数 实例化类的时候触发的方法
this.name=n;
}
run():void{
console.log(this.name);
}
}
var p1=new Person('张三');
p1.run()
2. 继承 :extends 、super
class Person{
name:string; //属性 前面省略了public关键词
constructor(n:string){ //构造函数 实例化类的时候触发的方法
this.name=n;
}
run():void{
console.log(this.name);
}
}
class Man extends Person{
constructor(name:string){
super(name); /*初始化父类的构造函数*/
}
}
3. 类里面的修饰符
typescript里面定义属性的时候给我们提供了 三种修饰符
public :公有 在当前类里面、 子类 、类外面都可以访问
protected:保护类型 在当前类里面、子类里面可以访问 ,在类外部没法访问
private :私有 在当前类里面可以访问,子类、类外部都没法访问
属性如果不加修饰符 默认就是 公有 (public)
//public :公有 在类里面、 子类 、类外面都可以访问
class Person{
public name:string; /*公有属性*/
constructor(name:string){
this.name=name;
}
run():string{
return `${this.name}在运动`
}
}
class Web extends Person{
constructor(name:string){
super(name); /*初始化父类的构造函数*/
}
run():string{
return `${this.name}在运动-子类`
}
work(){
alert(`${this.name}在工作`)
}
}
var p1=new Person('张三');
p1.run() // 正确:张三在运动
alert(p1.name) // 正确:张三
var p2=new Man('李四');
p2.run() // 正确:李四在运动-子类
alert(p2.name) // 正确:李四
protected:保护类型
//protected:保护类型 在类里面、子类里面可以访问 ,在类外部没法访问
class Person{
protected name:string; /*公有属性*/
constructor(name:string){
this.name=name;
}
run():string{
return `${this.name}在运动`
}
}
class Man extends Person{
constructor(name:string){
super(name); /*初始化父类的构造函数*/
}
run():string{
return `${this.name}在运动-子类`
}
work(){
alert(`${this.name}在工作`)
}
}
var p1=new Person('张三');
p1.run() // 正确:张三在运动
alert(p1.name) // 错误,在类外部没法访问
var p2=new Man('李四');
p2.run() // 正确:李四在运动-子类
alert(p2.name) // 错误,在类外部没法访问
private 私有属性
class Person{
private name:string; /*公有属性*/
constructor(name:string){
this.name=name;
}
run():string{
return `${this.name}在运动`
}
}
class Man extends Person{
constructor(name:string){
super(name); /*初始化父类的构造函数*/
}
run():string{
return `${this.name}在运动-子类`
}
work(){
alert(`${this.name}在工作`)
}
}
var p1=new Person('张三');
p1.run() // 正确:张三在运动
alert(p1.name) // 错误,私有属性外部无法访问
var p2=new Man('李四'); // 错误
p2.run() // 错误,私有属性子类无法访问
alert(p2.name) // 错误,私有属性外部无法访问
4.静态属性 静态方法
class Man {
public name:string;
public age:number=18;
static sex="男"; //静态属性
constructor(name:string) {
this.name=name;
}
run(){ /*实例方法*/
console.log(`${this.name}在运动`)
}
work(){
console.log(`${this.name}在工作`)
}
static print(){ /*静态方法 里面没法直接调用类里面的属性*/
console.log('print方法'+ Man.sex);
}
}
var p=new Man('张三');
p.run(); // 张三在运动
p.print(); // 错误,静态方法,外部无法调用
console.log(p.sex); // 错误,静态属性,外部无法调用
Man.print(); // 正确:print方法男
console.log(Man.sex); // 正确:男
5. 多态,抽象
//多态:父类定义一个方法不去实现,让继承它的子类去实现 每一个子类有不同的表现
class Animal {
name:string;
constructor(name:string) {
this.name=name;
}
eat(){ //具体吃什么 不知道 , 具体吃什么?继承它的子类去实现 ,每一个子类的表现不一样
console.log('吃的方法')
}
}
class Dog extends Animal{
constructor(name:string){
super(name)
}
eat(){
return this.name+'吃粮食'
}
}
class Cat extends Animal{
constructor(name:string){
super(name)
}
eat(){
return this.name+'吃老鼠'
}
}
//typescript中的抽象类:它是提供其他类继承的基类,不能直接被实例化。
//用abstract关键字定义抽象类和抽象方法,抽象类中的抽象方法不包含具体实现并且必须在派生类中实现。
// abstract抽象方法只能放在抽象类里面
// 抽象类和抽象方法用来定义标准 。 标准:Animal 这个类要求它的子类必须包含eat方法
abstract class Animal{
public name:string;
constructor(name:string){
this.name=name;
}
abstract eat():any; //抽象方法不包含具体实现并且必须在派生类中实现。
run(){
console.log('其他方法可以不实现')
}
}
var a = new Animal() /*错误的写法*/
class Dog extends Animal{
//抽象类的子类必须实现抽象类里面的抽象方法
constructor(name:any){
super(name)
}
eat(){
console.log(this.name+'吃粮食')
}
}
var d = new Dog('小白狗');
d.eat();
总结
一、多态的概念:面向对象语言有三大主要特征:封装、继承、多态、封装是为了把我们需要隐藏的东西私有化,不让别人知道,把该暴露的暴露出去;继承提高了代码的复用性,我们可以直接拿父类中的属性,而且子父类的产生使类与类之间产生了关系,就有了多态的出现。顾名思义,多态就是事物的多种体现形态,学生军人农民都是人,我们既可以说他们是农民、军人又可以说他们是人,这就是多态。
二、多态的体现:多态必须是父类的引用指向子类的对象:Person p=new Student();当然这个前提是Student 这个类extends Person 这个类。多态的必要性:存在继承关系,子父类或者是实现关系(接口中)。然后就是发生重写,就是有重写存在。
三、多态的好处:大大提到了代码的可扩展性。