TypeScript中的⽅法重载（38）
实例成员的访问修饰符
1、public 开放的/公开的。
当创建⼀个类时，成员默认的修饰符为public
class Person{
public name: string;
public constructor(name: string) {
this.name= name;
}
public Speak() :string {
alert("Hello, " + this.name);
}
}
let ps= new Person("world");
ps.Speak() // 通过实例化后的对象调⽤类⾥的⽅法
就拿上⼀篇⽂章中定义的类举例，所有属性和⽅法之前，如果不加其他的访问修饰符，成员默认的修饰符都为public。
2、private 私有的。
只能在类的内部访问 private修饰的成员，当前类的实例也不能访问，且不能被继承，继承后的对象实例化后也不能访问。constructor 也可以被 private访问修饰符修饰。
class Animal {
private name: string;
constructor(theName: string) { this.name = theName; }
}
new Animal("Cat").name; // 错误: 'name' 是私有的.
当被protected访问修饰符修饰的成员，相当于给成员穿了⼀层防护。类的实例不能访问，不能被继承。
3、protected 受保护的。
与private不同的是，⽗类constructor中如果有属性，继承后的constructor中就得有super（），protected成员在派⽣类中依然可以访问（注：只能在⼦类 中 获取⽗类的受保护的属性⽅法）。被继承后的实例也不能访问。
super()：执⾏⽗类的构造函数。
class Animal {
protected name: string
constructor(theName: string) {
this.name = theName;
}
run(distance: number) {
// this.name='xiaohuang'
console.log(`${this.name} moved ${distance}`)
console.log(this.name)
}borrow的用法
}
class Dog extends Animal{
constructor(name: string) {
super(name)
}
}
let animals = new Animal('xg')
let dog = new Dog('xxx')
dog.name // 访问不到
当属性name被访问修饰符protected修饰后，只能在类的内部访问 name属性，可以被继承，只能在派⽣类中能访问，继承后的实例也不能够访问。
成绩单英文
4、readonly 只读的。
不能被修改。可以被继承 但是继承后的实例还是不能修改只读成员。
class Octopus {
readonly name: string;
readonly numberOfLegs: number = 8;
constructor (theName: string) {
this.name = theName;
}
}
let dad = new Octopus("Man with the 8 strong legs");
dad.name = "Man with the 3-piece suit"; // 错误! name 是只读的.
存取器
TypeScript⽀持通过get/t来截取对 对象成员 的访问。 它能帮助你有效的控制对对象成员的访问。
let passcode = "cret passcode";
class Employee {
private _fullName: string;
get fullName(): string {
return this._fullName;
}
t fullName(newName: string) {
if (passcode && passcode == "cret passcode") {
this._fullName = newName;
}
el {
console.log("Error: Unauthorized update of employee!");
}
}
}
let employee = new Employee();
employee.fullName = "Bob Smith";
if (employee.fullName) {
alert(employee.fullName);
}
我们可以随意的设置 fullName，这是⾮常⽅便的，但是这也可能会带来⿇烦。
我们可以修改⼀下密码，来验证⼀下存取器是否是⼯作的。当密码不对时，会提⽰我们没有权限去修改员⼯。
静态属性（static）
概念：不需要被实例化 访问的成员 称之为 静态成员，即只能被当前类访问的成员
和访问修饰符成员相似，static修饰的成员属性或是⽅法 ，只能通过类名. 成员名称 访问。不能够通过 实例对象 访问静态成员 。
class Grid {
static origin = {x: 0, y: 0};
calculateDistanceFromOrigin(point: {x: number; y: number;}) {在线听力
let xDist = (point.x - igin.x);
let yDist = (point.y - igin.y);
return Math.sqrt(xDist * xDist + yDist * yDist) / this.scale;
}
constructor (public scale: number) { }
}
let grid1 = new Grid(1.0); // 1x scale
let grid2 = new Grid(5.0); // 5x scale
console.log(grid1.calculateDistanceFromOrigin({x: 10, y: 10}));用英文怎么读
console.log(grid2.calculateDistanceFromOrigin({x: 10, y: 10}));
抽象类（abstract）
抽象类 使⽤abstract 修饰，抽象类可以有普通的⽅法，也可以有抽象的⽅法，但是抽象的⽅法不能被实现，只能在派⽣类中实现（普通类中不能有抽象的⽅法），抽象类不能够被实例化。
不同于接⼝，抽象类可以包含成员的实现细节
abstract class Animal {
abstract makeSound(): void;
move(): void {
console.log('roaming ');
}
}
接⼝与抽象类的区别：
相同点：少儿篮球培训班>appeal to
blundering1、都不能被实例化。
2、接⼝的实现类和抽象类的⼦类只有全部实现了接⼝或者抽象类中的⽅法后才可以被实例化。
不同点：
1、接⼝只能定义抽象⽅法不能实现⽅法，抽象类既可以定义抽象⽅法，也可以实现⽅法。
2、单继承，多实现。接⼝可以实现多个，只能继承⼀个抽象类。
3、接⼝强调的是功能，抽象类强调的是所属关系。
4、接⼝中的所有成员变量 为public static final， 静态不可修改，当然必须初始化。接⼝中的所有⽅法都是public abstract 公开抽象的。⽽且不能有构造⽅法。抽象类就⽐较⾃由了，和普通的类差不多，可以有抽象⽅法也可以没有，可以有正常的⽅法，也可以没有。
英文搜索引擎
⽅法重载
⽅法名相同，参数类型或个数不同，返回类型可以相同也可以不同。
（可以根据所传递进来的不同参数，决定具体调⽤哪个函数。）
相同点：
1、都不能被实例化。
add up2、接⼝的实现类和抽象类的⼦类只有全部实现了接⼝或者抽象类中的⽅法后才可以被实例化。
不同点：
1、接⼝只能定义抽象⽅法不能实现⽅法，抽象类既可以定义抽象⽅法，也可以实现⽅法。
2、单继承，多实现。接⼝可以实现多个，只能继承⼀个抽象类。
3、接⼝强调的是功能，抽象类强调的是所属关系。
4、接⼝中的所有成员变量 为public static final， 静态不可修改，当然必须初始化。接⼝中的所有⽅法都是public abstract 公开抽象
qd
的。⽽且不能有构造⽅法。抽象类就⽐较⾃由了，和普通的类差不多，可以有抽象⽅法也可以没有，可以有正常的⽅法，也可以没有。
⽅法重载与⽅法重写的区别：
⽅法的重写（Overrriding）：当⼀个类继承另外⼀个类的时候，那么该类（⼦类/派⽣类）就拥有了其⽗类（基类）的成员⽅法和成员变量。在⼦类当中，可以创建属于⾃⼰独有的成员，如果创建了⼀个与⽗类中名称相同、参数列表相同的⽅法，只是⽅法体中的实现形式不相同，以实现与⽗类的功能不相同，这种⽅式就被称为⽅法的重写，也被称为⽅法的覆盖。
（）
⽅法的重载（Overloading）：⽅法的重载是指在⼀个类当中，有多个⽅法，⽽且这些⽅法的名字是相同的，但是参数列表和返回值是不相同，当重载的时候，⽅法名的名称是被共享的，但是参数类型和参数个数是不相同的，返回值类型可以相同也可以不相同。
