目录
1-1.类的基本使用
类描述了所创建的对象共同的属性和方法。
TypeScript支持面向对象的所有特性，比如类、接口等
TypeScript类定义方式如下：
class class_name{
//类作用域
}
定义类的关键字为class，后面紧跟类名，类可以包含以下几个模块(类的数据成员)︰
-
字段–字段是类里面声明的变量。字段表示对象的有关数据。
-
构造函数–类实例化时调用，可以为类的对象分配内存。
-
方法–方法为对象要执行的操作。
class Person{
//字段(属性)
name:string
age:number
//构造函数
constructor(name:string,age:number){
this.name = name;
this.age = age;
}
//函数(方法)
sayHello():void{
console.log(`这位美女是：${this.name}，她${this.age}岁`)
}
}
//实例化类
let p = new Person("杨超越",25)
p.sayHello()1-2.类的继承
TypeScript支持继承类，即我们可以在创建类的时候继承一个已存在的类，这个已存在的类称为父类，继承它的类称为子类
类继承使用关键字extends，子类除了不能继承父类的私有成员(方法和属性)和构造函数，其他的都可以继承。
TypeScript一次只能继承一个类，不支持继承多个类，但TypeScript支持多重继承（A继承B，B继承C)。
语法格式如下:
class child_c1ass_name extends parent_c1ass_name
export default{}
class Person{
//字段(属性)
name:string
age:number
//构造函数
constructor(name:string,age:number){
this.name = name;
this.age = age;
}
//函数(方法)
sayHello():void{
console.log(`这位美女是：${this.name}，她${this.age}岁`)
}
}
//子类继承父类
class Student extends Person{
score:string
constructor(name:string,age:number,score:string){
//调用父类中的构造函数
super(name,age)
this.score=score;
}
sayHello():void{
//调用父类中方法
super.sayHello();
//重写父类中的方法
console.log(`这位美女是：${this.name}，她${this.age}岁,成绩是：${this.score}`)
}
}
let s = new Student("欧阳娜娜",22,"S")
s.sayHello()1-3.static与instanceof
static关键字用于定义类的数据成员（属性和方法)为静态的，静态成员可以直接通过类名调用。
instanceof运算符用于判断对象是否是指定的类型，如果是返回true，否则返回false。
//static关键字
//static 关键字用于自定义类的数据成员(属性和方法）为静态的，静态成员可以直接通过类名调用。
class StaticTest{
static salary:number
static say():void{
console.log(`我想要的工资是：${StaticTest.salary}k`)
}
}
StaticTest.salary=20
StaticTest.say()
//instanceof运算符
//instanceof 运算符用于判断对象是否是指定的类型，如果是返回 true，否则返回 false。
class Person{}
let p = new Person();
let isPerson = p instanceof Person;
console.log("p是Person实例化出来的吗？",isPerson);//true
class Student extends Person{}
let s = new Person()
let isPerson2 = s instanceof Person;
console.log("s对象是Person类实例化出来的吗？"+isPerson2);//true1-4.类中的修饰符
-
public(默认):公有，可以在任何地方被访问
-
protected:受保护，可以被其自身以及其子类访问
-
private:私有，只能被其定义所在的类访问。
-
readonly:可以使用readon1y关键字将属性设置为只读的。只读属性必须在声明时或构造函数里被初始化。
export default{}
class Person{
public name:string
protected age:number
private sex:string
construnctor(name:string,age:number,sex:string){
this.name = name
this.age = age
this.sex = sex
}
say():void{
console.log(`我的名字叫：${this.name},今年${this.age}岁,性别：${this.sex}`)
}
}
class Student extends Person{
score:string
constructor(name:string,age:number,sex:string,score:string){
super(name,age,sex)
this.score = score
}
say():void{
console.log(this.name);
console.log(this.age);
console.log(this.sex);//报错(因为sex是私有属性)
console.log(this.score);
}
}
// readonly:字段的前缀可以是 readonly修饰符。这可以防止在构造函数之外对该字段进行赋值。
class Print{
readonly str1:string = "我是默认赋值的";
readonly str2:string ;
readonly str3:string ;
readonly str4:string;
constructor(str2:string,str3:string,str4:string){
this.str2 = str2;
this.str3 = str3;
this.str4 = str4;
}
}
let pc = new Print("我要月薪20k","杨超越","好漂亮")
console.log(pc);1-5.getter与setter
官方的另外一个名字:存取器
通过getters/setters来截取对对象成员的访问
注意点:
如果存在get，但没有set，则该属性自动是只读的
如果没有指定setter参数的类型，它将从getter的返回类型中推断出来访问器和设置器必须有相同的成员可见性
export default{}
class MyName{
private _fullName:string="杨紫";
// 读取字段的值
get fullName(){
console.log("get被调用");
return this._fullName;
}
// 为字段赋值
set fullName(newName:string){
console.log("set被调用");
this._fullName=newName;
}
}
let n = new MyName();
n.fullName="杨超越";//赋值
console.log(n);
console.log(n.fullName); //取值1-6.抽象类
-
定义 抽象类做为其它派生类的基类使用。它们一般不会直接被实例化
抽象类是专门用于定义哪些不希望被外界直接创建的类的
抽象类和接口一样用于约束子类
-
抽象类和接口区别(重点)
抽象方法必须包含abstract关键字并且可以包含访问修饰符
接口中只能定义约束,不能定义具体实现。而抽象类中既可以定义约束,又可以定义具体实现
export default{}
//abstract(抽象化类)
abstract class Person{
abstract name:string
abstract age:number
abstract show():string
showName():void{
console.log("杨超越")
}
}
class Student extends Person{
name:string="杨超越",
age:number=22
show():string{
return "燃烧我的卡路里"
}
}
let s = new Student()
let res = s.show()
console.log(res)1-7.implements子句
-
类可以实现接口，使用关键字implements
-
可以使用一个 implements子句来检查一个类，是否满足了一个特定的接口。如果一个类不能正确地实现它，就会发出一个错误
注意点:
实现一个带有可选属性的接口并不能创建该属性 只要一个接口继承了某个类,那么就会继承这个类中所有的属性和方法,但是只会继承属性和方法的声明,不会继承属―性和方法实现
与extends 的区别
extends:继承某个类，继承之后可以使用父类的方法，也可以重写父类的方法
implements:继承某个类，必须重写才可以使用
export default{}
interface IPersonInfo{
name:string
age:number
sex:string
show():void
}
interface IMusic{
musuc:string
}
class Person implements IPersonInfo{
name:string="杨超越"
age:number=22
sex:string="女"
show(): void {
console.log(`我是${this.name},年龄是${this.age}岁`);
}
}
// 注意点:只要一个接口继承了某个类，那么就会继承这个类中所有的属性和方法但是只会继承属性和方法的声明，不会继承属性和方法实现
interface ITest extends Person{
salary:number
}
class Star extends Person implements ITest{
salary:number=50
name:string="关晓彤"
age:number=18
}
let s = new Star()
console.log(s.name);
console.log(s.salary);1-8.类的初始化顺序
-
基类的字段被初始化
-
基类构造函数运行
-
子类的字段被初始化
-
子类构造函数运行
export default{}
/*
- 基类的字段被初始化
- 基类构造函数运行
- 子类的字段被初始化
- 子类构造函数运行
*/
class Old{
//基类的字段被初始化
name:sting="艾斯"
//基类构造函数运行
constructor(){
console.log(`我是${this.name},主演了海贼王`)
}
}
class Young extends Old{
//子类的字段被初始化
name:string="路飞"
//子类构造函数运行
constructor(){
super()
console.log(`我是${this.name},我主演了海贼王`)
}
}
let y = new Young()
347
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
