类（class）
😉小例子1：
class F {
name: string;
constructor(name: string) {
this.name = name;
}
getName() {
return "我的名字是：" + this.name;
}
}
let fObj = new F("六卿");
console.log(fObj.getName()); //我的名字是：六卿
console.log(fObj); //F { name: '六卿' }
使用 class 定义类，使用 constructor 定义构造函数。
通过 new 生成新实例的时候，会自动调用构造函数。
😉小例子2（extends and super）：
class F {
name: string;
constructor(name: string) {
this.name = name;
}
getName() {
return "我的名字是：" + this.name;
}
}
class M extends F {
age: number;
constructor(name: string, age: number) {
super(name);
this.age = age;
}
getAge() {
return "我的年龄是：" + this.age;
}
}
let MObj = new M("liuqing", 18);
console.log(MObj.getName());//我的名字是：liuqing
console.log(MObj.getAge());//我的年龄是：18
使用 extends 关键字实现继承，子类中使用 super 关键字来调用父类的构造函数和方法。
这样在M这个类实例化后原型上就会有getName这个父级类F的方法。
👌super需要在构造函数constructor第一行调用哦。
😉小例子3（修饰符）：
修饰符：
public—>被public修饰的属性或者方法，谁也可以调用或者访问。private–>修饰的属性或方法是受保护的，只能在声明类中访问，在子类中不允许被访问的。protected—>修饰的属性或方法是受保护的，它在子类中也是允许被访问。
3.1 public
class F {
public name: string;
constructor(name: string) {
this.name = name;
}
public getName() {
return "我的名字是：" + this.name;
}
}
let fObj = new F("六卿");
console.log(fObj.name) //六卿
console.log(fObj.getName()) //我的名字是：六卿
😉当我们不写修饰符的时候，默认为public修饰符。在任何类中都可以使用F类的name属性和getName方法。
3.2 private
class F {
private name: string;
constructor(name: string) {
this.name = name;
}
private getName() {
return "我的名字是：" + this.name;
}
public returnNameFun() {
return this.name;
}
}
class M extends F {
age: number;
constructor(name: string, age: number) {
super(name);
this.age = age;
}
getAge() {
return "我的年龄是：" + this.age;
}
}
let fObj = new F("六卿");
let MObj = new M("六卿", 18);
// console.log(fObj.name) //属性“name”为私有属性，只能在类“F”中访问
// console.log(MObj.getName()) //属性“getName”为私有属性，只能在类“F”中访问。
console.log(MObj.returnNameFun())
F类中name属性和getName方法都是被privare状态，所以我们在M子类中使用获取不到name属性，使用不了getName方法，但是我们想拿到name的值，我们可以通过returnNameFun方法得到。
3.3 protected
class F {
// 该属性只能自身使用或者子类使用
protected name: string;
constructor(name: string) {
this.name = name;
}
// 该方法只能自身调用或者子类调用
protected getName() {
return "我的名字是：" + this.name;
}
public returnNameFun() {
return this.name;
}
}
class M extends F {
age: number;
constructor(name: string, age: number) {
super(name);
this.age = age;
}
getMyName(){
return super.getName()
}
getAge() {
return "我的年龄是：" + this.age;
}
}
let fObj = new F("六卿");
let MObj = new M("六卿", 18);
// console.log(fObj.name) //属性“name”受保护，只能在类“F”及其子类中访问。
// console.log(MObj.getName()) //属性“name”受保护，只能在类“F”及其子类中访问。
console.log(MObj.getMyName())
console.log(MObj.returnNameFun())
protected修饰符与private修饰符的行为很相似，但有一点不同，protected成员在派生类中仍然可以访问。
😉小例子4（readonly 修饰符）：
readonly关键字将属性设置为只读的。 只读属性必须在声明时或构造函数里被初始化。
当readonly和其他修饰符一起出现的时候，写在其他修饰符后面：
class F {
public readonly name: string;
constructor(name: string) {
this.name = name;
}
}
let fObj = new F("六卿");
console.log(fObj.name,'namenamename')
// fObj.name = 'liuqinga';//Cannot assign to 'name' because it is a read-only property
只能读取，不能重新赋值。
😉小例子5（参数属性）：
参数属性用来修饰函数参数的
例子1：
class F {
constructor(private readonly name: string) {
this.name = name;
}
}
class M {
private readonly name: string;
constructor(name: string) {
this.name = name;
}
}
例子2：
class Person {
constructor(public name: string, public age: number) {
}
}
class Person {
name: string;
age: number;
constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
}
参数属性只是在原有的基础上多了一种写法。
😉小例子6（存取器）：
存取器：通俗点讲就是两个方法，一个方法可以读取属性，另一个方法对属性重新赋值，前提属性的修饰符应该是private或者protected，这样才有意义。
6.1看不使用存储器的例子：
class F {
public fullName: string;
constructor(fullName: string) {
this.fullName = fullName;
}
}
let FObj = new F("liu qing");
FObj.fullName = "六卿";
if (FObj.fullName === "liu qing") {
console.log(`my name is ${FObj.fullName}`);
} else {
console.log(`my new name is ${FObj.fullName}`);//my new name is 六卿
}
我们在F类中定义了fullNmae属性，被public修饰，实例化F类，得到FObj对象，我们重新给fullName属性赋值。
6.2改写成使用get和set的例子：
class F {
private fullName: string;
constructor(fullName: string) {
this.fullName = fullName;
}
// 获取fullName属性值的时候需要实例化对象.getfullName
get getfullName(): string {
return this.fullName;
}
// 重新赋值fullName属性值的时候需要实例化对象.setFullName=xxxx
set setFullName(newName: string) {
this.fullName = newName;
}
}
let FObj = new F("liu qing");
console.log(`my name is ${FObj.getfullName}`);
FObj.setFullName = "六卿";
console.log(`my new name is ${FObj.getfullName}`);
let passcode = "secret passcode";
class Employee {
private _fullName: string;
get fullName(): string {
return this._fullName;
}
set fullName(newName: string) {
if (passcode && passcode == "secret passcode") {
this._fullName = newName;
}
else {
console.log("Error: Unauthorized update of employee!");
}
}
}
let employee = new Employee();
employee.fullName = "Bob Smith";
if (employee.fullName) {
alert(employee.fullName);
}
set不需要返回值，但是需要形参；
调用存储器的方法是直接实例化对象.存储器即可：
get：直接点
set：用作赋值，所以直接赋值即可。
😉小例子7（抽象类）：
abstract 用于定义抽象类和其中的抽象方法。
7.1抽象类是不允许被实例化的：
abstract class F {
constructor(private fullName: string) {
this.fullName = fullName;
}
}
// let FObj = new F("liu qing");//无法创建抽象类的实例
抽象类是不允许被实例化的;
抽象类是不允许被实例化的;
抽象类是不允许被实例化的;
记住了吗？
7.2抽象类中的抽象方法必须被派生类实现：
abstract class F {
constructor(protected fullName: string) {
this.fullName = fullName;
}
abstract getFullNameFun():string;
}
class M extends F{
constructor(name:string){
super(name)
}
getFullNameFun(){
console.log()
return this.fullName
}
}
let MObj =new M("六卿")
console.log(MObj.getFullNameFun())
getFullNameFun为F父类的抽象方法，必须在派生类中实现抽象方法getFullNameFun。
😉小例子8（类也是一种类型）：
abstract class F {
constructor(protected fullName: string) {
this.fullName = fullName;
}
abstract getFullNameFun(): string;
}
class M extends F {
constructor(name: string) {
super(name);
}
getFullNameFun() {
console.log();
return this.fullName;
}
}
let MObj: M = new M("六卿");
console.log(MObj.getFullNameFun());
let MObj: M = new M("六卿");
六卿
见贤思齐焉，见不贤内自省