typescript any类型 typescript的类

TypeScript面向对象编程---类

• 1. Typescript类

• 1.1 类的定义
• 1.2 创建实例化对象
• 1.3 类的继承
• 1.4 继承类的方法：重写
• 1.5继承和重写的综合例子
• 1.6 static关键字
• 1.5 instanceof 运算符
• 1.7 访问控制修饰符
• 练习题：

1. Typescript类

Typescript 是面向对象的JavaScript。类描述了所创建的对象共同的属性和方法。Typescript 支持面向对象的所有特性。

1.1 类的定义

class class_name {
	//类作用域；
}

类可以包含以下几个模块(类的数据成员)

1. 字段： 字段是类里面声明的变量，字段表示对象的有关数据。
2. 构造函数： 类实例化时调用，可以分为类的对象分配内存。
3. 方法： 方法为对象要执行的操作。
   例如：

class Car {
	//字段
	engine: string;
	//构造函数
	constructor(engine: string) {
		this.engine = engine;
	}
	//方法
	disp():void {
		console.log("发动机为："+this.engine)
	}
}

this关键字表示当前类实例化对象。注意构造函数的参数名与字段名相同，this.engine表示类的字段。

1.2 创建实例化对象

创建实例化对象：使用 new 关键字来实例化类的对象，语法格式如下：

var object_name = new class_name([arguments])

类实例化时会调用构造函数,例如：

var obj = new Car("Engine1")

类中的字段属性和方法可以使用 == . == 号来访问：

//访问属性
obj.field_name
//访问方法
obj.function_name()
//示例：
//创建一个对象
var obj = new Car("XXSY1");
//访问字段
console.log("读取发动机型号："+obj.engine);
//访问方法
obj.disp();

1.3 类的继承

• Typescript 支持继承类，即我们可以在创造类的时候继承一个已经存在的类，这个已存在的类称为父类，继承它的类称为子类。
• 类继承使用关键字extends，子类除了不能继承父类的私有成员(方法和属性)和构造函数，其他的都可以继承。
• TypeScript 一次只能继承一个类，不支持继承多个类，但TypeScript支持多重继承(A继承B，B继承C)。

实例：

class Shape {
	Area:number
	constructor(a:number){
		this.Area = a;
	}
}
class Circle extends Shape {
	disp():void{
		console.log("圆的面积：",this.Area;
	}
}
var obj = new Circle(223);
obj.disp();

1.4 继承类的方法：重写

继承类的方法重写(overwrite)：又称为方法覆盖。类继承后，子类可以对父类的方法重新定义，这个过程称之为方法的重写。使用super关键字可以引用父类的属性和方法。
例如：

class PrinterClass {
	doPrint():void{
		console.log("父类的doPrint()方法。")
	}
}
class StringPrinter extends PrinterClass {
	doPrint():void {
		super.doPrint() //调用父类的函数
		console.log("子类的doPrint()方法，添加新的东西")
	}
}
var p1 = new StringPrinter();
p1.doPrint();

1.5继承和重写的综合例子

class Father{
      name:string;
      age:number;
      sex:string;
      constructor(sex:string,name:string,age:number){
        this.name = name;
        this.age = age;
        this.sex = sex;
      }
      say(){
        console.log("father");
      }
      sayHello(){
        console.log("father");
      }
     }
    
     let fa = new Father('胡英俊','男',30); //和 constructor 保持一致
    
    //子类
     class Child extends Father{
        look:string;
        play(){
          console.log("child-子类的一个方法!");
        }
        sayHello(){
        super.sayHello();
          console.log("child-重写父类的方法，添加新的东西！");
        }
     }
    
     let child = new Child('胡图图','男',6);
    
     child.play();
     child.sayHello();

1.6 static关键字

static关键字： 用于定义类的数据成员（属性和方法）为静态的，静态成员可以直接通过类名调用。

class StaticMem { 
	static num:number; 
	static disp():void { 
		console.log("num 值为 "+ StaticMem.num) 
	} 
} 
StaticMem.num = 12 // 初始化静态变量 
StaticMem.disp() // 调用静态方法

1.5 instanceof 运算符

instanceof 运算符： 用于判断对象是否是指定的类型，如果是返回 true，否则返回 false。

class Person{ }
  var obj = new Person()
  var isPerson = obj instanceof Person; 
console.log("obj 对象是 Person 类实例化来的吗？ " + isPerson);

1.7 访问控制修饰符

访问控制修饰符：TypeScript 中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。TypeScript 支持 3 种不同的访问权限。

• public（默认） : 公有，可以在任何地方被访问。
• protected : 受保护，可以被其自身以及其子类中访问。
• private : 私有，只能被其定义所在的类访问。

例如：

class Encapsulate { 
	str1:string = "hello" 
	private str2:string = "world" 
} 
var obj = new Encapsulate() 
console.log(obj.str1) // 可访问 
console.log(obj.str2) // 编译错误， str2 是私有的

练习题：

1、编写一个TS程序，并满足如下要求：
1）编写一个Car类，具有：
属性：品牌(mark)——String类型
功能：驾驶（void drive( ))
2）定义Car类的子类SubCar，具有：
属性：价格（price）、速度（speed）——number型
功能：变速（void speedChange(newSpeed:number))，把新速度赋给speed

class Car {
    mark:string;
    constructor(a:string) {
        this.mark = a;
    }
    drive():void {
        console.log("本车的品牌是",this.mark);
    }
}
class SunCar extends Car {
    price:number;
    speed:number;
    newSpeed:number;
    constructor(a:string,price:number,speed:number,newSpeed:number) {
        super(a);
        this.price = price;
        this.speed = speed;
        this.newSpeed = newSpeed;
    }
    speedChange():void{
        console.log("本车的品牌是"+this.mark);
        console.log(`${this.mark}的价格是${this.price}`);
        console.log("奥迪车原来的速度是",this.speed);
        console.log("本车正在驾驶");
        console.log(this.mark+"现在的速度是"+this.newSpeed);
    }
}
var car1 = new SunCar('奥迪',50,80,120);
car1.speedChange();

var car2 = new SunCar('奔驰',100,90,120);
car2.speedChange();