CK calculates class$-$level and method$-$level code metrics in Java projects by means of static analysis $($i$.$e$.$ no need for compiled code$).$ Currently, it contains a large set of metrics, including the famous CK:

CBO $($Coupling between objects$)$: Counts the number of dependencies a class has. The tools checks for any type used in the entire class $($field declaration, method return types, variable declarations, etc$).$ It ignores dependencies to Java itself $($e$.$g$.$ java.lang.String$).$

CBO Modified $($Coupling between objects$)$: Counts the number of dependencies a class has. It is very similar to the CKTool's original CBO. However, this metric considers a dependency from a class as being both the references the type makes to others and the references that it receives from other types.

FAN$-$IN: Counts the number of input dependencies a class has, i$.$e$,$ the number of classes that reference a particular class. For instance, given a class X$,$ the fan$-$in of X would be the number of classes that call X by referencing it as an attribute, accessing some of its attributes, invoking some of its methods, etc.

FAN$-$OUT: Counts the number of output dependencies a class has, i$.$e$,$ the number of other classes referenced by a particular class. In other words, given a class X$,$ the fan$-$out of X is the number of classes called by X via attributes reference, method invocations, object instances, etc.

DIT $($Depth Inheritance Tree$)$: It counts the number of "fathers" a class has. All classes have DIT at least $1($everyone inherits java.lang.Object$).$ In order to make it happen, classes must exist in the project $($i$.$e$.$ if a class depends upon X which relies in a jar$/$dependency file, and X depends upon other classes, DIT is counted as $2).$

NOC $($Number of Children$)$: It counts the number of immediate subclasses that a particular class has.

Number of fields: Counts the number of fields. Specific numbers for total number of fields, static, public, private, protected, default, final, and synchronized fields.

Number of methods: Counts the number of methods. Specific numbers for total number of methods, static, public, abstract$,$ private, protected, default, final, and synchronized methods. Constructor methods also count here.

Number of visible methods: Counts the number of visible methods. A method is visible if it is not private.

NOSI $($Number of static invocations$)$: Counts the number of invocations to static methods. It can only count the ones that can be resolved by the JDT$.$

RFC $($Response for a Class$)$: Counts the number of unique method invocations in a class. As invocations are resolved via static analysis, this implementation fails when a method has overloads with same number of parameters, but different types.

WMC $($Weight Method Class$)$ or McCabe's complexity. It counts the number of branch instructions in a class.

LOC $($Lines of code$)$: It counts the lines of count, ignoring empty lines and comments $($i$.$e$.,$ it's Source Lines of Code, or SLOC$).$ The number of lines here might be a bit different from the original file, as we use JDT$\text{'}$s internal representation of the source code to calculate it$.$

LCOM $($Lack of Cohesion of Methods$)$: Calculates LCOM metric. This is the very first version of metric, which is not reliable. LCOM$-$HS can be better $($hopefully$,$ you will send us a pull request$).$

LCOM$*($Lack of Cohesion of Methods$)$: This metric is a modified version of the current version of LCOM implemented in CK Tool. LCOM$*$ is a normalized metric that computes the lack of cohesion of class within a range of $0$ to $1.$ Then, the closer to $1$ the value of LCOM$*$ in a class, the less the cohesion degree of this respective class. The closer to $0$ the value of LCOM$*$ in a class, the most the cohesion of this respective class. This implementation follows the third version of LCOM$*$ defined in $[1].$

Reference: $[1]$ Henderson$-$Sellers, Brian, Larry L$.$ Constantine and Ian M$.$ Graham. $$Coupling and cohesion $($towards a valid metrics suite for object$-$oriented analysis and design$).$ Object Oriented Systems $3(1996)$: $143-158.$

TCC $($Tight Class Cohesion$)$: Measures the cohesion of a class with a value range from $0$ to $1.$ TCC measures the cohesion of a class via direct connections between visible methods, two methods or their invocation trees access the same class variable.

LCC $($Loose Class Cohesion$)$: Similar to TCC but it further includes the number of indirect connections between visible classes for the cohesion calculation. Thus, the constraint LCC $>=$ TCC holds always.

Quantity of returns: The number of return instructions.

Quantity of loops: The number of loops $($i$.$e$.,$ for, while, do while, enhanced for$).$

Quantity of comparisons: The number of comparisons $($i$.$e$.,==$ and $!=).$ Note: $!=$ is only available in $0\mathrm{.}4\mathrm{.}2+.$

Quantity of try$/$catches: The number of try$/$catches

Quantity of parenthesized expressions: The number of expressions inside parenthesis.

String literals: The number of string literals $($e$.$g$.,$ "John Doe"$).$ Repeated strings count as manytimes as they appear.