面向对象的三大特征:封装 继承 多态、
一.封装
封装:隐藏对象的属性对外只提供可以访问属性的方法。
访问修饰符有:
1.public:公用 任何位置都可以访问
2.private:私有 ,只允许本类访问
// exprot导出 可以让其他包可以引用本文件
exprot class Pet{
//访问修饰符 本类 本包 其他包 子类
//public:公用的 任何位置都可以访问
public id:number
//default 默认
name:string
//private:私有的 只允许本类访问
private sex:string
// 私有的 只允许本类访问
private a(){
console.log('a');
}
constructor(id:number,name:string,sex:string){
this.id=id
this.name=name
this.sex=sex
}
}
1.如何使用封装
封装:隐藏对象的属性对外只提供可以访问属性的方法
1.私有化属性并初始化
2.提供一个公用的方法来访问属性一般用get/set 或getter/setter来访问属性和设置或赋值
3.实例化并打印
class Pets{
constructor(id:number, name:string, sex:string,helth:number , love:number ){
this.id=id
this.name=name
this.sex=sex
this.helth=helth
this.love=love
}
// 1.私有化属性
private id:number
private name:string
private sex:string
private helth:number //健康值
private love:number //亲密度
// 2.提供一个公有的方法来访问属性 get/set || getter//setter
public getetId():number{
return this.id
}
public getName():string{
return this.name
}
public getSex():string{
return this.sex
}
public getHelth():number{
return this.helth
}
public getLove():number{
return this.love
}
//set 设置/赋值
public setId(id:number){
this.id=id
}
public setName(name:string){
this.name=name
}
public setSex(sex:string){
this.sex=sex
}
public setHelth(helth:number){
this.helth=helth
}
public setLove(love:number){
this.love=love
}
}
let p:Pets=new Pets(1,'小白','公',100,100)
// p.helth=99
p.setHelth(90) //调用函数修改属性的值
//必须使用get函数访问属性
console.log(`序号:${p.getetId()},昵称:${p.getName()}`);
二. 继承
1.继承
继承关键字:extends子类继承父类的属性和方法,通过export 导出,用improt导入。
//导包
import { Pet } from "../bb/extends";
//
//创建父类
class A{
//创建了三个不同修饰符在不同的状态下,子类是否能继承父类的属性
public a1:number
a2:number
private a3:number
//初始化对象
constructor(a1:number,a2:number,a3:number){
this.a1=a1
this.a2=a2
this.a3=a3
}
//获取私有属性 返回a3的值
public getA3():number{
return this.a3
}
//设置获取的私有属性并赋值
public setA3(a3:number){
this.a3=a3
}
//设置 aa方法为私有属性
private aa(){
console.log('私有方法');
}
// 设置bb方法为公有方法
public bb(){
console.log('父类的公有方法');
}
}
//创建子类B 继承了父类 A的属性和方法
class B extends A{
// 子类可以有自己的属性和方法
b1:number
b2:number
b3(){
console.log('b的函数');
console.log(this.a1);
console.log(this.a2);
// 子类无法继承父类的私有属性和方法
// console.log(this.a3);
// this.aa()
this.bb()
}
// 派生类的构造函数必须包含 "super" 调用
constructor( a1:number,a2:number,a3:number,b1:number,b2:number){
// 调用父类的构造函数 必须写在构造函数的第一行
super(a1,a2,a3)
this.b1=b1
this.b2=b2
}
}
let ba:B=new B(1,2,3,4,5)
console.log(ba);
ba.bb()
2.继承的关键字:extends
1.继承的关键字 extends
//列子
class A{
name:string
constructor(name:string){
this.name=name
}
}
class B extends A{}
3.一个父类也可以有多个子类
class R{
public Name:string
public Sex:string
public chi(){
console.log('平淡的一天');
}
constructor(Name:string,Sex:string){
this.Name=Name
this.Sex=Sex
}
}
let h:R=new R('李四','男')
console.log(`姓名:${h.Name},性别:${h.Sex}`);
h.chi()
class H extends R{
fs:string
hs(){
console.log(this.Name+':'+'做好事');
}
constructor(Name:string,Sex:string,fs:string){
super(Name,Sex)
this.fs=fs
}
}
let h1:H=new H('张三','男','黄色')
console.log(`姓名:${h1.Name},性别:${h1.Sex},肤色:${h1.fs}`);
h1.hs()
class Huai extends R{
dq:string
hs(){
console.log(this.Name+':'+'做坏事');
}
constructor(Name:string,Sex:string,dq:string){
super(Name,Sex)
this.dq=dq
}
}
let h2:Huai=new Huai('王五','男','北京')
console.log(`姓名:${h2.Name},性别:${h2.Sex},地区:${h2.dq}`);
h2.hs()
1.object类时所有类的父类,没有显示的继承的类都默认继承object,继承了object中转换字符串的toString方法。
2.子类必须调用父类的构造函数,构造函数必须在第一行。
3.super:调用父类的构造函数方法。
4.子类不能继承父类的私有属性和方法。
5.如果需要在子类中调用父类的属性和方法需要使用this关键字
class Person{
constructor(name:string,sex:string){
this.name=name
this.sex=sex
}
name:string
sex:string
eat(){
console.log('人平淡的一天');
}
}
class GoodPerson extends Person{
color:string
sex:string
constructor(name:string,sex:string,color:string){
super(name,sex)
this.color=color
this.sex=sex
}
hs(){
//调用父类的属性和方法需要使用this关键字
console.log(this.sex+'好人都上天堂');
}
6.子类属性和父类属性同名,默认使用子类的属性
//实例化对象
let hr:GoodPerson=new GoodPerson('张三','男','黄')
//调用hs方法
hr.hs()
//子类属性和父类属性同名,默认使用子类的属性
//
7.有种方法可以同名,默认调用子类方法,可以使用super调用父类方法
eat(){
// 调用父类的方法需要使用super关键字
super.eat()
console.log('好人都上天堂');
}
//使用super可以调用父类方法,但是只能写到构造函数里
三. 多态
多态有方法的重载,方法的重写等
1.方法的重载的概念
在同一个类中,方法名相同,返回值和参数不同,ts中无法使用,arkts中使用。
2.方法的重写
子类重写父类的方法,方法名相同,参数相同,返回值相同或者是其子类。
//创建一个父类 A
class A{
a1():void{
console.log('第一个');
}
}
子类 B 继承 父类 A
class B extends A{
a1(): void {
console.log('子类的重写');
}
}
let b:B=new B()
b.a1()