Inheritance 在TypeScript中,接口可以扩展一个类,为什么?
在 在“使用类作为接口”部分中,有一个扩展类的接口示例Inheritance 在TypeScript中,接口可以扩展一个类,为什么?,inheritance,typescript,interface,Inheritance,Typescript,Interface,在 在“使用类作为接口”部分中,有一个扩展类的接口示例 类点{…} 接口点3D扩展点{…} 这什么时候有用?你有这方面的实际例子吗?以这门课为例: class MyClass { public num: number; public str: string; public constructor(num: number, str: string) { this.num = num; this.str = str; } p
类点{…}
接口点3D扩展点{…}
这什么时候有用?你有这方面的实际例子吗?以这门课为例:
class MyClass {
public num: number;
public str: string;
public constructor(num: number, str: string) {
this.num = num;
this.str = str;
}
public fn(arr: any[]): boolean {
// do something
}
}
您可以这样创建一个实例:
let a1 = new MyClass(4, "hey");
let a2 = {
num: 3,
str: "hey",
fn: function(arr: any[]): boolean {
// do something
}
}
但您也可以创建满足相同精确接口的对象,如下所示:
let a1 = new MyClass(4, "hey");
let a2 = {
num: 3,
str: "hey",
fn: function(arr: any[]): boolean {
// do something
}
}
a1
是MyClass
的实例,而a2
只是一个对象,但它们都实现了相同的接口。
接口扩展类的要点就是,您可以获取类定义的接口并对其进行扩展
也许这只是一种可能,因为语言的性质,但这里有一个例子,说明它可能有用:
class Map<T> {
private _items: { [key: string]: T };
set(key: string, value: T) { ... }
has(key: string): boolean { ... }
get(key: string): T { ... }
remove(key: string): T { ... }
}
interface NumberMap extends Map<number> {}
interface StringMap extends Map<string> {}
interface BooleanMap extends Map<boolean> {}
function stringsHandler(map: StringMap) { ... }
类映射{
私有_项:{[key:string]:T};
集合(键:字符串,值:T){…}
has(key:string):布尔{…}
get(key:string):T{…}
移除(键:字符串):T{…}
}
接口编号映射扩展映射{}
接口StringMap扩展映射{}
接口布尔映射扩展映射{}
函数stringsHandler(映射:StringMap){…}
如中所述:
接口甚至继承基类的私有和受保护成员。这意味着,当您创建一个扩展具有私有或受保护成员的类的接口时,该接口类型只能由该类或其子类实现
这种限制似乎是私有和受保护成员继承的副作用
class Parent
{
private m_privateParent;
}
interface ISomething extends Parent
{
doSomething(): void;
}
class NoonesChild implements ISomething
{
/**
* You will get error here
* Class 'NoonesChild' incorrectly implements interface 'ISomething'.
* Property 'm_privateParent' is missing in type 'NoonesChild'
*/
doSomething()
{
//do something
}
}
class NoonesSecondChild implements ISomething
{
/**
* Nope, this won't help
* Class 'NoonesSecondChild' incorrectly implements interface 'ISomething'.
* Types have separate declarations of a private property 'm_privateParent'.
*/
private m_privateParent;
doSomething()
{
//do something
}
}
class ParentsChild extends Parent implements ISomething
{
/**
* This works fine
*/
doSomething()
{
//Do something
}
}
- 限制接口的使用
- 如果我们不希望任何类可以实现接口,可以使用此解决方案
- 假设接口“I”扩展了类“C”。那么“I”只能由“C”或其子级实现
- 或者,如果一个类需要实现“I”,那么它应该首先扩展“C”
请参见下面的示例
// This class is a set of premium features for cars.
class PremiumFeatureSet {
private cruiseControl: boolean;
}
// Only through this interface, cars can use premium features.
// This can be 'licensed' by car manufacturers to use premium features !!
interface IAccessPremiumFeatures extends PremiumFeatureSet {
enablePremiumFeatures(): void
}
// MyFirstCar cannot implement interface to access premium features.
// Because I had no money to extend MyFirstCar to have PremiumFeatureSet.
// Without feature, what's the use of a way to access them?
// So This won't work.
class MyFirstCar implements IAccessPremiumFeatures {
enablePremiumFeatures() {
}
}
// Later I bought a LuxuryCar with (extending) PremiumFeatureSet.
// So I can access features with implementing interface.
// Now MyLuxuryCar has premium features first. So it makes sense to have an interface to access them.
// i.e. To implement IAccessPremiumFeatures, we need have PremiumFeatureSet first.
class MyLuxuryCar extends PremiumFeatureSet implements IAccessPremiumFeatures {
enablePremiumFeatures() {
// code to enable features
}
}
我也很难理解“你为什么要这样做?”以下是我学到的
如前所述,接口甚至继承基类的私有和受保护成员。这意味着,当您创建一个扩展具有私有或受保护成员的类的接口时,该接口类型只能由该类或其子类实现
假设您正在为用户界面实现控件。您需要按钮、文本框和标签等标准控件
层次结构将是:
class Control{
private state: any;
}
class Button extends Control{
}
class TextBox extends Control{
}
class Label extends Control{
}
请注意控件中的私有状态值。这将很重要
现在假设我们想要一种方法来引用可以由某些激活触发的控件。例如,可以单击按钮。当您输入文本并按enter键时,可以激活文本框。然而,标签是装饰性的,所以用户不能用它做任何事情
我们可能需要一种引用这些控件的方法,这样我们就可以只使用这些类型的控件来做一些事情。例如,我们可能需要一个接受控件作为参数的函数,但我们只需要可以激活的控件
假设我们试图用一个不扩展类的简单接口来描述这些控件(这是不正确的,但我稍后会解释原因)
实现接口的任何内容都可以被视为ActivatableControl,因此,让我们更新层次结构:
class Control{
private state: any;
}
interface ActivatableControl{
activate(): void;
}
class Button extends Control implements ActivatableControl{
activate(){}
}
class TextBox extends Control implements ActivatableControl{
activate(){}
}
class Label extends Control{}
如上所述,Label不实现ActivatableControl。所以一切都很好,对吗
问题在于-我可以添加另一个实现ActivatableControl的类:
class Dishwasher implements ActivatableControl{
activate(){}
}
class TextBox extends Control {
activate(){}
}
该界面的用途是用于可以激活的控件,而不是用于不相关的对象
所以我真正想要的是指定一个接口,该接口要求某些控件是可激活的,而不是其他
为此,我让我的界面扩展控件,如下所示:
class Control{
private state: any;
}
interface ActivatableControl extends Control {
activate(): void;
}
由于控件具有私有值,只有控件的子类才能实现ActivatableControl
现在,如果我尝试这样做:
// Error!
class Dishwasher implements ActivatableControl{
activate(){}
}
因为洗碗机不是控件,所以我会得到一个打字脚本错误
附加说明:如果一个类扩展了控件并实现了activate,那么它可以被视为ActivatableControl。本质上,该类实现了接口,即使接口没有显式声明
因此,下面的TextBox实现仍然允许我们将其视为ActivatableControl:
class Dishwasher implements ActivatableControl{
activate(){}
}
class TextBox extends Control {
activate(){}
}
这是层次结构的最终版本,一些代码显示了我可以用它做什么:
class Control {
private state: any;
}
interface ActivatableControl extends Control {
activate(): void;
}
class Button extends Control implements ActivatableControl {
activate() { }
}
// Implicitly implements ActivatableControl since it matches the interface and extends Control.
class TextBox extends Control {
activate() { }
}
class Label extends Control {
}
// Error - cannot implement ActivatableControl because it isn't a Control
/*
class Dishwasher implements ActivatableControl {
activate() { }
}
*/
// Error - this won't work either.
// ActivatableControl extends Control, and therefore contains state as a private member.
// Only descendants of Control can implement ActivatableControl.
/*
class Microwave implements ActivatableControl {
private state: any;
activate() { }
}
*/
let button: Button = new Button();
let textBox: TextBox = new TextBox();
let label: Label = new Label();
let activatableControl: ActivatableControl = null;
// I can assign button to activatableControl.
activatableControl = button;
// Same with textBox since textBox fulfills the contract of an ActivatableControl.
activatableControl = textBox;
// Error - label does not implement ActivatableControl
// nor does it fulfill the contract.
//activatableControl = label;
function activator(activatableControl: ActivatableControl){
// I can assume activate can be called
// since ActivatableControl requires that activate is implemented.
activatableControl.activate();
}