The fourth unit architecture design
The fourth unit is to be done given the modeling UML elements / statistics / analysis, taking into account the UML elements of the organization is a tree, it is easy to think of completion based on the tree data structure
Since the UML elements have been given the official interface, the node type of wrapper in the form of a simplified design. Map building process is as follows:
- The different elements of different type to generate a corresponding node selected wrapper. In fact, this is similar to a plant (but not strong enough motivation for the use of the plant, and therefore did not adopt
- The resulting node into the node corresponding to the pool
- Considering the UML diagrams has been secured, there is no foreseeable needs to dynamically change the structure of FIG, by way of built FIG forced offline: After all the nodes is generated, the sequence will be topologically node sequentially taken out from the node pool, to complete its mount to the parent node (Mount) process. 4. In order to facilitate the achievement of intermediate results buffer, after the completion of loading the parent node explicitly call
setImmutableannotate it immutable objects, allowing to save the query cache
In addition, experimental attempt to encapsulate a node can be queried by type of QueryableNodeListclass, the effect did not meet expectations
The second of three classes completion checker check all use separate and complete the establishment of a directed graph on correlation detection according to an implementation of the interface class / inheritance
The architecture of some over designed, first iteration operation direction of the second job demand is not good control, but fortunately not out of control
Review and recommend semester courses
This four semester work down the harvest, or find many, profound look at a few different scenarios, understand some classic oo ideas, but also try to achieve some real opportunity not previously used design pattern, but also no shortage of Some explore and try their experimental nature. Overall, both the architecture point of view or engineering capabilities, in this semester have been a considerable degree of exercise.
Understanding of java style oo oo especially the deeper. Formally we could simply say, oo [is inherited polymorphism · · package], but in fact this is not a good summary of what exactly oo: js prototype chain is also a form of code reuse, the pursuit of all kinds elegant closures language features can be well hidden implementation details, they are not classic oo we understand. smalltalk oo is a pure object and message mechanism, c ++ oo is the perfect complement to the programming style and other characteristics, swift agreement instead of oo-oriented oriented interface, and the python oo great metaprogramming mean ...... one thousand kinds of languages, one thousand kinds oo, we are well-known in training but is a java-oo oo understanding of angles. It is difficult to generalize to say what is the absolute oo. So at this level of understanding, we explore not only not over, it has only just begun.
Even so, whether it is broad or narrow, understand and practice this semester oo in this area enough taste of the review. From the most basic syntax features, to common design patterns, the java concurrent programming, every job is a new engineering experience. We are once again iteration, at this point of the project oop touch to the original intention: the height of reuse, easy to maintain, easy to expand, human-friendly, clear framework ......
I think the biggest advantage oo lesson is that while moderate pressure, provides us with the opportunity to explore and a free trial and error. The same a task, it can achieve a very linear way, with a highly designed architecture can also be achieved, which achieve, which is not good to realize, when you can feel the iterative nature - less design will lead to heavy regular structure, over design will clearly feel the gravity during maintenance - these are the rare experience of the process. Programming philosophy is philosophy of pragmatism and empiricism philosophy, so these training for me is very useful.
On this basis, I personally have a few suggestions for curriculum design follows:
- Adjust difficulty curve. For example, the first unit immediately started training for oo characteristics while Proficiency regular expression, experience steep
- Adjusted some test data set, such as an elevator structure data is much greater than the proportion of the second random data work, which leads to some performance evaluation algorithms a larger deviation
- Hoping to increase the proportion of concurrent programming is appropriate, because this part personally think relatively more important in the build, and the current training concurrent security, involving concurrency degree lighter
Fleeting, fleeting one semester. At this time next year would like to look back, Hear the Wind Sing and wine.