typescript 类的属性是接口 typescript的特性

【有哪些特点】

1.封装 2.继承3.重写4.抽象

一.面向对象的特点

TS中属性具有三种修饰符**：

- public（默认值），可以在类、子类和对象中修改

 - protected ，可以在类、子类中修改

- private ，可以在类中修改

不使用任何修饰符，建立模型

//面向对象----将生活中具体事物通过程序代码镜像抽象化---通过class创建类-----属性（事物的特征）与方法（事物的功能）

//1.创建类----抽象化的对象
class Student{
    //实例属性
    name:string;
    age:number;
   //创建构造函数---需要构建这个函数才能进行多个值书写
constructor(name: string, age: number){
    this.name = name;
    this.age = age;
}
    //实例方法
    playGame(gameName:string){
        console.log(`${this.name}喜欢玩${gameName}`);
    }
}

//2.使用类
//实例化对象
let s1=new Student("张三",22);
//使用类中方法
s1.playGame("王者荣耀")
//获取数据
console.log(s1.age);
//修改数据
s1.name="小红"

结果：

1.封装

（1）.public（默认值），可以在类、子类和对象中修改---不需要get与set（读取属性的方法叫做setter方法，设置属性的方法叫做getter方法 ）

例题1.public修饰名字，和方法（方法一样，可去举一反三，根据所需求）

//面向对象----将生活中具体事物通过程序代码镜像抽象化---通过class创建类-----属性（事物的特征）与方法（事物的功能）

//1.创建类----抽象化的对象
class Student {
    //实例属性
  public  name: string;
    age: number;
    //创建构造函数---需要构建这个函数才能进行多个值书写
    constructor(name: string, age: number) {
        this.name = name;
        this.age = age;
    }
    //实例方法
    public playGame(gameName: string) {
        console.log(`${this.name}喜欢玩${gameName}`);
    }
}

//2.使用类
//实例化对象
let s1 = new Student("张三", 22);
//使用类中方法
s1.playGame("王者荣耀")
//获取数据
console.log(s1.name);
//修改数据
s1.name = "1111"
console.log(s1);

结果：

结论： 用public修饰符可以在可以在类、子类和对象中修改属性值。不会报错，是公开修饰符。

（2）protected ，可以在类、子类中修改---需要用到get与set

例题2：（会有报错）

 修改：

//面向对象----将生活中具体事物通过程序代码镜像抽象化---通过class创建类-----属性（事物的特征）与方法（事物的功能）

//1.创建类----抽象化的对象
class Student {
    //实例属性
    protected name: string;
    age: number;
    //创建构造函数---需要构建这个函数才能进行多个值书写
    constructor(name: string, age: number) {
        this.name = name;
        this.age = age;
    }

    //实例方法
    protected playGame(gameName: string) {
        console.log(`${this.name}喜欢玩${gameName}`);
    }
    get name1() {
        return this.name;
    }
    set name1(name: string) {
        this.name = name
    }
    fn() {
        this.playGame("")
    }
}

//2.使用类
//实例化对象
let s1 = new Student("张三", 22);
//使用类中方法
// s1.playGame("王者荣耀") //不能这样调用--会报错
//获取数据
console.log(s1.name1);
//修改数据
s1.name1 = "1111"
console.log(s1);
//调用方法
s1.fn()//---调用方法  需要用函数来调用

结果：

结论： 用protected修饰符可以在类、子类中修改，但如果要在对象内修改，需要用到get与set方法。

（2）private ，可以在类中修改

例题3：（会有报错）

修改： 

//面向对象----将生活中具体事物通过程序代码镜像抽象化---通过class创建类-----属性（事物的特征）与方法（事物的功能）

//1.创建类----抽象化的对象
class Student {
    //实例属性
    private name: string;
    age: number;
    //创建构造函数---需要构建这个函数才能进行多个值书写
    constructor(name: string, age: number) {
        this.name = name;
        this.age = age;
    }

    //实例方法
    private playGame(gameName: string) {
        console.log(`${this.name}喜欢玩${gameName}`);
    }
    get name1() {
        return this.name;
    }
    set name1(name: string) {
        this.name = name
    }
    fn() {
        this.playGame("gameName: string")
    }
}

//2.使用类
//实例化对象
let s1 = new Student("张三", 22);
//使用类中方法
// s1.playGame("王者荣耀") //不能这样调用--会报错
//获取数据
console.log(s1.name1);
//修改数据
s1.name1 = "1111"
console.log(s1);
//调用方法
s1.fn()//---调用方法  需要用函数来调用

结果：

补充：

例题：

//面向对象----将生活中具体事物通过程序代码镜像抽象化---通过class创建类-----属性（事物的特征）与方法（事物的功能）

//1.创建类----抽象化的对象
class Student {
    //实例属性
    name: string;
    age: number;
    static sex: string = "25岁" //静态设置常量
    //创建构造函数---需要构建这个函数才能进行多个值书写
    constructor(name: string, age: number) {
        this.name = name;
        this.age = age;
    }

    //实例方法
    playGame(gameName: string) {
        console.log(`${this.name}喜欢玩${gameName}`);
    }

}

//2.使用类
//实例化对象
let s1 = new Student("张三", 22);
//获取常量
console.log(Student.sex);

结果：

2.继承

通过继承可以将其他类中的属性和方法引入到当前类中（将父中的属性由子中继承）

//继承

class Fu{
    //属性
    name:string;
   age:number;
    //构造函数
    constructor(u_name:string,u_age:number){
        this.name=u_name,
        this.age=u_age
    }
    //方法
    fuFn(){
        console.log("父类方法");
    }
}


//子类
class Son extends Fu{
    sonFn(){
        this.name="小明"
        // this.age=22----私有只能在类中修改使用
    }
    
}
//实例化子类
let son = new Son("张三",20);
console.log(son);
// console.log(son.name,son.age);
son.fuFn()

son.sonFn()//调用方法
console.log(son);

结果：

 3.重写

发生继承时，如果子类中的方法会替换掉父类中的同名方法，这就称为方法的重写

实例：

//重写

class Fu{
    //属性
    name:string;
   age:number;
    //构造函数
    constructor(u_name:string,u_age:number){
        this.name=u_name,
        this.age=u_age
    }
    //方法
    fuFn(){
        console.log("父类方法");
    }
}


//子类
class Son extends Fu{
    //重写----父类方法名与子类的方法名称一致
    fuFn(){
        console.log("子类方法");
    }
    
}
//实例化子类
let son = new Son("张三",20);
son.fuFn()

结果：

4. 抽象类

抽象类是专门用来被其他类所继承的类，它只能被其他类所继承不能用来创建实例

实例：

//抽象化----用于子类继承  不能实例化

abstract class Fu {
    //属性
    name: string;
    age: number;
    //构造函数
    constructor(u_name: string, u_age: number) {
        this.name = u_name,
            this.age = u_age
    }
    //方法
    abstract fn(): void//必须在子类中进行重写
}


//子类
class Son extends Fu {
    fn(): void {
        console.log("子类方法1");
    }

}
//实例化子类
let son = new Son("张三", 20);

son.fn()

结果：

 

二.接口

 实例：1.制造一个汽车接口

 2.在创建一个关于接口的类

class Bom implements Car{
    brand:string;
    color:string
    seat:number
    price:number
    consumption:string
    constructor( brand:string,color:string,seat:number,price:number,consumption:string){
      this.brand=brand,
      this.color=color,
      this.price=price,
      this.seat=seat,
      this.consumption=consumption
    }

    //重写
    run() {
        
    }
    listen() {
        
    }
    playGame(){

    }
}
let bom=new Bom("宝马x5","blue",4,800000,"2.0T")
console.log(bom);

注意：在类中可以添加接口没有的属性与方法，但接口中有的属性与方法，类中必须继承

三.泛型

当函数的参数，返回值类型不确定的情况，可以泛型

1.单个使用

function fn<T>(a:T):T{
  return a
}

（1）在不知道类型的情况下使用

（2）指定类型 

2.多个使用 

返回值指定那个，就确定哪个类型的值

（1） 在不知道类型的情况下使用

 （2）指定类型