悬赏，看谁懂下面几个专业术语

1
Attribute Complexity (AC)
Description:

Defined as the sum of each attribute's weight in the class.

You can set up weights for types, the enum type and the array type separately. Use "*" to define types of a package with all its subpackages . For example, java.lang.* means that the row defines all classes of the java.lang package and its subpackages . To process all types not listed in the table, specify the last row as "*".

The row order is important, because checking of attributes goes from the top of the table downwards. (Repetitions of a type aren't counted, so if a specific type follows a more general type that already included it, the specific type isn't counted. For example, java.lang.* won't be counted if it comes after java.* .)

2
Attribute Hiding Factor (AHF)
Description:

This measure is from the MOOD (Metrics for Object-Oriented Development) suite. It is calculated as a fraction. The numerator is the sum of the invisibilities of all attributes defined in all classes. The invisibility of an attribute is the percentage of the total classes (excluding the class owner of attribute) from which this attribute is not visible. The denominator is the total number of attributes defined in the project.

3
Access of Import Data (AID)
Description:

AID the amount of data members accessed in a method directly or via accessor-methods , from which the definition-class of the method is not derived.

4
Attribute Inheritance Factor (AIF)
Description:

This measure is from the MOOD (Metrics for Object-Oriented Development) suite. It is calculated as a fraction. The numerator is the sum of inherited attributes in all classes in the project. The denominator is the total number of available attributes (locally defined plus inherited) for all classes.

5
Average Inheritance Usage Ratio (AIUR)
Description:

we define AIUR for a derived class as the average value of the IUR metric computed between that class and all its ancestor classes.

for class C, let the set of its ancestor be {Ai}, (i=1, NOA):

NOA
   
   IUR(C, Ai)
i=1
AIUR =  
--------------------------------------------------------------------------------

NOA  

6
Access of Local Data (ALD)
Description:

ALD counts the number of the data accessed in the given method, which is local to the class where the method is defined.

Inherited data should be counted too.

7
Access Of Foreign Data (AOFD)
Description:

AOFD represents the number of external classes from which a given class accesses attributes , directly or via accessor methods . The higher the AOFD value for a class, the higher the probability that the class is or is about to become an unfocused-class.

Inner classes and superclasses are not counted.

8
Average Use of Interface (AUF)
Description:

AUF metric is defined as the average number of interface members of a class that are used by another class.

AUF is computed by totalling up the number of used members for each of client-classes and dividing it by the number of client classes (COC).

where NOA is the number of ancestor classes for class C.

9
Coupling Between Objects (CBO)
Description:

Represents the number of other classes to which a class is coupled to. Counts the number of reference types that are used in attribute declarations, formal parameters, return types, throws declarations, local variables, and types from which attribute and method selections are made. Primitive types, types from java.lang package and supertypes are not counted.

Excessive coupling between objects is detrimental to modular design and prevents reuse. The more independent a class is, the easier it is to reuse it in another application. In order to improve modularity and promote encapsulation, inter-object class coupling should be kept to a minimum. The larger the number of coupling, the higher the sensitivity to changes in other parts of the design, and therefore maintenance is more difficult. A measure of coupling is useful to determine how complex the testing of various parts of a design is likely to be. The higher the inter-object class coupling, the more rigorous the testing needs to be.


10
Cyclomatic Complexity (CC)
Description:

CC represents number of cycles in the measured method. This measure represents the cognitive complexity of the class. It counts the number of possible paths through an algorithm by counting the number of distinct regions on a flowgraph, meaning the number of if, for, and while statements in the operation's body. Case labels for switch statements are counted if the Case as branch property is activated.

A strict definition of CC (introduced by McCabe in 1976) looks at a program's control flow graph as a measure of its complexity:

CC = L - N + 2P

where L is the number of links in the control flow graph, N is the number of nodes in the control flow graph, and P is the number of disconnected parts in the control flow graph.

For example, consider a method which consists of an if statement:


   if (x > 0) {
       x++;
   } else {
       x--;
   }


CC = L - N + 2P = 4 - 4 + 2*1 = 2

A less formal definition is:

CC = D + 1

where D is the number of binary decisions in the control flow graph, if it has only one entry and exit. In other words, the number of if, for and while statements and number of logical and and or operators.

For the example above: CC = D + 1 = 1 + 1 = 2