java代码架构分析工具_Java代码度量分析工具：DesigniteJava简介

Duplicate Abstraction:

重复抽象，This smell arises when two or more abstractions have identical names or identical implementation or both.

Feature Envy:

This smell occurs when a method seems more interested in an abstraction other than the one it actually is in.

Imperative Abstraction

命令抽象，This smell arises when an operation is turned into a class.

Multifaceted Abstraction

多方面抽象，This smell arises when an abstraction has more than one responsibility assigned to it.

Unnecessary Abstraction

不必要的抽象，This smell occurs when an abstraction that is actually not needed (and thus could have been avoided) gets introduced in a software design.

Unutilized Abstraction

未使用的抽象，This smell arises when an abstraction is left unused (either not directly used or not reachable).

Deficient Encapsulation

封装不足，This smell occurs when the declared accessibility of one or more members of an abstraction is more permissive than actually required.

Unexploited Encapsulation

未开发封装，This smell arises when client code uses explicit type checks (using chained if-else or switch statements that check for the type of the object) instead of exploiting the variation in types already encapsulated within a hierarchy.

Broken Modularization

模块化中断，This smell arises when data and/or methods that ideally should have been localized into a single abstraction are separated and spread across multiple abstractions.

Cyclic-Dependent Modularization

循环相关模块化， This smell arises when two or more abstractions depend on each other directly or indirectly (creating a tight coupling between the abstractions).

Insufficient Modularization

模块化不足 ，This smell arises when an abstraction exists that has not been completely decomposed, and a further decomposition could reduce its size, implementation complexity, or both.

Hub-like Modularization

轮毂式模块化，This smell arises when an abstraction has dependencies (both incoming and outgoing) with a large number of other abstractions.

Broken Hierarchy

断裂的层次结构，This smell arises when a supertype and its subtype conceptually do not share an “IS-A” relationship resulting in broken substitutability.

Cyclic Hierarchy

循环层次结构，This smell arises when a supertype in a hierarchy depends on any of its subtypes.

Deep Hierarchy

层次过深，This smell arises when an inheritance hierarchy is “excessively” deep.

Missing Hierarchy

缺少层次结构，This smell arises when a code segment uses conditional logic (typically in conjunction with “tagged types”) to explicitly manage variation in behavior where a hierarchy could have been created and used to encapsulate those variations.

Multipath Hierarchy

多路径层次结构，This smell arises when a subtype inherits both directly as well as indirectly from a supertype leading to unnecessary inheritance paths in the hierarchy.

Rebellious Hierarchy

叛逆性层次结构，This smell arises when a subtype rejects the methods provided by its supertype(s).

Wide Hierarchy

层次过宽，This smell arises when an inheritance hierarchy is “too” wide indicating that intermediate types may be missing.

Unfactored Hierarchy:

This smell arises when there is unnecessary duplication among types in a hierarchy.