Dart官方文档翻译(二)（Dart之旅）

对象具有由函数和数据（分别为方法和实例变量）组成的成员。调用方法时，可以在对象上调用它：该方法可以访问该对象的函数和变量。使用点（.）来引用实例变量或方法：

varp=Point(2,2);//Setthevalueoftheinstancevariabley.p.y=3;//Getthevalueofy.assert(p.y==3);//InvokedistanceTo()onp.numdistance=p.distanceTo(Point(4,4));当最左边的操作数有可能为null时，使用.而不是.避免异常：

//Ifpisnon-null,setitsyvalueto4.p.y=4;使用构造函数构造函数用来创建对象.构造函数的名称可以为类名或者其他类方法.比如你可以用Point的Point（）构造函数或者Point.fromJson():

varp1=Point(2,2);varp2=Point.fromJson({'x':1,'y':2});以下代码具有相同的效果，但new在构造函数名称之前使用可选关键字：

varp=constImmutablePoint(2,2);构造两个相同的编译时常量会产生一个规范的实例：

常量构造函数如果传递相同的参数，仅仅会存在一个对象，不会重复创建！！！

vara=constImmutablePoint(1,1);varb=constImmutablePoint(1,1);//常量构造函数如果传递相同的参数，仅仅会存在一个对象，不会重复创建！！！assert(identical(a,b));//Theyarethesameinstance!在常量上下文中，您可以省略const构造函数或文字之前的内容。例如，查看此代码，该代码创建一个const映射：

//Lotsofconstkeywordshere.constpointAndLine=const{'point':const[constImmutablePoint(0,0)],'line':const[constImmutablePoint(1,10),constImmutablePoint(-2,11)],};您可以省略除const关键字的第一次使用之外的所有内容：

//Onlyoneconst,whichestablishestheconstantcontext.constpointAndLine={'point':[ImmutablePoint(0,0)],'line':[ImmutablePoint(1,10),ImmutablePoint(-2,11)],};如果常量构造函数在常量上下文之外并且在没有const它的情况下调用，则会创建一个非常量对象：

print('Thetypeofais${a.runtimeType}');到目前为止，您已经了解了如何使用类。本节的其余部分将介绍如何实现类。

classPoint{numx;//Declareinstancevariablex,initiallynull.numy;//Declarey,initiallynull.numz=0;//Declarez,initially0.}所有未初始化的实例变量都具有该值null。

classPoint{numx,y;Point(numx,numy){//There'sabetterwaytodothis,staytuned.this.x=x;this.y=y;}}//该this关键字是指当前实例。注意：有名称冲突时，才使用this。否则，Dart风格省略了this。

将构造函数参数赋值给实例变量的模式是如此常见，Dart具有语法糖，使其变得简单：classPoint{numx,y;

//Syntacticsugarforsettingxandy//beforetheconstructorbodyruns.Point(this.x,this.y);}

使用命名构造函数为类实现多个构造函数：

classPoint{numx,y;Point(this.x,this.y);//NamedconstructorPoint.origin(){x=0;y=0;}}请记住，构造函数不是继承的，这意味着超类的命名构造函数不会被子类继承。如果希望使用超类中定义的命名构造函数创建子类，则必须在子类中实现该构造函数。

如果超类没有未命名的无参数构造函数，则必须手动调用超类中的一个构造函数。在冒号（:）之后，在构造函数体（如果有）之前指定超类构造函数。

在下面的示例中，Employee类的构造函数为其超类Person调用命名构造函数。

classPerson{StringfirstName;Person.fromJson(Mapdata){print('inPerson');}}classEmployeeextendsPerson{//Persondoesnothaveadefaultconstructor;//youmustcallsuper.fromJson(data).Employee.fromJson(Mapdata):super.fromJson(data){print('inEmployee');}}main(){varemp=newEmployee.fromJson({});//Prints://inPerson//inEmployeeif(empisPerson){//Typecheckemp.firstName='Bob';}(empasPerson).firstName='Bob';}因为在调用构造函数之前会计算超类构造函数的参数，所以参数可以是一个表达式，例如函数调用：

classEmployeeextendsPerson{Employee():super.fromJson(getDefaultData());//···}警告：超类构造函数的参数无权访问this。例如，参数可以调用静态方法，但不能调用实例方法。

除了调用超类构造函数之外，还可以在构造函数体运行之前初始化实例变量。用逗号分隔初始化程序。

//Initializerlistsetsinstancevariablesbefore//theconstructorbodyruns.Point.fromJson(Mapjson):x=json['x'],y=json['y']{print('InPoint.fromJson():($x,$y)');}警告：初始化程序的右侧无权访问this。

在开发期间，您可以通过assert在初始化列表中使用来验证输入。

Point.withAssert(this.x,this.y):assert(x>=0){print('InPoint.withAssert():($x,$y)');}设置最终字段时，初始化程序列表很方便。以下示例初始化初始化列表中的三个最终字段。

import'dart:math';classPoint{finalnumx;finalnumy;finalnumdistanceFromOrigin;Point(x,y):x=x,y=y,distanceFromOrigin=sqrt(x*x+y*y);}main(){varp=newPoint(2,3);print(p.distanceFromOrigin);}重定向构造函数有时构造函数的唯一目的是重定向到同一个类中的另一个构造函数。重定向构造函数的主体是空的，构造函数调用出现在冒号（:)之后。

classPoint{numx,y;//Themainconstructorforthisclass.Point(this.x,this.y);//Delegatestothemainconstructor.Point.alongXAxis(numx):this(x,0);}常量构造函数如果您的类生成永远不会更改的对象，则可以使这些对象成为编译时常量。为此，请定义const构造函数并确保所有实例变量都是final。

factory关键字在实现不总是创建其类的新实例的构造函数时使用。例如，工厂构造函数可能从缓存中返回实例，或者它可能返回子类型的实例。

以下示例演示了从缓存中返回对象的工厂构造函数：

classLogger{finalStringname;boolmute=false;//_cacheislibrary-private,thanksto//the_infrontofitsname.staticfinalMap_cache={};factoryLogger(Stringname){if(_cache.containsKey(name)){return_cache[name];}else{finallogger=Logger._internal(name);_cache[name]=logger;returnlogger;}}Logger._internal(this.name);voidlog(Stringmsg){if(!mute)print(msg);}}注意：工厂构造函数无权访问this。

像调用任何其他构造函数一样调用工厂构造函数：varlogger=Logger('UI');logger.log('Buttonclicked');

方法是为对象提供行为的函数。

对象的实例方法可以访问实例变量和this。在distanceTo()下面的示例中方法是一个实例方法的一个例子：

import'dart:math';classPoint{numx,y;Point(this.x,this.y);numdistanceTo(Pointother){vardx=x-other.x;vardy=y-other.y;returnsqrt(dx*dx+dy*dy);}}Gettersandsettersgetter和setter是提供对象属性的读写访问权限的特殊方法。回想一下，每个实例变量都有一个隐式getter，如果合适的话还有一个setter。您可以使用get和set关键字通过实现getter和setter来创建其他属性：

classRectangle{numleft,top,width,height;Rectangle(this.left,this.top,this.width,this.height);//Definetwocalculatedproperties:rightandbottom.numgetright=>left+width;setright(numvalue)=>left=value-width;numgetbottom=>top+height;setbottom(numvalue)=>top=value-height;}voidmain(){varrect=Rectangle(3,4,20,15);assert(rect.left==3);rect.right=12;assert(rect.left==-8);}使用getter和setter，您可以从实例变量开始，稍后使用方法包装它们，而无需更改客户端代码。

注意：无论是否明确定义了getter，增量（++）等运算符都以预期的方式工作。为避免任何意外的副作用，操作员只需调用一次getter，将其值保存在临时变量中。

//Thisclassisdeclaredabstractandthus//can'tbeinstantiated.abstractclassAbstractContainer{//Defineconstructors,fields,methods...voidupdateChildren();//Abstractmethod.}隐式接口每个类都隐式定义一个接口，该接口包含该类的所有实例成员及其实现的任何接口。如果要在不继承B实现的情况下创建支持B类API的A类，则A类应实现B接口。

/Aperson.Theimplicitinterfacecontainsgreet().classPerson{//Intheinterface,butvisibleonlyinthislibrary.final_name;//Notintheinterface,sincethisisaconstructor.Person(this._name);//Intheinterface.Stringgreet(Stringwho)=>'Hello,$who.Iam$_name.';}//AnimplementationofthePersoninterface.classImpostorimplementsPerson{get_name=>'';Stringgreet(Stringwho)=>'Hi$who.DoyouknowwhoIam';}StringgreetBob(Personperson)=>person.greet('Bob');voidmain(){print(greetBob(Person('Kathy')));print(greetBob(Impostor()));}这是一个指定类实现多个接口的示例：

classPointimplementsComparable,Location{...}扩展类使用extends创建一个子类，并super指超：

classTelevision{voidturnOn(){_illuminateDisplay();_activateIrSensor();}//···}classSmartTelevisionextendsTelevision{voidturnOn(){super.turnOn();_bootNetworkInterface();_initializeMemory();_upgradeApps();}//···}复写成员子类可以覆盖实例方法，getter和setter。您可以使用@override注释来指示您有意覆盖成员：

您可以覆盖下表中显示的运算符。例如，如果定义Vector类，则可以定义+添加两个向量的方法。

注意：您可能已经注意到，这!=不是可覆盖的运算符。表达e1!=e2只是语法糖!(e1==e2)。

这是一个覆盖+和-运算符的类的示例:

要在代码尝试使用不存在的方法或实例变量时检测或做出反应，您可以覆盖noSuchMethod()：

classA{//UnlessyouoverridenoSuchMethod,usinga//non-existentmemberresultsinaNoSuchMethodError.@overridevoidnoSuchMethod(Invocationinvocation){print('Youtriedtouseanon-existentmember:'+'${invocation.memberName}');}}你不能调用一个未实现的方法除非满足一下至少一个条件：

assert(Color.red.index==0);assert(Color.green.index==1);assert(Color.blue.index==2);要获取枚举中所有值的列表，请使用枚举values常量。

varaColor=Color.blue;switch(aColor){caseColor.red:print('Redasroses!');break;caseColor.green:print('Greenasgrass!');break;default://Withoutthis,youseeaWARNING.print(aColor);//'Color.blue'}枚举类型具有以下限制：

Mixins是一种在多个类层次结构中重用类代码的方法。

要使用mixin，请使用with关键字后跟一个或多个mixin名称。以下示例显示了两个使用mixins的类：

mixinMusical{boolcanPlayPiano=false;boolcanCompose=false;boolcanConduct=false;voidentertainMe(){if(canPlayPiano){print('Playingpiano');}elseif(canConduct){print('Wavinghands');}else{print('Hummingtoself');}}}要指定只有某些类型可以使用mixin-例如，所以你的mixin可以调用它没有定义的方法-用于on指定所需的超类：

使用static关键字实现类范围的变量和方法。

静态变量（类变量）对于类范围的状态和常量很有用：

classQueue{staticconstinitialCapacity=16;//···}voidmain(){assert(Queue.initialCapacity==16);}静态变量在使用之前不会初始化。

静态方法（类方法）不对实例进行操作，因此无权访问this。例如：

import'dart:math';classPoint{numx,y;Point(this.x,this.y);staticnumdistanceBetween(Pointa,Pointb){vardx=a.x-b.x;vardy=a.y-b.y;returnsqrt(dx*dx+dy*dy);}}voidmain(){vara=Point(2,2);varb=Point(4,4);vardistance=Point.distanceBetween(a,b);assert(2.8

您可以使用静态方法作为编译时常量。例如，您可以将静态方法作为参数传递给常量构造函数。

类型安全通常需要泛型，但它们比仅允许代码运行有更多好处：

正确指定泛型类型会产生更好的生成代码。

varnames=List();names.addAll(['Seth','Kathy','Lars']);names.add(42);//Error使用泛型的另一个原因是减少代码重复。泛型允许您在多种类型之间共享单个接口和实现，同时仍然利用静态分析。例如，假设您创建了一个用于缓存对象的接口：

abstractclassObjectCache{ObjectgetByKey(Stringkey);voidsetByKey(Stringkey,Objectvalue);}您发现需要此接口的特定于字符串的版本，因此您需要创建另一个接口：

abstractclassStringCache{StringgetByKey(Stringkey);voidsetByKey(Stringkey,Stringvalue);}之后，您决定要使用此接口的数字版本...您明白了。

通用类型可以省去创建所有这些接口的麻烦。相反，您可以创建一个带有类型参数的接口：

abstractclassCache{TgetByKey(Stringkey);voidsetByKey(Stringkey,Tvalue);}在此代码中，T是替身类型。它是一个占位符，您可以将其视为开发人员稍后定义的类型。使用集合文字可以参数化列表，集和地图文字。参数化文字就像你已经看到的文字一样，除了你在开始括号之前添加（对于列表和集合）或（对于地图）。以下是使用类型文字的示例：

varnames=['Seth','Kathy','Lars'];varuniqueNames={'Seth','Kathy','Lars'};varpages={'index.html':'Homepage','robots.txt':'Hintsforwebrobots','humans.txt':'Wearepeople,notmachines'};使用带有构造函数的参数化类型要在使用构造函数时指定一个或多个类型，请将类型放在<...>类名称后面的尖括号（）中。例如：

varnameSet=Set.from(names);以下代码创建一个具有整数键和View类型值的映射：

varviews=Map();通用集合及其包含的类型Dart泛型类型的具体化，这意味着他们随身携带的类型信息在运行时。例如，您可以测试集合的类型：

varnames=List();names.addAll(['Seth','Kathy','Lars']);print(namesisList);//true注意：相反，Java中的泛型使用擦除，这意味着在运行时删除泛型类型参数。在Java中，您可以测试对象是否为List，但您无法测试它是否为aList。

实现泛型类型时，您可能希望限制其参数的类型。你可以使用extends。

classFoo{//Implementationgoeshere...StringtoString()=>"Instanceof'Foo<$T>'";}classExtenderextendsSomeBaseClass{...}使用SomeBaseClass或其任何子类作为通用参数是可以的：

varsomeBaseClassFoo=Foo();varextenderFoo=Foo();也可以不指定泛型参数：

varfoo=Foo();print(foo);//Instanceof'Foo'指定任何非SomeBaseClass类型会导致错误：

varfoo=Foo