`(function () {
//描述一个对象的类型
type myType = {
name: string,
age: number
}
const obj: myType = {
name: "sss",
age: 111
}
//接口，定义一个类结构,用来定义一个类中应该包含哪些属性和方法
// 接口中所有方法都是抽象方法，没有返回值
//可以重名，想当于合并，并集
interface myInterface{
name: string,
age: number
}
interface myInterface{
gender:string
sayHello():void
}
const obj1: myInterface = {
name: "sss",
age: 111,
gender:"man",
sayHello(){
console.log("gogogogo");
}
}
interface myInter{
name:string,
sayHello():void
}
// 实现接口
class myClass implements myInter {
name :string;
constructor(name:string){
this.name = name
}
sayHello(): void {
console.log("gogog222");
}
}
})()`
`//继承 。直接写就可以，然后如果有单独需求，自己在自己的类里写，子类中如果有和父类相同的方法，那么就会覆盖父类的方法「重写」 (function (){
//abstract 代表抽象类，不能用来创建实例，只用来继承
// abstract class Animal{
abstract class Animal{
// public 修饰地属性可以在任意位置访问修改 // private 私有属性，只可以在类内部修改 // protected 受保护的属性，只能在当前类和当前类的子类访问，新建的实例不可以
private name:string;
age:number
constructor(name:string,age:number){
// this.name = name;
this.age = age;
}
// sayHello(){
// console.log("gogogo");
// }
//抽象方法，只定义，没方法体，必须在子类中自行定义
abstract sayHello() : void
//get xxx set xxx 是可以读取修改private的属性的，避免直接修改，但是下面创建实例调用的时候还直接写
// 实例.属性就可以 默认会调用此方法读取、修改属性的值
get name1(){
return this.name
}
set name1 (value:string){
this.name = value
}
}
class Dog extends Animal{
sayHello(){
console.log("gogogo");
}
run(){
// console.log(`${this.name}run`);
}
}
class Cat extends Animal{
sayHello(){
console.log("gogogo_cat");
}
}
class Dog_b extends Animal{
// 如果在子类中写了构造函数constructor，会覆盖父类中的构造函数，所以，需要用super调用一下父类中的构造函数，在添加自己其他的
thing:string
constructor(name:string,age:number,thing:string){
super(name,age)
this.thing = thing
}
sayHello() {
//super.xxx 在类的方法中super就表示当前类的父类
// super.sayHello()
}
}
const d1 = new Dog("white",2);
console.log(d1);
d1.run()
const c1 = new Cat("black",1);
console.log(c1);
const db = new Dog_b("white_black",3,"iiii")
console.log(db);
//语法糖，和上面效果一样🍬
class C{
constructor(public name :string , public age : number){
}
}
})()`
