One of the fastest ways for faulty software to fail is at compile time. <\/p>\n
Here is an example of slow<\/strong> failing code, it will fail at runtime if it comes across an implementation of One way to move these failures to compile time would be to move the responsibility for doing my If I add a new type Sometimes it is not appropriate to put the responsibility to Adding a new type However, a user might not want to handle every new implementation of When I add I can choose to either have my code break when new implementations of One of the fastest ways for faulty software to fail is at compile time. Here is an example of slow failing code, it will fail at runtime if it comes across an implementation of A that it did not expect. … Continue reading A<\/code> that it did not expect. This can happen if a developer adds a new implementation of A<\/code> but forgets to update this code (or is not aware of it, or it is located in some other dependent library).<\/p>\n\r\ninterface A { }\r\nclass B implements A { }\r\nclass C implements A { }\r\n\r\nvoid doSomething(A a) {\r\n \/\/ not recommend\r\n if(a instanceof B) {\r\n doMyBThings((B) a);\r\n } else if(a instanceof C) {\r\n doMyCThings((C) a);\r\n } else {\r\n throw IllegalArgumentException(\"unexpected kind of A\");\r\n }\r\n}\r\n<\/pre>\nB<\/code> things and doing my C<\/code> things on to the classes B<\/code> and C<\/code> respectively.<\/p>\n\r\ninterface A { void doMyThings(); }\r\nclass B implements A { void doMyThings(){ \/* do my B things *\/ } }\r\nclass C implements A { void doMyThings(){ \/* do my C things *\/ } }\r\n\r\nvoid doSomething(A a) {\r\n a.doMyThings();\r\n}\r\n<\/pre>\nD<\/code> the compiler forces us to implement doMyThings()<\/code> <\/p>\n\r\nclass D implements A { void doMyThings(){ \/* do my D things *\/ } }\r\n<\/pre>\ndoMyThings()<\/code> onto A<\/code>. It might create undesirable coupling (a dependency) or have some other undesirable property. I can maintain the fail fast property in in other ways.<\/p>\n\r\ninterface A { void doThings(Things things); }\r\nclass B implements A { void doThings(Things things){ things.doBThings(this); } }\r\nclass C implements A { void doThings(Things things){ things.doCThings(this); } }\r\n\r\ninterface Things {\r\n void doBThings(B b);\r\n void doCThings(C c);\r\n}\r\n\r\nvoid doSomething(A a) {\r\n a.doThings(new Things(){\r\n void doBThings(B b){ \/* do my B things *\/}\r\n void doCThings(C c){ \/* do my C things *\/}\r\n });\r\n}\r\n<\/pre>\nD<\/code>, the compiler forces me to implement doThings<\/code> on D<\/code>, which leads me to add a new method onto the Things interface, which forces any implementers of Things to handle D<\/code> types. <\/p>\n\r\nclass D implements A { void doThings(Things things){ things.doDThings(this); } }\r\n\r\ninterface Things {\r\n void doBThings(B b);\r\n void doCThings(C c);\r\n void doDThings(D d);\r\n}\r\n\r\nvoid doSomething(A a) {\r\n a.doThings(new Things(){\r\n void doBThings(B b){ \/* do my B things *\/}\r\n void doCThings(C c){ \/* do my C things *\/}\r\n void doDThings(D d){ \/* do my D things *\/}\r\n });\r\n}\r\n<\/pre>\nA<\/code>, I can provide default implementations of the methods: <\/p>\n\r\nclass BaseThings implements Things {\r\n void doBThings(B b) { };\r\n void doCThings(C c) { };\r\n}\r\n\r\nvoid doSomething(A a) {\r\n a.doThings(new BaseThings(){\r\n void doBThings(B b){ \/* do my B things *\/}\r\n void doCThings(C c){ \/* do my C things *\/}\r\n });\r\n}\r\n<\/pre>\nD<\/code> I also add a default implementation, so I do not have to add any new handling code:<\/p>\n\r\nclass BaseThings implements Things {\r\n void doBThings(B b) { };\r\n void doCThings(C c) { };\r\n void doDThings(D d) { };\r\n}\r\n\r\nvoid doSomething(A a) {\r\n a.doThings(new BaseThings(){\r\n void doBThings(B b){ \/* do my B things *\/}\r\n void doCThings(C c){ \/* do my C things *\/}\r\n });\r\n}\r\n<\/pre>\nA<\/code> are added (by extending Things<\/code>) or not to break (by extending BaseThings<\/code>).<\/p>\n","protected":false},"excerpt":{"rendered":"