操作对象
例如
- 操作浏览器要使用window对象
- 操作网页要使用document对象
- 操作控制台要使用console对象
(function(){})()
操作对象要先有类
- 类(class)
语法
class 类名 {
属性名: 类型;
constructor(参数: 类型){
this.属性名 = 参数
}
方法名(){
......
}
}
class Person{
/*
直接定义的属性是实例属性,需要通过对象的实例去访问
const p = new Person();
p.name
使用static开头的属性是静态属性(类属性),可以直接通过类去访问
Person.age
*/
// readonly 只读属性不能更改
readonly name: string = 'zs';
// 在属性前使用static关键字可以定义类属性(静态属性)
static age: number = 15;
// 定义方法
static sayHello() {
console.log('hello');
}
}
const p = new Peron();
// 实例属性
console.log(p.age)
// 类属性(static开头)
console.log(Person.age)
// 实例方法
p.sayHello()
// 类方法(static开头)
Person.sayHello()
- 构造函数(constructor)在对象创建时调用
class Hell{
name: string;
age: number
constructor(name: string,age: number){
/* 在实例方法中,this表示当前的实例
console.log(this)
*/
this.name = name;
this.age = age
}
}
const h = new Hell(name:'ls', age:12);
const s = new Hell(name:'zs', age:16)
- 继承(extends)
class Amid{
name:string;
age: number
constructor(name: string,age: number){
this.name = name;
this.age = age
}
saHe(){
console.log('动物们');
}
}
/* Dog extends Amid
- 此时,Amid被称为父类,Dog被称为子类
- 使用继承后,子类将会拥有父类所有的属性和方法
- 如果在子类中添加了和父类相同的方法,则子类方法会覆盖掉父类的方法
这种方式称为方法重写
*/
// 使用Dog 继承 Amid 类
class Dog extends Amid {
run () {
console.log(`${this.name}在跑~~`);
}
}
// 使用Cat 继承 Amid 类
class Cat extends Amid {
saHe(){
console.log('喵喵');
}
}
- super(在类的方法中super表示当前类的父类)
class A{
name: string;
constructor(name: string){
this.name = name;
}
sayHello() {
console.log('动物在叫~')
}
}
// 添加新的属性
class Dog extends A {
age: number;
// 对属性进行初始化必须调用构造函数
constructor(name:string, age:number){
// 如果在子类中写了构造函数,在子类构造函数中必须对父类的构造函数进行调用
super(name); // 调用父类的构造函数
this.age = age;
}
sayHello() {
console.log('汪汪')
}
}
const dog = new Dog(name:'旺财',age:6)
- 抽象类
以abstract开头的类是抽象类;不能创建对象;抽象类就是专门用来被继承的类
abstract class A{
name: string;
constructor(name: string){
this.name = name;
}
/* 定义抽象方法;使用abstract开头,没有方法体;只能定义在抽象类中;子类必须对抽象方法进行重写
*/
abstract sayHello(): void;
}
class Dog extends A {
sayHello() {
console.log('汪汪')
}
}
