TypeScript面向对象(学习笔记)

一、类的简介

1.使用class关键字来定义一个类；
2. 对象中主要包含了两个部分：属性、方法；
3. 属性包括：实例属性、静态属性；

class Person{
	name:string = '孙悟空';
	age:number = 18;
	static sex:string = '男';
	}

4.方法包括：实例方法、静态方法；

sayHell0(){
	console.log('hello');
	}
static sayHi(){
	console.log('hi');
	}

5.区别：实例属性和实例方法，通过new的对象的实例可以访问；静态属性和静态方法，无需new对象，可以直接访问

const per = new Person();
console.log(per);
console.log(per.name,per.age);
console.log(Person.sex);
per.sayHello();
Person.sayHi();

二、构造函数
1.constructor 构造函数，会在对象创建的时候调用

class Dog{
	name:string;
	age:number;
	constructor(name:string,age:number)				{ console.log('构造函数执行了');
	this.name = name;
	this.age = age;
	}
	back(){
	alter('汪汪汪')
	console.log(this);
	}
	}
	const dog = new Dog("小黑",18);
	const dog2 = new Dog("小贝",20);
	console.log(dog);
	console.log(dog2);
	dog.back();
	dog2.back();
	

三、类的继承
1.Dog extends Animal
此时，Animal被称为父类，Dog被称为子类；
2.使用方法和继承后，子类将会拥有父类所有的方法和属性；
3.通过继承可以将子类中的共有代码写在一个父类中（这样写只需写一次即可让所有的子类都同时拥有父类中的属性，如果希望在子类中添加一些父类中没有的属性或者方法直接加就行了）
4.如果子类中添加了和父类相同的方法，则子类方法会覆盖掉父类的方法，这种子类覆盖掉父类方法的形式，叫做重写

（function(){
	class Animal{
	name:string;
	age:number;
	constructor(name:string,age:number)  {
	this.name = name;
	this.age = age 
	}
	sayHello(){
	console.log('动物在叫');
	}
	}
	
	class Cat extends Animal{
	sayHello(){
		console.log('喵喵咪哦啊');
		}
		}
		const dog = new Dog('黑背',3)
		const cat = new Cat('咪咪',8)
		

四、super关键字

（function(){
	class Animal{
		name:string;
		constructor(name:string){
		this.name = name;
		}
		sayHello(){
		console.log('动物在叫');
		} 
		}
	class Dog extends Animal{
	age;number;
	constructor(age:number){
	super(name);//调用父类的构造函数
	this.age = age;
	}
	sayHello(){
	super.sayHello();
	}
	}
	dog.sayHello();
	})
	
		

五、抽象类
1.以abstract开头的类是抽象类
2.抽象类和其他类区别不大，只是不能用来创建对象
3.抽象类就是专门用来被继承的类
4.抽象类中可以添加抽象方法
5.抽象方法使用abstract开头，没有方法体；
6.抽象方法只能定义在抽象类中，子类必须对抽象方法进行重写

abstract class Aniaml{
name:string;
constructor(name:string){
this.name = name;
abstract sayHello();void();
}
class Dog extends Animal{
	sayHello(){
	console.log('hello');
	}
	}

六、接口

1.接口用来定义一个类结构,用来定义一个类中应该包含哪些属性和方法；
2.接口可以定义类的时候去限制类的结构；
3.接口中的所有属性都不能有实际的值；
4.接口只定义对象的结构，而不考虑实际值；
5.在接口中所有的方法都是抽象方法；

interface MyInter{
	name:string;
	sayHello();void;
	}

class MyClass implements myInter{
	name:string;
	constructor(name:string){
	this.name = name;
	}
	sayHello(){
		console.log('大家好');
		}
		}

七、属性的封装
1.ts可以在属性前加修饰符
2.public 修饰的属性可以在任意位置访问 默认值
3.private 私有属性，私有属性只能在类的内部访问，通过在类中添加方法使得私有属性可以被外部访问
4.定义方法，用来获取name属性,getter方法用来读取属性,setter方法用来修改属性,被称为属性的存取器

class Person{
		private _name: string;
        private _age: number;
        constructor(name:string,age:number){
            this._name = name;
            this._age = age;
        }
        get name(){
            return this._name;
        }
        set name(value:string){
            this._name = value;
        }
        get age(){
            return this._age;
        }
        set age(value:number){
            this._age = value;
        }
    }
    const per = new Person('孙悟空',18)
    per.name = '猪八戒';
    per.age = 18;
    console.log(per);
    }