Code format and cleanup

Private methods don't need to be final.
Enums don't need to be static.
Public methods in final classes don't need to be final.
Interfaces don't need public methods.
Added Eclipse formatter.

.settings/org.eclipse.jdt.core.prefs

@@ -6,3 +6,379 @@ org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
 org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=ignore
 org.eclipse.jdt.core.compiler.release=disabled
 org.eclipse.jdt.core.compiler.source=11
+org.eclipse.jdt.core.formatter.align_assignment_statements_on_columns=false
+org.eclipse.jdt.core.formatter.align_fields_grouping_blank_lines=2147483647
+org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
+org.eclipse.jdt.core.formatter.align_variable_declarations_on_columns=false
+org.eclipse.jdt.core.formatter.align_with_spaces=false
+org.eclipse.jdt.core.formatter.alignment_for_additive_operator=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=0
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant=48
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call=0
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation=0
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression=0
+org.eclipse.jdt.core.formatter.alignment_for_assignment=4
+org.eclipse.jdt.core.formatter.alignment_for_bitwise_operator=16
+org.eclipse.jdt.core.formatter.alignment_for_compact_if=0
+org.eclipse.jdt.core.formatter.alignment_for_compact_loops=16
+org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=0
+org.eclipse.jdt.core.formatter.alignment_for_conditional_expression_chain=0
+org.eclipse.jdt.core.formatter.alignment_for_enum_constants=49
+org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer=49
+org.eclipse.jdt.core.formatter.alignment_for_expressions_in_for_loop_header=0
+org.eclipse.jdt.core.formatter.alignment_for_logical_operator=16
+org.eclipse.jdt.core.formatter.alignment_for_method_declaration=0
+org.eclipse.jdt.core.formatter.alignment_for_module_statements=16
+org.eclipse.jdt.core.formatter.alignment_for_multiple_fields=16
+org.eclipse.jdt.core.formatter.alignment_for_multiplicative_operator=16
+org.eclipse.jdt.core.formatter.alignment_for_parameterized_type_references=0
+org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration=0
+org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration=0
+org.eclipse.jdt.core.formatter.alignment_for_record_components=0
+org.eclipse.jdt.core.formatter.alignment_for_relational_operator=0
+org.eclipse.jdt.core.formatter.alignment_for_resources_in_try=85
+org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation=0
+org.eclipse.jdt.core.formatter.alignment_for_shift_operator=0
+org.eclipse.jdt.core.formatter.alignment_for_string_concatenation=16
+org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration=0
+org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration=48
+org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_record_declaration=0
+org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration=0
+org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration=0
+org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration=0
+org.eclipse.jdt.core.formatter.alignment_for_type_arguments=0
+org.eclipse.jdt.core.formatter.alignment_for_type_parameters=0
+org.eclipse.jdt.core.formatter.alignment_for_union_type_in_multicatch=16
+org.eclipse.jdt.core.formatter.blank_lines_after_imports=1
+org.eclipse.jdt.core.formatter.blank_lines_after_last_class_body_declaration=0
+org.eclipse.jdt.core.formatter.blank_lines_after_package=1
+org.eclipse.jdt.core.formatter.blank_lines_before_abstract_method=1
+org.eclipse.jdt.core.formatter.blank_lines_before_field=0
+org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration=0
+org.eclipse.jdt.core.formatter.blank_lines_before_imports=1
+org.eclipse.jdt.core.formatter.blank_lines_before_member_type=1
+org.eclipse.jdt.core.formatter.blank_lines_before_method=1
+org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk=1
+org.eclipse.jdt.core.formatter.blank_lines_before_package=0
+org.eclipse.jdt.core.formatter.blank_lines_between_import_groups=1
+org.eclipse.jdt.core.formatter.blank_lines_between_statement_group_in_switch=0
+org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations=1
+org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_array_initializer=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_block=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_block_in_case=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_enum_constant=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_lambda_body=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_method_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_record_constructor=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_record_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_switch=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_type_declaration=end_of_line
+org.eclipse.jdt.core.formatter.comment.align_tags_descriptions_grouped=false
+org.eclipse.jdt.core.formatter.comment.align_tags_names_descriptions=false
+org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment=true
+org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment=true
+org.eclipse.jdt.core.formatter.comment.count_line_length_from_starting_position=false
+org.eclipse.jdt.core.formatter.comment.format_block_comments=true
+org.eclipse.jdt.core.formatter.comment.format_header=false
+org.eclipse.jdt.core.formatter.comment.format_html=true
+org.eclipse.jdt.core.formatter.comment.format_javadoc_comments=true
+org.eclipse.jdt.core.formatter.comment.format_line_comments=true
+org.eclipse.jdt.core.formatter.comment.format_source_code=true
+org.eclipse.jdt.core.formatter.comment.indent_parameter_description=true
+org.eclipse.jdt.core.formatter.comment.indent_root_tags=true
+org.eclipse.jdt.core.formatter.comment.indent_tag_description=false
+org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags=do not insert
+org.eclipse.jdt.core.formatter.comment.insert_new_line_between_different_tags=do not insert
+org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=do not insert
+org.eclipse.jdt.core.formatter.comment.line_length=300
+org.eclipse.jdt.core.formatter.comment.new_lines_at_block_boundaries=true
+org.eclipse.jdt.core.formatter.comment.new_lines_at_javadoc_boundaries=true
+org.eclipse.jdt.core.formatter.comment.preserve_white_space_between_code_and_line_comments=false
+org.eclipse.jdt.core.formatter.compact_else_if=true
+org.eclipse.jdt.core.formatter.continuation_indentation=1
+org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer=1
+org.eclipse.jdt.core.formatter.disabling_tag=@formatter\:off
+org.eclipse.jdt.core.formatter.enabling_tag=@formatter\:on
+org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line=false
+org.eclipse.jdt.core.formatter.format_line_comment_starting_on_first_column=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_record_header=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header=true
+org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases=true
+org.eclipse.jdt.core.formatter.indent_empty_lines=true
+org.eclipse.jdt.core.formatter.indent_statements_compare_to_block=true
+org.eclipse.jdt.core.formatter.indent_statements_compare_to_body=true
+org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases=true
+org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch=true
+org.eclipse.jdt.core.formatter.indentation.size=4
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_enum_constant=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_field=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_method=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_package=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_type=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_label=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_type_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement=insert
+org.eclipse.jdt.core.formatter.insert_space_after_additive_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter=insert
+org.eclipse.jdt.core.formatter.insert_space_after_arrow_in_switch_case=insert
+org.eclipse.jdt.core.formatter.insert_space_after_arrow_in_switch_default=insert
+org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_bitwise_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_record_components=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_switch_case_expressions=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_ellipsis=insert
+org.eclipse.jdt.core.formatter.insert_space_after_lambda_arrow=insert
+org.eclipse.jdt.core.formatter.insert_space_after_logical_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_multiplicative_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_not_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_record_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_try=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_relational_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_try_resources=insert
+org.eclipse.jdt.core.formatter.insert_space_after_shift_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_string_concatenation=insert
+org.eclipse.jdt.core.formatter.insert_space_after_unary_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_additive_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter=insert
+org.eclipse.jdt.core.formatter.insert_space_before_arrow_in_switch_case=insert
+org.eclipse.jdt.core.formatter.insert_space_before_arrow_in_switch_default=insert
+org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_bitwise_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_record_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_try=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_record_components=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_switch_case_expressions=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_ellipsis=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_lambda_arrow=insert
+org.eclipse.jdt.core.formatter.insert_space_before_logical_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_multiplicative_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_record_constructor=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_record_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_record_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_try=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while=insert
+org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return=insert
+org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_throw=insert
+org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_relational_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_semicolon=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_try_resources=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_shift_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_string_concatenation=insert
+org.eclipse.jdt.core.formatter.insert_space_before_unary_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.join_lines_in_comments=true
+org.eclipse.jdt.core.formatter.join_wrapped_lines=true
+org.eclipse.jdt.core.formatter.keep_annotation_declaration_on_one_line=one_line_never
+org.eclipse.jdt.core.formatter.keep_anonymous_type_declaration_on_one_line=one_line_never
+org.eclipse.jdt.core.formatter.keep_code_block_on_one_line=one_line_never
+org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line=false
+org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line=true
+org.eclipse.jdt.core.formatter.keep_enum_constant_declaration_on_one_line=one_line_never
+org.eclipse.jdt.core.formatter.keep_enum_declaration_on_one_line=one_line_never
+org.eclipse.jdt.core.formatter.keep_if_then_body_block_on_one_line=one_line_never
+org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line=false
+org.eclipse.jdt.core.formatter.keep_lambda_body_block_on_one_line=one_line_never
+org.eclipse.jdt.core.formatter.keep_loop_body_block_on_one_line=one_line_never
+org.eclipse.jdt.core.formatter.keep_method_body_on_one_line=one_line_never
+org.eclipse.jdt.core.formatter.keep_record_constructor_on_one_line=one_line_never
+org.eclipse.jdt.core.formatter.keep_record_declaration_on_one_line=one_line_never
+org.eclipse.jdt.core.formatter.keep_simple_do_while_body_on_same_line=false
+org.eclipse.jdt.core.formatter.keep_simple_for_body_on_same_line=false
+org.eclipse.jdt.core.formatter.keep_simple_getter_setter_on_one_line=false
+org.eclipse.jdt.core.formatter.keep_simple_while_body_on_same_line=false
+org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line=false
+org.eclipse.jdt.core.formatter.keep_type_declaration_on_one_line=one_line_never
+org.eclipse.jdt.core.formatter.lineSplit=300
+org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column=false
+org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column=false
+org.eclipse.jdt.core.formatter.number_of_blank_lines_after_code_block=0
+org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_code_block=0
+org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body=0
+org.eclipse.jdt.core.formatter.number_of_blank_lines_at_end_of_code_block=0
+org.eclipse.jdt.core.formatter.number_of_blank_lines_at_end_of_method_body=0
+org.eclipse.jdt.core.formatter.number_of_blank_lines_before_code_block=0
+org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve=1
+org.eclipse.jdt.core.formatter.parentheses_positions_in_annotation=common_lines
+org.eclipse.jdt.core.formatter.parentheses_positions_in_catch_clause=common_lines
+org.eclipse.jdt.core.formatter.parentheses_positions_in_enum_constant_declaration=common_lines
+org.eclipse.jdt.core.formatter.parentheses_positions_in_for_statment=common_lines
+org.eclipse.jdt.core.formatter.parentheses_positions_in_if_while_statement=common_lines
+org.eclipse.jdt.core.formatter.parentheses_positions_in_lambda_declaration=common_lines
+org.eclipse.jdt.core.formatter.parentheses_positions_in_method_delcaration=common_lines
+org.eclipse.jdt.core.formatter.parentheses_positions_in_method_invocation=common_lines
+org.eclipse.jdt.core.formatter.parentheses_positions_in_record_declaration=common_lines
+org.eclipse.jdt.core.formatter.parentheses_positions_in_switch_statement=common_lines
+org.eclipse.jdt.core.formatter.parentheses_positions_in_try_clause=common_lines
+org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line=false
+org.eclipse.jdt.core.formatter.tabulation.char=tab
+org.eclipse.jdt.core.formatter.tabulation.size=4
+org.eclipse.jdt.core.formatter.text_block_indentation=0
+org.eclipse.jdt.core.formatter.use_on_off_tags=true
+org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations=false
+org.eclipse.jdt.core.formatter.wrap_before_additive_operator=true
+org.eclipse.jdt.core.formatter.wrap_before_assignment_operator=false
+org.eclipse.jdt.core.formatter.wrap_before_bitwise_operator=true
+org.eclipse.jdt.core.formatter.wrap_before_conditional_operator=true
+org.eclipse.jdt.core.formatter.wrap_before_logical_operator=true
+org.eclipse.jdt.core.formatter.wrap_before_multiplicative_operator=true
+org.eclipse.jdt.core.formatter.wrap_before_or_operator_multicatch=true
+org.eclipse.jdt.core.formatter.wrap_before_relational_operator=true
+org.eclipse.jdt.core.formatter.wrap_before_shift_operator=true
+org.eclipse.jdt.core.formatter.wrap_before_string_concatenation=true
+org.eclipse.jdt.core.formatter.wrap_outer_expressions_when_nested=true
+org.eclipse.jdt.core.javaFormatter=org.eclipse.jdt.core.defaultJavaFormatter

.settings/org.eclipse.jdt.ui.prefs

@@ -0,0 +1,70 @@
+cleanup.add_default_serial_version_id=false
+cleanup.add_generated_serial_version_id=true
+cleanup.add_missing_annotations=true
+cleanup.add_missing_deprecated_annotations=true
+cleanup.add_missing_methods=true
+cleanup.add_missing_nls_tags=false
+cleanup.add_missing_override_annotations=true
+cleanup.add_missing_override_annotations_interface_methods=true
+cleanup.add_serial_version_id=true
+cleanup.always_use_blocks=true
+cleanup.always_use_parentheses_in_expressions=true
+cleanup.always_use_this_for_non_static_field_access=false
+cleanup.always_use_this_for_non_static_method_access=false
+cleanup.convert_functional_interfaces=true
+cleanup.convert_to_enhanced_for_loop=true
+cleanup.correct_indentation=false
+cleanup.format_source_code=true
+cleanup.format_source_code_changes_only=false
+cleanup.insert_inferred_type_arguments=false
+cleanup.make_local_variable_final=false
+cleanup.make_parameters_final=false
+cleanup.make_private_fields_final=true
+cleanup.make_type_abstract_if_missing_method=false
+cleanup.make_variable_declarations_final=true
+cleanup.never_use_blocks=false
+cleanup.never_use_parentheses_in_expressions=false
+cleanup.number_suffix=false
+cleanup.organize_imports=true
+cleanup.push_down_negation=false
+cleanup.qualify_static_field_accesses_with_declaring_class=false
+cleanup.qualify_static_member_accesses_through_instances_with_declaring_class=true
+cleanup.qualify_static_member_accesses_through_subtypes_with_declaring_class=true
+cleanup.qualify_static_member_accesses_with_declaring_class=true
+cleanup.qualify_static_method_accesses_with_declaring_class=false
+cleanup.remove_private_constructors=true
+cleanup.remove_redundant_modifiers=true
+cleanup.remove_redundant_semicolons=true
+cleanup.remove_redundant_type_arguments=true
+cleanup.remove_trailing_whitespaces=false
+cleanup.remove_trailing_whitespaces_all=true
+cleanup.remove_trailing_whitespaces_ignore_empty=true
+cleanup.remove_unnecessary_array_creation=false
+cleanup.remove_unnecessary_casts=true
+cleanup.remove_unnecessary_nls_tags=true
+cleanup.remove_unused_imports=true
+cleanup.remove_unused_local_variables=true
+cleanup.remove_unused_private_fields=true
+cleanup.remove_unused_private_members=true
+cleanup.remove_unused_private_methods=true
+cleanup.remove_unused_private_types=true
+cleanup.simplify_lambda_expression_and_method_ref=false
+cleanup.sort_members=false
+cleanup.sort_members_all=false
+cleanup.use_anonymous_class_creation=false
+cleanup.use_autoboxing=false
+cleanup.use_blocks=true
+cleanup.use_blocks_only_for_return_and_throw=false
+cleanup.use_directly_map_method=false
+cleanup.use_lambda=true
+cleanup.use_parentheses_in_expressions=true
+cleanup.use_this_for_non_static_field_access=true
+cleanup.use_this_for_non_static_field_access_only_if_necessary=true
+cleanup.use_this_for_non_static_method_access=true
+cleanup.use_this_for_non_static_method_access_only_if_necessary=true
+cleanup.use_unboxing=false
+cleanup_profile=_L2J Clean Up v0.4
+cleanup_settings_version=2
+eclipse.preferences.version=1
+formatter_profile=_L2J Formatter v0.8
+formatter_settings_version=19

.settings/org.eclipse.m2e.core.prefs

@@ -0,0 +1,4 @@
+activeProfiles=
+eclipse.preferences.version=1
+resolveWorkspaceProjects=true
+version=1

src/main/java/com/l2jserver/gameserver/GameTimeController.java

@@ -64,23 +64,23 @@ public final class GameTimeController extends Thread {
 		super.start();
 	}
 	
-	public static final void init() {
+	public static void init() {
 		_instance = new GameTimeController();
 	}
 	
-	public final int getGameTime() {
+	public int getGameTime() {
 		return (getGameTicks() % TICKS_PER_IG_DAY) / MILLIS_IN_TICK;
 	}
 	
-	public final int getGameHour() {
+	public int getGameHour() {
 		return getGameTime() / 60;
 	}
 	
-	public final int getGameMinute() {
+	public int getGameMinute() {
 		return getGameTime() % 60;
 	}
 	
-	public final boolean isNight() {
+	public boolean isNight() {
 		return getGameHour() < 6;
 	}
 	
@@ -88,7 +88,7 @@ public final class GameTimeController extends Thread {
 	 * The true GameTime tick. Directly taken from current time. This represents the tick of the time.
 	 * @return
 	 */
-	public final int getGameTicks() {
+	public int getGameTicks() {
 		return (int) ((System.currentTimeMillis() - _referenceTime) / MILLIS_IN_TICK);
 	}
 	
@@ -96,7 +96,7 @@ public final class GameTimeController extends Thread {
 	 * Add a L2Character to movingObjects of GameTimeController.
 	 * @param cha The L2Character to add to movingObjects of GameTimeController
 	 */
-	public final void registerMovingObject(final L2Character cha) {
+	public void registerMovingObject(final L2Character cha) {
 		if (cha == null) {
 			return;
 		}
@@ -115,17 +115,17 @@ public final class GameTimeController extends Thread {
 	 * <li>Create a task to update the _knownObject and _knowPlayers of each L2Character that finished its movement and of their already known L2Object then notify AI with EVT_ARRIVED</li>
 	 * </ul>
 	 */
-	private final void moveObjects() {
+	private void moveObjects() {
 		_movingObjects.removeIf(L2Character::updatePosition);
 	}
 	
-	public final void stopTimer() {
+	public void stopTimer() {
 		super.interrupt();
 		LOG.info("Stopping {}", getClass().getSimpleName());
 	}
 	
 	@Override
-	public final void run() {
+	public void run() {
 		LOG.debug("{}: Started.", getClass().getSimpleName());
 		
 		long nextTickTime, sleepTime;
@@ -161,7 +161,7 @@ public final class GameTimeController extends Thread {
 		}
 	}
 	
-	public static final GameTimeController getInstance() {
+	public static GameTimeController getInstance() {
 		return _instance;
 	}
 }

src/main/java/com/l2jserver/gameserver/ThreadPoolManager.java

@@ -81,7 +81,7 @@ public class ThreadPoolManager {
 		}
 		
 		@Override
-		public final void run() {
+		public void run() {
 			try {
 				_r.run();
 			} catch (final Throwable e) {

src/main/java/com/l2jserver/gameserver/ai/L2AttackableAI.java

@@ -576,8 +576,7 @@ public class L2AttackableAI extends L2CharacterAI implements Runnable {
 			int z1 = 0;
 			final int range = npc().getMaxDriftRange();
 			
-			if (npc.isWalker()) 
-			{
+			if (npc.isWalker()) {
 				return;
 			}
 			

src/main/java/com/l2jserver/gameserver/ai/NextAction.java

@@ -28,7 +28,7 @@ import java.util.List;
  */
 public class NextAction {
 	public interface NextActionCallback {
-		public void doWork();
+		void doWork();
 	}
 	
 	private List<CtrlEvent> _events;

src/main/java/com/l2jserver/gameserver/bbs/model/Forum.java

@@ -82,59 +82,59 @@ public final class Forum {
 	public void rmTopicByID(int id) {
 		topics.remove(id);
 	}
-
+	
 	public String getName() {
 		return name;
 	}
-
+	
 	public void setName(String name) {
 		this.name = name;
 	}
-
+	
 	public ForumType getType() {
 		return type;
 	}
-
+	
 	public void setType(ForumType type) {
 		this.type = type;
 	}
-
+	
 	public int getPost() {
 		return post;
 	}
-
+	
 	public void setPost(int post) {
 		this.post = post;
 	}
-
+	
 	public ForumVisibility getVisibility() {
 		return visibility;
 	}
-
+	
 	public void setVisibility(ForumVisibility visibility) {
 		this.visibility = visibility;
 	}
-
+	
 	public int getOwnerId() {
 		return ownerId;
 	}
-
+	
 	public void setOwnerId(int ownerId) {
 		this.ownerId = ownerId;
 	}
-
+	
 	public int getId() {
 		return id;
 	}
-
+	
 	public Forum getParent() {
 		return parent;
 	}
-
+	
 	public List<Forum> getChildren() {
 		return children;
 	}
-
+	
 	public Map<Integer, Topic> getTopics() {
 		return topics;
 	}

src/main/java/com/l2jserver/gameserver/bbs/repository/PostRepository.java

@@ -29,10 +29,10 @@ import com.l2jserver.gameserver.bbs.model.Topic;
  * @version 2.6.2.0
  */
 public interface PostRepository {
-
+	
 	void delete(Topic topic);
-
+	
 	void update(Post post);
-
+	
 	List<Post> load(Topic topic);
 }

src/main/java/com/l2jserver/gameserver/bbs/service/PostBBSManager.java

@@ -26,9 +26,9 @@ import java.util.Map;
 import java.util.StringTokenizer;
 import java.util.concurrent.ConcurrentHashMap;
 
-import com.l2jserver.gameserver.bbs.model.Post;
 import com.l2jserver.gameserver.bbs.model.Forum;
 import com.l2jserver.gameserver.bbs.model.ForumType;
+import com.l2jserver.gameserver.bbs.model.Post;
 import com.l2jserver.gameserver.bbs.model.Topic;
 import com.l2jserver.gameserver.dao.factory.impl.DAOFactory;
 import com.l2jserver.gameserver.handler.CommunityBoardHandler;

src/main/java/com/l2jserver/gameserver/bbs/service/TopicBBSManager.java

@@ -28,9 +28,9 @@ import java.util.Map;
 import java.util.StringTokenizer;
 import java.util.concurrent.CopyOnWriteArrayList;
 
-import com.l2jserver.gameserver.bbs.model.Post;
 import com.l2jserver.gameserver.bbs.model.Forum;
 import com.l2jserver.gameserver.bbs.model.ForumType;
+import com.l2jserver.gameserver.bbs.model.Post;
 import com.l2jserver.gameserver.bbs.model.Topic;
 import com.l2jserver.gameserver.bbs.model.TopicType;
 import com.l2jserver.gameserver.dao.factory.impl.DAOFactory;

src/main/java/com/l2jserver/gameserver/data/sql/impl/NpcBufferTable.java

@@ -55,13 +55,8 @@ public class NpcBufferTable {
 	}
 	
 	private static class NpcBufferSkills {
-		private final int _npcId;
 		private final Map<Integer, NpcBufferData> _skills = new HashMap<>();
 		
-		protected NpcBufferSkills(int npcId) {
-			_npcId = npcId;
-		}
-		
 		public void addSkill(int skillId, int skillLevel, int skillFeeId, int skillFeeAmount, int buffGroup) {
 			_skills.put(buffGroup, new NpcBufferData(skillId, skillLevel, skillFeeId, skillFeeAmount));
 		}
@@ -69,11 +64,6 @@ public class NpcBufferTable {
 		public NpcBufferData getSkillGroupInfo(int buffGroup) {
 			return _skills.get(buffGroup);
 		}
-		
-		@SuppressWarnings("unused")
-		public int getNpcId() {
-			return _npcId;
-		}
 	}
 	
 	protected NpcBufferTable() {
@@ -97,7 +87,7 @@ public class NpcBufferTable {
 						_buffers.put(lastNpcId, skills);
 					}
 					
-					skills = new NpcBufferSkills(npcId);
+					skills = new NpcBufferSkills();
 					skills.addSkill(skillId, skillLevel, skillFeeId, skillFeeAmount, buffGroup);
 				} else if (skills != null) {
 					skills.addSkill(skillId, skillLevel, skillFeeId, skillFeeAmount, buffGroup);
@@ -133,7 +123,7 @@ public class NpcBufferTable {
 							_buffers.put(lastNpcId, skills);
 						}
 						
-						skills = new NpcBufferSkills(npcId);
+						skills = new NpcBufferSkills();
 						skills.addSkill(skillId, skillLevel, skillFeeId, skillFeeAmount, buffGroup);
 					} else if (skills != null) {
 						skills.addSkill(skillId, skillLevel, skillFeeId, skillFeeAmount, buffGroup);

src/main/java/com/l2jserver/gameserver/data/xml/impl/MultisellData.java

@@ -138,7 +138,7 @@ public final class MultisellData implements IXmlReader {
 		return NUMERIC_FILTER;
 	}
 	
-	private final Entry parseEntry(Node n, int entryId, ListContainer list) {
+	private Entry parseEntry(Node n, int entryId, ListContainer list) {
 		Node first = n.getFirstChild();
 		final Entry entry = new Entry(entryId);
 		
@@ -198,7 +198,7 @@ public final class MultisellData implements IXmlReader {
 	 * @param productMultiplier
 	 * @param ingredientMultiplier
 	 */
-	public final void separateAndSend(int listId, L2PcInstance player, L2Npc npc, boolean inventoryOnly, double productMultiplier, double ingredientMultiplier) {
+	public void separateAndSend(int listId, L2PcInstance player, L2Npc npc, boolean inventoryOnly, double productMultiplier, double ingredientMultiplier) {
 		ListContainer template = _entries.get(listId);
 		if (template == null) {
 			LOG.warn("{}: Cannot find list ID: {} requested by player: {}, NPC ID: {}!", getClass().getSimpleName(), listId, player, (npc != null ? npc.getId() : 0));
@@ -233,11 +233,11 @@ public final class MultisellData implements IXmlReader {
 		player.setMultiSell(list);
 	}
 	
-	public final void separateAndSend(int listId, L2PcInstance player, L2Npc npc, boolean inventoryOnly) {
+	public void separateAndSend(int listId, L2PcInstance player, L2Npc npc, boolean inventoryOnly) {
 		separateAndSend(listId, player, npc, inventoryOnly, 1, 1);
 	}
 	
-	public static final boolean hasSpecialIngredient(int id, long amount, L2PcInstance player) {
+	public static boolean hasSpecialIngredient(int id, long amount, L2PcInstance player) {
 		switch (id) {
 			case CLAN_REPUTATION:
 				if (player.getClan() == null) {
@@ -263,7 +263,7 @@ public final class MultisellData implements IXmlReader {
 		return false;
 	}
 	
-	public static final boolean takeSpecialIngredient(int id, long amount, L2PcInstance player) {
+	public static boolean takeSpecialIngredient(int id, long amount, L2PcInstance player) {
 		switch (id) {
 			case CLAN_REPUTATION:
 				player.getClan().takeReputationScore((int) amount, true);
@@ -280,7 +280,7 @@ public final class MultisellData implements IXmlReader {
 		return false;
 	}
 	
-	public static final void giveSpecialProduct(int id, long amount, L2PcInstance player) {
+	public static void giveSpecialProduct(int id, long amount, L2PcInstance player) {
 		switch (id) {
 			case CLAN_REPUTATION:
 				player.getClan().addReputationScore((int) amount, true);
@@ -293,7 +293,7 @@ public final class MultisellData implements IXmlReader {
 		}
 	}
 	
-	private final void verify() {
+	private void verify() {
 		ListContainer list;
 		final Iterator<ListContainer> iter = _entries.values().iterator();
 		while (iter.hasNext()) {
@@ -314,7 +314,7 @@ public final class MultisellData implements IXmlReader {
 		}
 	}
 	
-	private final boolean verifyIngredient(Ingredient ing) {
+	private boolean verifyIngredient(Ingredient ing) {
 		switch (ing.getItemId()) {
 			case CLAN_REPUTATION:
 			case FAME:

src/main/java/com/l2jserver/gameserver/data/xml/impl/PlayerTemplateData.java

@@ -138,7 +138,7 @@ public final class PlayerTemplateData implements IXmlReader {
 		return _playerTemplates.get(ClassId.getClassId(classId));
 	}
 	
-	public static final PlayerTemplateData getInstance() {
+	public static PlayerTemplateData getInstance() {
 		return SingletonHolder.INSTANCE;
 	}
 	

src/main/java/com/l2jserver/gameserver/datatables/ItemTable.java

@@ -230,7 +230,7 @@ public class ItemTable {
 		
 		if (general().logItems() && !process.equals("Reset")) {
 			if (!general().logItemsSmallLog() || (general().logItemsSmallLog() && (item.isEquipable() || (item.getId() == ADENA_ID)))) {
-				if (item.getItemType() != ARROW && item.getItemType() != SHOT) {
+				if ((item.getItemType() != ARROW) && (item.getItemType() != SHOT)) {
 					LOG_ITEM.info("CREATED {} by {}, referenced by {}.", item, actor, reference);
 				}
 			}
@@ -286,7 +286,7 @@ public class ItemTable {
 			
 			if (general().logItems()) {
 				if (!general().logItemsSmallLog() || (general().logItemsSmallLog() && (item.isEquipable() || (item.getId() == ADENA_ID)))) {
-					if (item.getItemType() != ARROW && item.getItemType() != SHOT) {
+					if ((item.getItemType() != ARROW) && (item.getItemType() != SHOT)) {
 						LOG_ITEM.info("DELETED {} amount {} by {}, referenced by {}.", item, old, actor, reference);
 					}
 				}

src/main/java/com/l2jserver/gameserver/enums/audio/IAudio.java

@@ -27,10 +27,10 @@ public interface IAudio {
 	/**
 	 * @return the name of the sound of this audio object
 	 */
-	public String getSoundName();
+	String getSoundName();
 	
 	/**
 	 * @return the {@link PlaySound} packet of this audio object
 	 */
-	public PlaySound getPacket();
+	PlaySound getPacket();
 }

src/main/java/com/l2jserver/gameserver/handler/IActionHandler.java

@@ -25,9 +25,9 @@ import com.l2jserver.gameserver.model.L2Object;
 import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
 
 public interface IActionHandler {
-	public static Logger _log = Logger.getLogger(IActionHandler.class.getName());
+	Logger _log = Logger.getLogger(IActionHandler.class.getName());
 	
-	public boolean action(L2PcInstance activeChar, L2Object target, boolean interact);
+	boolean action(L2PcInstance activeChar, L2Object target, boolean interact);
 	
-	public InstanceType getInstanceType();
+	InstanceType getInstanceType();
 }

src/main/java/com/l2jserver/gameserver/handler/IActionShiftHandler.java

@@ -25,9 +25,9 @@ import com.l2jserver.gameserver.model.L2Object;
 import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
 
 public interface IActionShiftHandler {
-	public static Logger _log = Logger.getLogger(IActionShiftHandler.class.getName());
+	Logger _log = Logger.getLogger(IActionShiftHandler.class.getName());
 	
-	public boolean action(L2PcInstance activeChar, L2Object target, boolean interact);
+	boolean action(L2PcInstance activeChar, L2Object target, boolean interact);
 	
-	public InstanceType getInstanceType();
+	InstanceType getInstanceType();
 }

src/main/java/com/l2jserver/gameserver/handler/IAdminCommandHandler.java

@@ -27,11 +27,11 @@ public interface IAdminCommandHandler {
 	 * @param command
 	 * @return command success
 	 */
-	public boolean useAdminCommand(String command, L2PcInstance activeChar);
+	boolean useAdminCommand(String command, L2PcInstance activeChar);
 	
 	/**
 	 * this method is called at initialization to register all the item ids automatically
 	 * @return all known itemIds
 	 */
-	public String[] getAdminCommandList();
+	String[] getAdminCommandList();
 }

src/main/java/com/l2jserver/gameserver/handler/IBypassHandler.java

@@ -27,7 +27,7 @@ import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
  * @author nBd
  */
 public interface IBypassHandler {
-	public static Logger _log = Logger.getLogger(IBypassHandler.class.getName());
+	Logger _log = Logger.getLogger(IBypassHandler.class.getName());
 	
 	/**
 	 * This is the worker method that is called when someone uses an bypass command.
@@ -36,11 +36,11 @@ public interface IBypassHandler {
 	 * @param bypassOrigin
 	 * @return success
 	 */
-	public boolean useBypass(String command, L2PcInstance activeChar, L2Character bypassOrigin);
+	boolean useBypass(String command, L2PcInstance activeChar, L2Character bypassOrigin);
 	
 	/**
 	 * This method is called at initialization to register all bypasses automatically.
 	 * @return all known bypasses
 	 */
-	public String[] getBypassList();
+	String[] getBypassList();
 }

src/main/java/com/l2jserver/gameserver/handler/IChatHandler.java

@@ -32,11 +32,11 @@ public interface IChatHandler {
 	 * @param target
 	 * @param text
 	 */
-	public void handleChat(int type, L2PcInstance activeChar, String target, String text);
+	void handleChat(int type, L2PcInstance activeChar, String target, String text);
 	
 	/**
 	 * Returns a list of all chat types registered to this handler
 	 * @return
 	 */
-	public int[] getChatTypeList();
+	int[] getChatTypeList();
 }

src/main/java/com/l2jserver/gameserver/handler/IItemHandler.java

@@ -27,7 +27,7 @@ import com.l2jserver.gameserver.model.items.instance.L2ItemInstance;
  * Mother class of all Item Handlers.
  */
 public interface IItemHandler {
-	public static final Logger _log = Logger.getLogger(IItemHandler.class.getName());
+	Logger _log = Logger.getLogger(IItemHandler.class.getName());
 	
 	/**
 	 * Launch task associated to the item.
@@ -36,5 +36,5 @@ public interface IItemHandler {
 	 * @param forceUse ctrl hold on item use
 	 * @return {@code true} if the item all conditions are met and the item is used, {@code false} otherwise.
 	 */
-	public boolean useItem(L2Playable playable, L2ItemInstance item, boolean forceUse);
+	boolean useItem(L2Playable playable, L2ItemInstance item, boolean forceUse);
 }

src/main/java/com/l2jserver/gameserver/handler/IParseBoardHandler.java

@@ -27,7 +27,7 @@ import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
  * @author Zoey76
  */
 public interface IParseBoardHandler {
-	public static final Logger LOG = Logger.getLogger(IParseBoardHandler.class.getName());
+	Logger LOG = Logger.getLogger(IParseBoardHandler.class.getName());
 	
 	/**
 	 * Parses a community board command.
@@ -35,11 +35,11 @@ public interface IParseBoardHandler {
 	 * @param player the player
 	 * @return
 	 */
-	public boolean parseCommunityBoardCommand(String command, L2PcInstance player);
+	boolean parseCommunityBoardCommand(String command, L2PcInstance player);
 	
 	/**
 	 * Gets the community board commands.
 	 * @return the community board commands
 	 */
-	public String[] getCommunityBoardCommands();
+	String[] getCommunityBoardCommands();
 }

src/main/java/com/l2jserver/gameserver/handler/IPunishmentHandler.java

@@ -27,11 +27,11 @@ import com.l2jserver.gameserver.model.punishment.PunishmentType;
  * @author UnAfraid
  */
 public interface IPunishmentHandler {
-	static final Logger _log = Logger.getLogger(IPunishmentHandler.class.getName());
+	Logger _log = Logger.getLogger(IPunishmentHandler.class.getName());
 	
-	public void onStart(PunishmentTask task);
+	void onStart(PunishmentTask task);
 	
-	public void onEnd(PunishmentTask task);
+	void onEnd(PunishmentTask task);
 	
-	public PunishmentType getType();
+	PunishmentType getType();
 }

src/main/java/com/l2jserver/gameserver/handler/ITargetTypeHandler.java

@@ -27,9 +27,9 @@ import com.l2jserver.gameserver.model.skills.targets.L2TargetType;
  * @author UnAfraid
  */
 public interface ITargetTypeHandler {
-	static final L2Object[] EMPTY_TARGET_LIST = new L2Object[0];
+	L2Object[] EMPTY_TARGET_LIST = new L2Object[0];
 	
-	public L2Object[] getTargetList(Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target);
+	L2Object[] getTargetList(Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target);
 	
-	public Enum<L2TargetType> getTargetType();
+	Enum<L2TargetType> getTargetType();
 }

src/main/java/com/l2jserver/gameserver/handler/ITelnetHandler.java

@@ -26,7 +26,7 @@ import java.util.logging.Logger;
  * @author UnAfraid
  */
 public interface ITelnetHandler {
-	public static Logger _log = Logger.getLogger(ITelnetHandler.class.getName());
+	Logger _log = Logger.getLogger(ITelnetHandler.class.getName());
 	
 	/**
 	 * this is the worker method that is called when someone uses an bypass command
@@ -36,11 +36,11 @@ public interface ITelnetHandler {
 	 * @param __uptime
 	 * @return success
 	 */
-	public boolean useCommand(String command, PrintWriter _print, Socket _cSocket, int __uptime);
+	boolean useCommand(String command, PrintWriter _print, Socket _cSocket, int __uptime);
 	
 	/**
 	 * this method is called at initialization to register all bypasses automatically
 	 * @return all known bypasses
 	 */
-	public String[] getCommandList();
+	String[] getCommandList();
 }

src/main/java/com/l2jserver/gameserver/handler/IUserCommandHandler.java

@@ -23,7 +23,7 @@ import java.util.logging.Logger;
 import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
 
 public interface IUserCommandHandler {
-	public static Logger _log = Logger.getLogger(IUserCommandHandler.class.getName());
+	Logger _log = Logger.getLogger(IUserCommandHandler.class.getName());
 	
 	/**
 	 * this is the worker method that is called when someone uses an admin command.
@@ -31,11 +31,11 @@ public interface IUserCommandHandler {
 	 * @param activeChar
 	 * @return command success
 	 */
-	public boolean useUserCommand(int id, L2PcInstance activeChar);
+	boolean useUserCommand(int id, L2PcInstance activeChar);
 	
 	/**
 	 * this method is called at initialization to register all the item ids automatically
 	 * @return all known itemIds
 	 */
-	public int[] getUserCommandList();
+	int[] getUserCommandList();
 }

src/main/java/com/l2jserver/gameserver/handler/IVoicedCommandHandler.java

@@ -23,7 +23,7 @@ import java.util.logging.Logger;
 import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
 
 public interface IVoicedCommandHandler {
-	public static Logger _log = Logger.getLogger(IVoicedCommandHandler.class.getName());
+	Logger _log = Logger.getLogger(IVoicedCommandHandler.class.getName());
 	
 	/**
 	 * this is the worker method that is called when someone uses an admin command.
@@ -32,11 +32,11 @@ public interface IVoicedCommandHandler {
 	 * @param params
 	 * @return command success
 	 */
-	public boolean useVoicedCommand(String command, L2PcInstance activeChar, String params);
+	boolean useVoicedCommand(String command, L2PcInstance activeChar, String params);
 	
 	/**
 	 * this method is called at initialization to register all the item ids automatically
 	 * @return all known itemIds
 	 */
-	public String[] getVoicedCommandList();
+	String[] getVoicedCommandList();
 }

src/main/java/com/l2jserver/gameserver/handler/IWriteBoardHandler.java

@@ -35,5 +35,5 @@ public interface IWriteBoardHandler extends IParseBoardHandler {
 	 * @param arg5 the fifth argument
 	 * @return
 	 */
-	public boolean writeCommunityBoardCommand(L2PcInstance player, String arg1, String arg2, String arg3, String arg4, String arg5);
+	boolean writeCommunityBoardCommand(L2PcInstance player, String arg1, String arg2, String arg3, String arg4, String arg5);
 }

src/main/java/com/l2jserver/gameserver/instancemanager/AntiFeedManager.java

@@ -45,7 +45,7 @@ public final class AntiFeedManager {
 	 * Set time of the last player's death to current
 	 * @param objectId Player's objectId
 	 */
-	public final void setLastDeathTime(int objectId) {
+	public void setLastDeathTime(int objectId) {
 		_lastDeathTimes.put(objectId, System.currentTimeMillis());
 	}
 	
@@ -55,7 +55,7 @@ public final class AntiFeedManager {
 	 * @param target Target character
 	 * @return True if kill is non-feeded.
 	 */
-	public final boolean check(L2Character attacker, L2Character target) {
+	public boolean check(L2Character attacker, L2Character target) {
 		if (!customs().antiFeedEnable()) {
 			return true;
 		}
@@ -97,7 +97,7 @@ public final class AntiFeedManager {
 	/**
 	 * Clears all timestamps
 	 */
-	public final void clear() {
+	public void clear() {
 		_lastDeathTimes.clear();
 	}
 	
@@ -105,7 +105,7 @@ public final class AntiFeedManager {
 	 * Register new event for dualbox check. Should be called only once.
 	 * @param eventId
 	 */
-	public final void registerEvent(int eventId) {
+	public void registerEvent(int eventId) {
 		_eventIPs.putIfAbsent(eventId, new ConcurrentHashMap<Integer, AtomicInteger>());
 	}
 	
@@ -116,7 +116,7 @@ public final class AntiFeedManager {
 	 * @return If number of all simultaneous connections from player's IP address lower than max then increment connection count and return true.<br>
 	 *         False if number of all simultaneous connections from player's IP address higher than max.
 	 */
-	public final boolean tryAddPlayer(int eventId, L2PcInstance player, int max) {
+	public boolean tryAddPlayer(int eventId, L2PcInstance player, int max) {
 		return tryAddClient(eventId, player.getClient(), max);
 	}
 	
@@ -127,7 +127,7 @@ public final class AntiFeedManager {
 	 * @return If number of all simultaneous connections from player's IP address lower than max then increment connection count and return true.<br>
 	 *         False if number of all simultaneous connections from player's IP address higher than max.
 	 */
-	public final boolean tryAddClient(int eventId, L2GameClient client, int max) {
+	public boolean tryAddClient(int eventId, L2GameClient client, int max) {
 		if (client == null) {
 			return false; // unable to determine IP address
 		}
@@ -153,7 +153,7 @@ public final class AntiFeedManager {
 	 * @param player
 	 * @return true if success and false if any problem detected.
 	 */
-	public final boolean removePlayer(int eventId, L2PcInstance player) {
+	public boolean removePlayer(int eventId, L2PcInstance player) {
 		return removeClient(eventId, player.getClient());
 	}
 	
@@ -163,7 +163,7 @@ public final class AntiFeedManager {
 	 * @param client
 	 * @return true if success and false if any problem detected.
 	 */
-	public final boolean removeClient(int eventId, L2GameClient client) {
+	public boolean removeClient(int eventId, L2GameClient client) {
 		if (client == null) {
 			return false; // unable to determine IP address
 		}
@@ -187,7 +187,7 @@ public final class AntiFeedManager {
 	 * Remove player connection IP address from all registered events lists.
 	 * @param client
 	 */
-	public final void onDisconnect(L2GameClient client) {
+	public void onDisconnect(L2GameClient client) {
 		if (client == null) {
 			return;
 		}
@@ -201,7 +201,7 @@ public final class AntiFeedManager {
 	 * Clear all entries for this eventId.
 	 * @param eventId
 	 */
-	public final void clear(int eventId) {
+	public void clear(int eventId) {
 		final Map<Integer, AtomicInteger> event = _eventIPs.get(eventId);
 		if (event != null) {
 			event.clear();
@@ -213,7 +213,7 @@ public final class AntiFeedManager {
 	 * @param max
 	 * @return maximum number of allowed connections (whitelist + max)
 	 */
-	public final int getLimit(L2PcInstance player, int max) {
+	public int getLimit(L2PcInstance player, int max) {
 		return getLimit(player.getClient(), max);
 	}
 	
@@ -222,7 +222,7 @@ public final class AntiFeedManager {
 	 * @param max
 	 * @return maximum number of allowed connections (whitelist + max)
 	 */
-	public final int getLimit(L2GameClient client, int max) {
+	public int getLimit(L2GameClient client, int max) {
 		if (client == null) {
 			return max;
 		}
@@ -235,7 +235,7 @@ public final class AntiFeedManager {
 		return limit;
 	}
 	
-	public static final AntiFeedManager getInstance() {
+	public static AntiFeedManager getInstance() {
 		return SingletonHolder._instance;
 	}
 	

src/main/java/com/l2jserver/gameserver/instancemanager/AuctionManager.java

@@ -94,7 +94,7 @@ public final class AuctionManager {
 		load();
 	}
 	
-	private final void load() {
+	private void load() {
 		try (var con = ConnectionFactory.getInstance().getConnection();
 			var s = con.createStatement();
 			var rs = s.executeQuery("SELECT id FROM auction ORDER BY id")) {
@@ -107,7 +107,7 @@ public final class AuctionManager {
 		}
 	}
 	
-	public final Auction getAuction(int auctionId) {
+	public Auction getAuction(int auctionId) {
 		int index = getAuctionIndex(auctionId);
 		if (index >= 0) {
 			return _auctions.get(index);
@@ -115,7 +115,7 @@ public final class AuctionManager {
 		return null;
 	}
 	
-	public final int getAuctionIndex(int auctionId) {
+	public int getAuctionIndex(int auctionId) {
 		Auction auction;
 		for (int i = 0; i < _auctions.size(); i++) {
 			auction = _auctions.get(i);
@@ -126,7 +126,7 @@ public final class AuctionManager {
 		return -1;
 	}
 	
-	public final List<Auction> getAuctions() {
+	public List<Auction> getAuctions() {
 		return _auctions;
 	}
 	
@@ -152,7 +152,7 @@ public final class AuctionManager {
 		}
 	}
 	
-	public static final AuctionManager getInstance() {
+	public static AuctionManager getInstance() {
 		return SingletonHolder.INSTANCE;
 	}
 	

src/main/java/com/l2jserver/gameserver/instancemanager/CastleManager.java

@@ -57,11 +57,11 @@ public final class CastleManager implements InstanceListManager {
 		8183
 	};
 	
-	public final int findNearestCastleIndex(L2Object obj) {
+	public int findNearestCastleIndex(L2Object obj) {
 		return findNearestCastleIndex(obj, Long.MAX_VALUE);
 	}
 	
-	public final int findNearestCastleIndex(L2Object obj, long maxDistance) {
+	public int findNearestCastleIndex(L2Object obj, long maxDistance) {
 		int index = getCastleIndex(obj);
 		if (index < 0) {
 			double distance;
@@ -81,7 +81,7 @@ public final class CastleManager implements InstanceListManager {
 		return index;
 	}
 	
-	public final Castle getCastleById(int castleId) {
+	public Castle getCastleById(int castleId) {
 		for (Castle temp : _castles) {
 			if (temp.getResidenceId() == castleId) {
 				return temp;
@@ -90,7 +90,7 @@ public final class CastleManager implements InstanceListManager {
 		return null;
 	}
 	
-	public final Castle getCastleByOwner(L2Clan clan) {
+	public Castle getCastleByOwner(L2Clan clan) {
 		for (Castle temp : _castles) {
 			if (temp.getOwnerId() == clan.getId()) {
 				return temp;
@@ -99,7 +99,7 @@ public final class CastleManager implements InstanceListManager {
 		return null;
 	}
 	
-	public final Castle getCastle(String name) {
+	public Castle getCastle(String name) {
 		for (Castle temp : _castles) {
 			if (temp.getName().equalsIgnoreCase(name.trim())) {
 				return temp;
@@ -108,7 +108,7 @@ public final class CastleManager implements InstanceListManager {
 		return null;
 	}
 	
-	public final Castle getCastle(int x, int y, int z) {
+	public Castle getCastle(int x, int y, int z) {
 		for (Castle temp : _castles) {
 			if (temp.checkIfInZone(x, y, z)) {
 				return temp;
@@ -117,11 +117,11 @@ public final class CastleManager implements InstanceListManager {
 		return null;
 	}
 	
-	public final Castle getCastle(L2Object activeObject) {
+	public Castle getCastle(L2Object activeObject) {
 		return getCastle(activeObject.getX(), activeObject.getY(), activeObject.getZ());
 	}
 	
-	public final int getCastleIndex(int castleId) {
+	public int getCastleIndex(int castleId) {
 		Castle castle;
 		for (int i = 0; i < _castles.size(); i++) {
 			castle = _castles.get(i);
@@ -132,11 +132,11 @@ public final class CastleManager implements InstanceListManager {
 		return -1;
 	}
 	
-	public final int getCastleIndex(L2Object activeObject) {
+	public int getCastleIndex(L2Object activeObject) {
 		return getCastleIndex(activeObject.getX(), activeObject.getY(), activeObject.getZ());
 	}
 	
-	public final int getCastleIndex(int x, int y, int z) {
+	public int getCastleIndex(int x, int y, int z) {
 		Castle castle;
 		for (int i = 0; i < _castles.size(); i++) {
 			castle = _castles.get(i);
@@ -147,7 +147,7 @@ public final class CastleManager implements InstanceListManager {
 		return -1;
 	}
 	
-	public final List<Castle> getCastles() {
+	public List<Castle> getCastles() {
 		return _castles;
 	}
 	
@@ -162,7 +162,7 @@ public final class CastleManager implements InstanceListManager {
 		return hasOwnedCastle;
 	}
 	
-	public final void validateTaxes(int sealStrifeOwner) {
+	public void validateTaxes(int sealStrifeOwner) {
 		int maxTax;
 		switch (sealStrifeOwner) {
 			case SevenSigns.CABAL_DUSK:
@@ -275,7 +275,7 @@ public final class CastleManager implements InstanceListManager {
 		return count;
 	}
 	
-	public static final CastleManager getInstance() {
+	public static CastleManager getInstance() {
 		return SingletonHolder._instance;
 	}
 	

src/main/java/com/l2jserver/gameserver/instancemanager/CastleManorManager.java

@@ -114,13 +114,13 @@ public final class CastleManorManager implements IXmlReader, IStorable {
 	}
 	
 	@Override
-	public final void load() {
+	public void load() {
 		parseDatapackFile("data/seeds.xml");
 		LOG.info("Loaded {} seeds.", _seeds.size());
 	}
 	
 	@Override
-	public final void parseDocument(Document doc) {
+	public void parseDocument(Document doc) {
 		StatsSet set;
 		NamedNodeMap attrs;
 		Node att;
@@ -148,7 +148,7 @@ public final class CastleManorManager implements IXmlReader, IStorable {
 		}
 	}
 	
-	private final void loadDb() {
+	private void loadDb() {
 		try (var con = ConnectionFactory.getInstance().getConnection();
 			var stProduction = con.prepareStatement("SELECT * FROM castle_manor_production WHERE castle_id=?");
 			var stProcure = con.prepareStatement("SELECT * FROM castle_manor_procure WHERE castle_id=?")) {
@@ -216,7 +216,7 @@ public final class CastleManorManager implements IXmlReader, IStorable {
 	// Manor methods
 	// -------------------------------------------------------
 	
-	private final void scheduleModeChange() {
+	private void scheduleModeChange() {
 		// Calculate next mode change
 		_nextModeChange = Calendar.getInstance();
 		_nextModeChange.set(Calendar.SECOND, 0);
@@ -241,7 +241,7 @@ public final class CastleManorManager implements IXmlReader, IStorable {
 		ThreadPoolManager.getInstance().scheduleGeneral(this::changeMode, (_nextModeChange.getTimeInMillis() - System.currentTimeMillis()));
 	}
 	
-	public final void changeMode() {
+	public void changeMode() {
 		switch (_mode) {
 			case APPROVED: {
 				// Change mode
@@ -365,7 +365,7 @@ public final class CastleManorManager implements IXmlReader, IStorable {
 		}
 	}
 	
-	public final void setNextSeedProduction(List<SeedProduction> list, int castleId) {
+	public void setNextSeedProduction(List<SeedProduction> list, int castleId) {
 		_productionNext.put(castleId, list);
 		if (general().manorSaveAllActions()) {
 			try (var con = ConnectionFactory.getInstance().getConnection();
@@ -394,7 +394,7 @@ public final class CastleManorManager implements IXmlReader, IStorable {
 		}
 	}
 	
-	public final void setNextCropProcure(List<CropProcure> list, int castleId) {
+	public void setNextCropProcure(List<CropProcure> list, int castleId) {
 		_procureNext.put(castleId, list);
 		if (general().manorSaveAllActions()) {
 			try (var con = ConnectionFactory.getInstance().getConnection();
@@ -424,7 +424,7 @@ public final class CastleManorManager implements IXmlReader, IStorable {
 		}
 	}
 	
-	public final void updateCurrentProduction(int castleId, Collection<SeedProduction> items) {
+	public void updateCurrentProduction(int castleId, Collection<SeedProduction> items) {
 		try (var con = ConnectionFactory.getInstance().getConnection();
 			var ps = con.prepareStatement("UPDATE castle_manor_production SET amount = ? WHERE castle_id = ? AND seed_id = ? AND next_period = 0")) {
 			for (SeedProduction sp : items) {
@@ -439,7 +439,7 @@ public final class CastleManorManager implements IXmlReader, IStorable {
 		}
 	}
 	
-	public final void updateCurrentProcure(int castleId, Collection<CropProcure> items) {
+	public void updateCurrentProcure(int castleId, Collection<CropProcure> items) {
 		try (var con = ConnectionFactory.getInstance().getConnection();
 			var ps = con.prepareStatement("UPDATE castle_manor_procure SET amount = ? WHERE castle_id = ? AND crop_id = ? AND next_period = 0")) {
 			for (CropProcure sp : items) {
@@ -454,11 +454,11 @@ public final class CastleManorManager implements IXmlReader, IStorable {
 		}
 	}
 	
-	public final List<SeedProduction> getSeedProduction(int castleId, boolean nextPeriod) {
+	public List<SeedProduction> getSeedProduction(int castleId, boolean nextPeriod) {
 		return (nextPeriod) ? _productionNext.get(castleId) : _production.get(castleId);
 	}
 	
-	public final SeedProduction getSeedProduct(int castleId, int seedId, boolean nextPeriod) {
+	public SeedProduction getSeedProduct(int castleId, int seedId, boolean nextPeriod) {
 		for (SeedProduction sp : getSeedProduction(castleId, nextPeriod)) {
 			if (sp.getId() == seedId) {
 				return sp;
@@ -467,11 +467,11 @@ public final class CastleManorManager implements IXmlReader, IStorable {
 		return null;
 	}
 	
-	public final List<CropProcure> getCropProcure(int castleId, boolean nextPeriod) {
+	public List<CropProcure> getCropProcure(int castleId, boolean nextPeriod) {
 		return (nextPeriod) ? _procureNext.get(castleId) : _procure.get(castleId);
 	}
 	
-	public final CropProcure getCropProcure(int castleId, int cropId, boolean nextPeriod) {
+	public CropProcure getCropProcure(int castleId, int cropId, boolean nextPeriod) {
 		for (CropProcure cp : getCropProcure(castleId, nextPeriod)) {
 			if (cp.getId() == cropId) {
 				return cp;
@@ -480,7 +480,7 @@ public final class CastleManorManager implements IXmlReader, IStorable {
 		return null;
 	}
 	
-	public final long getManorCost(int castleId, boolean nextPeriod) {
+	public long getManorCost(int castleId, boolean nextPeriod) {
 		final List<CropProcure> procure = getCropProcure(castleId, nextPeriod);
 		final List<SeedProduction> production = getSeedProduction(castleId, nextPeriod);
 		
@@ -496,7 +496,7 @@ public final class CastleManorManager implements IXmlReader, IStorable {
 	}
 	
 	@Override
-	public final boolean storeMe() {
+	public boolean storeMe() {
 		try (var con = ConnectionFactory.getInstance().getConnection();
 			var ds = con.prepareStatement("DELETE FROM castle_manor_production");
 			var is = con.prepareStatement(INSERT_PRODUCT);
@@ -575,7 +575,7 @@ public final class CastleManorManager implements IXmlReader, IStorable {
 		}
 	}
 	
-	public final void resetManorData(int castleId) {
+	public void resetManorData(int castleId) {
 		if (!general().allowManor()) {
 			return;
 		}
@@ -602,23 +602,23 @@ public final class CastleManorManager implements IXmlReader, IStorable {
 		}
 	}
 	
-	public final boolean isUnderMaintenance() {
+	public boolean isUnderMaintenance() {
 		return _mode.equals(ManorMode.MAINTENANCE);
 	}
 	
-	public final boolean isManorApproved() {
+	public boolean isManorApproved() {
 		return _mode.equals(ManorMode.APPROVED);
 	}
 	
-	public final boolean isModifiablePeriod() {
+	public boolean isModifiablePeriod() {
 		return _mode.equals(ManorMode.MODIFIABLE);
 	}
 	
-	public final String getCurrentModeName() {
+	public String getCurrentModeName() {
 		return _mode.toString();
 	}
 	
-	public final String getNextModeChange() {
+	public String getNextModeChange() {
 		return new SimpleDateFormat("dd/MM HH:mm:ss").format(_nextModeChange.getTime());
 	}
 	
@@ -626,7 +626,7 @@ public final class CastleManorManager implements IXmlReader, IStorable {
 	// Seed methods
 	// -------------------------------------------------------
 	
-	public final List<L2Seed> getCrops() {
+	public List<L2Seed> getCrops() {
 		final List<L2Seed> seeds = new ArrayList<>();
 		final List<Integer> cropIds = new ArrayList<>();
 		for (L2Seed seed : _seeds.values()) {
@@ -639,23 +639,23 @@ public final class CastleManorManager implements IXmlReader, IStorable {
 		return seeds;
 	}
 	
-	public final Set<L2Seed> getSeedsForCastle(int castleId) {
+	public Set<L2Seed> getSeedsForCastle(int castleId) {
 		return _seeds.values().stream().filter(s -> s.getCastleId() == castleId).collect(Collectors.toSet());
 	}
 	
-	public final Set<Integer> getSeedIds() {
+	public Set<Integer> getSeedIds() {
 		return _seeds.keySet();
 	}
 	
-	public final Set<Integer> getCropIds() {
+	public Set<Integer> getCropIds() {
 		return _seeds.values().stream().map(L2Seed::getCropId).collect(Collectors.toSet());
 	}
 	
-	public final L2Seed getSeed(int seedId) {
+	public L2Seed getSeed(int seedId) {
 		return _seeds.get(seedId);
 	}
 	
-	public final L2Seed getSeedByCrop(int cropId, int castleId) {
+	public L2Seed getSeedByCrop(int cropId, int castleId) {
 		for (L2Seed s : getSeedsForCastle(castleId)) {
 			if (s.getCropId() == cropId) {
 				return s;
@@ -664,7 +664,7 @@ public final class CastleManorManager implements IXmlReader, IStorable {
 		return null;
 	}
 	
-	public final L2Seed getSeedByCrop(int cropId) {
+	public L2Seed getSeedByCrop(int cropId) {
 		for (L2Seed s : _seeds.values()) {
 			if (s.getCropId() == cropId) {
 				return s;
@@ -673,7 +673,7 @@ public final class CastleManorManager implements IXmlReader, IStorable {
 		return null;
 	}
 	
-	public static final CastleManorManager getInstance() {
+	public static CastleManorManager getInstance() {
 		return SingletonHolder.INSTANCE;
 	}
 	

src/main/java/com/l2jserver/gameserver/instancemanager/ClanHallManager.java

@@ -62,7 +62,7 @@ public final class ClanHallManager {
 		load();
 	}
 	
-	private final void load() {
+	private void load() {
 		try (var con = ConnectionFactory.getInstance().getConnection();
 			var s = con.createStatement();
 			var rs = s.executeQuery("SELECT * FROM clanhall ORDER BY id")) {
@@ -106,49 +106,44 @@ public final class ClanHallManager {
 		}
 	}
 	
-	public static final Map<Integer, ClanHall> getAllClanHalls() {
+	public Map<Integer, ClanHall> getAllClanHalls() {
 		return _allClanHalls;
 	}
 	
-	public final Map<Integer, AuctionableHall> getFreeClanHalls() {
+	public Map<Integer, AuctionableHall> getFreeClanHalls() {
 		return _freeClanHall;
 	}
 	
 	/**
 	 * @return all ClanHalls that have owner
 	 */
-	public final Map<Integer, AuctionableHall> getClanHalls() {
+	public Map<Integer, AuctionableHall> getClanHalls() {
 		return _clanHall;
 	}
 	
-	public final Map<Integer, AuctionableHall> getAllAuctionableClanHalls() {
+	public Map<Integer, AuctionableHall> getAllAuctionableClanHalls() {
 		return _allAuctionableClanHalls;
 	}
 	
-	public static final void addClanHall(ClanHall hall) {
+	public void addClanHall(ClanHall hall) {
 		_allClanHalls.put(hall.getId(), hall);
 	}
 	
-	public final boolean isFree(int chId) {
+	public boolean isFree(int chId) {
 		if (_freeClanHall.containsKey(chId)) {
 			return true;
 		}
 		return false;
 	}
 	
-	public final synchronized void setFree(int chId) {
+	public synchronized void setFree(int chId) {
 		_freeClanHall.put(chId, _clanHall.get(chId));
 		ClanTable.getInstance().getClan(_freeClanHall.get(chId).getOwnerId()).setHideoutId(0);
 		_freeClanHall.get(chId).free();
 		_clanHall.remove(chId);
 	}
 	
-	/**
-	 * Set ClanHallOwner
-	 * @param chId
-	 * @param clan
-	 */
-	public final synchronized void setOwner(int chId, L2Clan clan) {
+	public synchronized void setOwner(int chId, L2Clan clan) {
 		if (!_clanHall.containsKey(chId)) {
 			_clanHall.put(chId, _freeClanHall.get(chId));
 			_freeClanHall.remove(chId);
@@ -159,15 +154,15 @@ public final class ClanHallManager {
 		_clanHall.get(chId).setOwner(clan);
 	}
 	
-	public final ClanHall getClanHallById(int clanHallId) {
+	public ClanHall getClanHallById(int clanHallId) {
 		return _allClanHalls.get(clanHallId);
 	}
 	
-	public final AuctionableHall getAuctionableHallById(int clanHallId) {
+	public AuctionableHall getAuctionableHallById(int clanHallId) {
 		return _allAuctionableClanHalls.get(clanHallId);
 	}
 	
-	public final ClanHall getClanHall(int x, int y, int z) {
+	public ClanHall getClanHall(int x, int y, int z) {
 		for (ClanHall temp : _allClanHalls.values()) {
 			if (temp.checkIfInZone(x, y, z)) {
 				return temp;
@@ -176,11 +171,11 @@ public final class ClanHallManager {
 		return null;
 	}
 	
-	public final ClanHall getClanHall(L2Object activeObject) {
+	public ClanHall getClanHall(L2Object activeObject) {
 		return getClanHall(activeObject.getX(), activeObject.getY(), activeObject.getZ());
 	}
 	
-	public final AuctionableHall getNearbyClanHall(int x, int y, int maxDist) {
+	public AuctionableHall getNearbyClanHall(int x, int y, int maxDist) {
 		L2ClanHallZone zone = null;
 		
 		for (Map.Entry<Integer, AuctionableHall> ch : _clanHall.entrySet()) {
@@ -198,7 +193,7 @@ public final class ClanHallManager {
 		return null;
 	}
 	
-	public final ClanHall getNearbyAbstractHall(int x, int y, int maxDist) {
+	public ClanHall getNearbyAbstractHall(int x, int y, int maxDist) {
 		L2ClanHallZone zone = null;
 		for (Map.Entry<Integer, ClanHall> ch : _allClanHalls.entrySet()) {
 			zone = ch.getValue().getZone();
@@ -209,7 +204,7 @@ public final class ClanHallManager {
 		return null;
 	}
 	
-	public final AuctionableHall getClanHallByOwner(L2Clan clan) {
+	public AuctionableHall getClanHallByOwner(L2Clan clan) {
 		for (Map.Entry<Integer, AuctionableHall> ch : _clanHall.entrySet()) {
 			if (clan.getId() == ch.getValue().getOwnerId()) {
 				return ch.getValue();
@@ -218,7 +213,7 @@ public final class ClanHallManager {
 		return null;
 	}
 	
-	public final ClanHall getAbstractHallByOwner(L2Clan clan) {
+	public ClanHall getAbstractHallByOwner(L2Clan clan) {
 		// Separate loops to avoid iterating over free clan halls
 		for (Map.Entry<Integer, AuctionableHall> ch : _clanHall.entrySet()) {
 			if (clan.getId() == ch.getValue().getOwnerId()) {

src/main/java/com/l2jserver/gameserver/instancemanager/ClanHallSiegeManager.java

@@ -53,7 +53,7 @@ public final class ClanHallSiegeManager {
 		loadClanHalls();
 	}
 	
-	private final void loadClanHalls() {
+	private void loadClanHalls() {
 		try (var con = ConnectionFactory.getInstance().getConnection();
 			var s = con.createStatement();
 			var rs = s.executeQuery(SQL_LOAD_HALLS)) {
@@ -74,7 +74,7 @@ public final class ClanHallSiegeManager {
 				set.set("scheduleConfig", rs.getString("schedule_config"));
 				SiegableHall hall = new SiegableHall(set);
 				_siegableHalls.put(id, hall);
-				ClanHallManager.addClanHall(hall);
+				ClanHallManager.getInstance().addClanHall(hall);
 			}
 			LOG.info("Loaded {} conquerable clan halls.", _siegableHalls.size());
 		} catch (Exception ex) {
@@ -90,11 +90,11 @@ public final class ClanHallSiegeManager {
 		return getConquerableHalls().get(clanHall);
 	}
 	
-	public final SiegableHall getNearbyClanHall(L2Character activeChar) {
+	public SiegableHall getNearbyClanHall(L2Character activeChar) {
 		return getNearbyClanHall(activeChar.getX(), activeChar.getY(), 10000);
 	}
 	
-	public final SiegableHall getNearbyClanHall(int x, int y, int maxDist) {
+	public SiegableHall getNearbyClanHall(int x, int y, int maxDist) {
 		L2ClanHallZone zone = null;
 		
 		for (Map.Entry<Integer, SiegableHall> ch : _siegableHalls.entrySet()) {
@@ -106,7 +106,7 @@ public final class ClanHallSiegeManager {
 		return null;
 	}
 	
-	public final ClanHallSiegeEngine getSiege(L2Character character) {
+	public ClanHallSiegeEngine getSiege(L2Character character) {
 		SiegableHall hall = getNearbyClanHall(character);
 		if (hall == null) {
 			return null;
@@ -114,7 +114,7 @@ public final class ClanHallSiegeManager {
 		return hall.getSiege();
 	}
 	
-	public final void registerClan(L2Clan clan, SiegableHall hall, L2PcInstance player) {
+	public void registerClan(L2Clan clan, SiegableHall hall, L2PcInstance player) {
 		if (clan.getLevel() < clanhall().getMinClanLevel()) {
 			player.sendMessage("Only clans of level " + clanhall().getMinClanLevel() + " or higher may register for a castle siege");
 		} else if (hall.isWaitingBattle()) {
@@ -138,14 +138,14 @@ public final class ClanHallSiegeManager {
 		}
 	}
 	
-	public final void unRegisterClan(L2Clan clan, SiegableHall hall) {
+	public void unRegisterClan(L2Clan clan, SiegableHall hall) {
 		if (!hall.isRegistering()) {
 			return;
 		}
 		hall.removeAttacker(clan);
 	}
 	
-	public final boolean isClanParticipating(L2Clan clan) {
+	public boolean isClanParticipating(L2Clan clan) {
 		for (SiegableHall hall : getConquerableHalls().values()) {
 			if ((hall.getSiege() != null) && hall.getSiege().checkIsAttacker(clan)) {
 				return true;
@@ -154,7 +154,7 @@ public final class ClanHallSiegeManager {
 		return false;
 	}
 	
-	public final void onServerShutDown() {
+	public void onServerShutDown() {
 		for (SiegableHall hall : getConquerableHalls().values()) {
 			// Rainbow springs has his own attackers table
 			if ((hall.getId() == 62) || (hall.getSiege() == null)) {

src/main/java/com/l2jserver/gameserver/instancemanager/CoupleManager.java

@@ -47,7 +47,7 @@ public final class CoupleManager {
 		load();
 	}
 	
-	private final void load() {
+	private void load() {
 		try (var con = ConnectionFactory.getInstance().getConnection();
 			var ps = con.createStatement();
 			var rs = ps.executeQuery("SELECT id FROM mods_wedding ORDER BY id")) {
@@ -60,7 +60,7 @@ public final class CoupleManager {
 		}
 	}
 	
-	public final Couple getCouple(int coupleId) {
+	public Couple getCouple(int coupleId) {
 		int index = getCoupleIndex(coupleId);
 		if (index >= 0) {
 			return getCouples().get(index);
@@ -107,7 +107,7 @@ public final class CoupleManager {
 		}
 	}
 	
-	public final int getCoupleIndex(int coupleId) {
+	public int getCoupleIndex(int coupleId) {
 		int i = 0;
 		for (Couple temp : getCouples()) {
 			if ((temp != null) && (temp.getId() == coupleId)) {
@@ -118,11 +118,11 @@ public final class CoupleManager {
 		return -1;
 	}
 	
-	public final List<Couple> getCouples() {
+	public List<Couple> getCouples() {
 		return _couples;
 	}
 	
-	public static final CoupleManager getInstance() {
+	public static CoupleManager getInstance() {
 		return SingletonHolder._instance;
 	}
 	

src/main/java/com/l2jserver/gameserver/instancemanager/CursedWeaponsManager.java

@@ -79,11 +79,11 @@ public final class CursedWeaponsManager {
 		LOG.info("Loaded {} cursed weapon(s).", _cursedWeapons.size());
 	}
 	
-	public final void reload() {
+	public void reload() {
 		init();
 	}
 	
-	private final void load() {
+	private void load() {
 		try {
 			DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
 			factory.setValidating(false);
@@ -144,7 +144,7 @@ public final class CursedWeaponsManager {
 		}
 	}
 	
-	private final void restore() {
+	private void restore() {
 		try (var con = ConnectionFactory.getInstance().getConnection();
 			var s = con.createStatement();
 			var rs = s.executeQuery("SELECT itemId, charId, playerKarma, playerPkKills, nbKills, endTime FROM cursed_weapons")) {
@@ -164,7 +164,7 @@ public final class CursedWeaponsManager {
 		}
 	}
 	
-	private final void controlPlayers() {
+	private void controlPlayers() {
 		// TODO: See comments below...
 		// This entire for loop should NOT be necessary, since it is already handled by
 		// CursedWeapon.endOfLife(). However, if we indeed *need* to duplicate it for safety,
@@ -352,7 +352,7 @@ public final class CursedWeaponsManager {
 		}
 	}
 	
-	public static final CursedWeaponsManager getInstance() {
+	public static CursedWeaponsManager getInstance() {
 		return SingletonHolder._instance;
 	}
 	

src/main/java/com/l2jserver/gameserver/instancemanager/DuelManager.java

@@ -139,7 +139,7 @@ public final class DuelManager {
 		return true;
 	}
 	
-	public static final DuelManager getInstance() {
+	public static DuelManager getInstance() {
 		return SingletonHolder._instance;
 	}
 	

src/main/java/com/l2jserver/gameserver/instancemanager/FortManager.java

@@ -36,11 +36,11 @@ public final class FortManager implements InstanceListManager {
 	
 	private final List<Fort> _forts = new ArrayList<>();
 	
-	public final int findNearestFortIndex(L2Object obj) {
+	public int findNearestFortIndex(L2Object obj) {
 		return findNearestFortIndex(obj, Long.MAX_VALUE);
 	}
 	
-	public final int findNearestFortIndex(L2Object obj, long maxDistance) {
+	public int findNearestFortIndex(L2Object obj, long maxDistance) {
 		int index = getFortIndex(obj);
 		if (index < 0) {
 			double distance;
@@ -60,7 +60,7 @@ public final class FortManager implements InstanceListManager {
 		return index;
 	}
 	
-	public final Fort getFortById(int fortId) {
+	public Fort getFortById(int fortId) {
 		for (Fort f : _forts) {
 			if (f.getResidenceId() == fortId) {
 				return f;
@@ -69,7 +69,7 @@ public final class FortManager implements InstanceListManager {
 		return null;
 	}
 	
-	public final Fort getFortByOwner(L2Clan clan) {
+	public Fort getFortByOwner(L2Clan clan) {
 		for (Fort f : _forts) {
 			if (f.getOwnerClan() == clan) {
 				return f;
@@ -78,7 +78,7 @@ public final class FortManager implements InstanceListManager {
 		return null;
 	}
 	
-	public final Fort getFort(String name) {
+	public Fort getFort(String name) {
 		for (Fort f : _forts) {
 			if (f.getName().equalsIgnoreCase(name.trim())) {
 				return f;
@@ -87,7 +87,7 @@ public final class FortManager implements InstanceListManager {
 		return null;
 	}
 	
-	public final Fort getFort(int x, int y, int z) {
+	public Fort getFort(int x, int y, int z) {
 		for (Fort f : _forts) {
 			if (f.checkIfInZone(x, y, z)) {
 				return f;
@@ -96,11 +96,11 @@ public final class FortManager implements InstanceListManager {
 		return null;
 	}
 	
-	public final Fort getFort(L2Object activeObject) {
+	public Fort getFort(L2Object activeObject) {
 		return getFort(activeObject.getX(), activeObject.getY(), activeObject.getZ());
 	}
 	
-	public final int getFortIndex(int fortId) {
+	public int getFortIndex(int fortId) {
 		Fort fort;
 		for (int i = 0; i < _forts.size(); i++) {
 			fort = _forts.get(i);
@@ -111,11 +111,11 @@ public final class FortManager implements InstanceListManager {
 		return -1;
 	}
 	
-	public final int getFortIndex(L2Object activeObject) {
+	public int getFortIndex(L2Object activeObject) {
 		return getFortIndex(activeObject.getX(), activeObject.getY(), activeObject.getZ());
 	}
 	
-	public final int getFortIndex(int x, int y, int z) {
+	public int getFortIndex(int x, int y, int z) {
 		Fort fort;
 		for (int i = 0; i < _forts.size(); i++) {
 			fort = _forts.get(i);
@@ -126,7 +126,7 @@ public final class FortManager implements InstanceListManager {
 		return -1;
 	}
 	
-	public final List<Fort> getForts() {
+	public List<Fort> getForts() {
 		return _forts;
 	}
 	
@@ -160,7 +160,7 @@ public final class FortManager implements InstanceListManager {
 		}
 	}
 	
-	public static final FortManager getInstance() {
+	public static FortManager getInstance() {
 		return SingletonHolder._instance;
 	}
 	

src/main/java/com/l2jserver/gameserver/instancemanager/FortSiegeGuardManager.java

@@ -105,11 +105,11 @@ public final class FortSiegeGuardManager {
 		}
 	}
 	
-	public final Fort getFort() {
+	public Fort getFort() {
 		return _fort;
 	}
 	
-	public final Map<Integer, List<L2Spawn>> getSiegeGuardSpawn() {
+	public Map<Integer, List<L2Spawn>> getSiegeGuardSpawn() {
 		return _siegeGuards;
 	}
 }

src/main/java/com/l2jserver/gameserver/instancemanager/FortSiegeManager.java

@@ -54,7 +54,7 @@ public final class FortSiegeManager {
 		load();
 	}
 	
-	public final void addSiegeSkills(L2PcInstance character) {
+	public void addSiegeSkills(L2PcInstance character) {
 		character.addSkill(CommonSkill.SEAL_OF_RULER.getSkill(), false);
 		character.addSkill(CommonSkill.BUILD_HEADQUARTERS.getSkill(), false);
 	}
@@ -64,7 +64,7 @@ public final class FortSiegeManager {
 	 * @param fortid
 	 * @return true if the clan is registered or owner of a fort
 	 */
-	public final boolean checkIsRegistered(L2Clan clan, int fortid) {
+	public boolean checkIsRegistered(L2Clan clan, int fortid) {
 		if (clan == null) {
 			return false;
 		}
@@ -86,12 +86,12 @@ public final class FortSiegeManager {
 		return register;
 	}
 	
-	public final void removeSiegeSkills(L2PcInstance character) {
+	public void removeSiegeSkills(L2PcInstance character) {
 		character.removeSkill(CommonSkill.SEAL_OF_RULER.getSkill());
 		character.removeSkill(CommonSkill.BUILD_HEADQUARTERS.getSkill());
 	}
 	
-	private final void load() {
+	private void load() {
 		// Siege spawns settings
 		_commanderSpawnList = new ConcurrentHashMap<>();
 		_flagList = new ConcurrentHashMap<>();
@@ -142,19 +142,19 @@ public final class FortSiegeManager {
 		}
 	}
 	
-	public final List<FortSiegeSpawn> getCommanderSpawnList(int _fortId) {
+	public List<FortSiegeSpawn> getCommanderSpawnList(int _fortId) {
 		return _commanderSpawnList.get(_fortId);
 	}
 	
-	public final List<CombatFlag> getFlagList(int _fortId) {
+	public List<CombatFlag> getFlagList(int _fortId) {
 		return _flagList.get(_fortId);
 	}
 	
-	public final FortSiege getSiege(L2Object activeObject) {
+	public FortSiege getSiege(L2Object activeObject) {
 		return getSiege(activeObject.getX(), activeObject.getY(), activeObject.getZ());
 	}
 	
-	public final FortSiege getSiege(int x, int y, int z) {
+	public FortSiege getSiege(int x, int y, int z) {
 		for (Fort fort : FortManager.getInstance().getForts()) {
 			if (fort.getSiege().checkIfInZone(x, y, z)) {
 				return fort.getSiege();
@@ -163,11 +163,11 @@ public final class FortSiegeManager {
 		return null;
 	}
 	
-	public final List<FortSiege> getSieges() {
+	public List<FortSiege> getSieges() {
 		return _sieges;
 	}
 	
-	public final void addSiege(FortSiege fortSiege) {
+	public void addSiege(FortSiege fortSiege) {
 		_sieges.add(fortSiege);
 	}
 	
@@ -230,7 +230,7 @@ public final class FortSiegeManager {
 		}
 	}
 	
-	public static final FortSiegeManager getInstance() {
+	public static FortSiegeManager getInstance() {
 		return SingletonHolder._instance;
 	}
 	

src/main/java/com/l2jserver/gameserver/instancemanager/FourSepulchersManager.java

@@ -1339,7 +1339,7 @@ public final class FourSepulchersManager {
 		player.sendPacket(html);
 	}
 	
-	public static final FourSepulchersManager getInstance() {
+	public static FourSepulchersManager getInstance() {
 		return SingletonHolder._instance;
 	}
 	

src/main/java/com/l2jserver/gameserver/instancemanager/GlobalVariablesManager.java

@@ -93,7 +93,7 @@ public final class GlobalVariablesManager extends AbstractVariables {
 		return true;
 	}
 	
-	public static final GlobalVariablesManager getInstance() {
+	public static GlobalVariablesManager getInstance() {
 		return SingletonHolder._instance;
 	}
 	

src/main/java/com/l2jserver/gameserver/instancemanager/GraciaSeedsManager.java

@@ -177,7 +177,7 @@ public final class GraciaSeedsManager {
 	 * Gets the single instance of {@code GraciaSeedsManager}.
 	 * @return single instance of {@code GraciaSeedsManager}
 	 */
-	public static final GraciaSeedsManager getInstance() {
+	public static GraciaSeedsManager getInstance() {
 		return SingletonHolder._instance;
 	}
 	

src/main/java/com/l2jserver/gameserver/instancemanager/InstanceManager.java

@@ -269,7 +269,7 @@ public final class InstanceManager implements IXmlReader {
 		return _dynamic;
 	}
 	
-	public static final InstanceManager getInstance() {
+	public static InstanceManager getInstance() {
 		return SingletonHolder._instance;
 	}
 	

src/main/java/com/l2jserver/gameserver/instancemanager/ItemAuctionManager.java

@@ -102,21 +102,21 @@ public final class ItemAuctionManager {
 		}
 	}
 	
-	public final void shutdown() {
+	public void shutdown() {
 		for (ItemAuctionInstance instance : _managerInstances.values()) {
 			instance.shutdown();
 		}
 	}
 	
-	public final ItemAuctionInstance getManagerInstance(final int instanceId) {
+	public ItemAuctionInstance getManagerInstance(final int instanceId) {
 		return _managerInstances.get(instanceId);
 	}
 	
-	public final int getNextAuctionId() {
+	public int getNextAuctionId() {
 		return _auctionIds.getAndIncrement();
 	}
 	
-	public static final void deleteAuction(final int auctionId) {
+	public static void deleteAuction(final int auctionId) {
 		try (var con = ConnectionFactory.getInstance().getConnection()) {
 			try (var ps = con.prepareStatement("DELETE FROM item_auction WHERE auctionId=?")) {
 				ps.setInt(1, auctionId);
@@ -136,7 +136,7 @@ public final class ItemAuctionManager {
 	 * Gets the single instance of {@code ItemAuctionManager}.
 	 * @return single instance of {@code ItemAuctionManager}
 	 */
-	public static final ItemAuctionManager getInstance() {
+	public static ItemAuctionManager getInstance() {
 		return SingletonHolder.INSTANCE;
 	}
 	

src/main/java/com/l2jserver/gameserver/instancemanager/ItemsOnGroundManager.java

@@ -203,7 +203,7 @@ public final class ItemsOnGroundManager implements Runnable {
 	 * Gets the single instance of {@code ItemsOnGroundManager}.
 	 * @return single instance of {@code ItemsOnGroundManager}
 	 */
-	public static final ItemsOnGroundManager getInstance() {
+	public static ItemsOnGroundManager getInstance() {
 		return SingletonHolder._instance;
 	}
 	

src/main/java/com/l2jserver/gameserver/instancemanager/MailManager.java

@@ -77,15 +77,15 @@ public final class MailManager {
 		LOG.info("Successfully loaded {} messages.", count);
 	}
 	
-	public final Message getMessage(int msgId) {
+	public Message getMessage(int msgId) {
 		return _messages.get(msgId);
 	}
 	
-	public final Collection<Message> getMessages() {
+	public Collection<Message> getMessages() {
 		return _messages.values();
 	}
 	
-	public final boolean hasUnreadPost(L2PcInstance player) {
+	public boolean hasUnreadPost(L2PcInstance player) {
 		final int objectId = player.getObjectId();
 		for (Message msg : getMessages()) {
 			if ((msg != null) && (msg.getReceiverId() == objectId) && msg.isUnread()) {
@@ -95,7 +95,7 @@ public final class MailManager {
 		return false;
 	}
 	
-	public final int getInboxSize(int objectId) {
+	public int getInboxSize(int objectId) {
 		int size = 0;
 		for (Message msg : getMessages()) {
 			if ((msg != null) && (msg.getReceiverId() == objectId) && !msg.isDeletedByReceiver()) {
@@ -105,7 +105,7 @@ public final class MailManager {
 		return size;
 	}
 	
-	public final int getOutboxSize(int objectId) {
+	public int getOutboxSize(int objectId) {
 		int size = 0;
 		for (Message msg : getMessages()) {
 			if ((msg != null) && (msg.getSenderId() == objectId) && !msg.isDeletedBySender()) {
@@ -115,7 +115,7 @@ public final class MailManager {
 		return size;
 	}
 	
-	public final List<Message> getInbox(int objectId) {
+	public List<Message> getInbox(int objectId) {
 		final List<Message> inbox = new ArrayList<>();
 		for (Message msg : getMessages()) {
 			if ((msg != null) && (msg.getReceiverId() == objectId) && !msg.isDeletedByReceiver()) {
@@ -125,7 +125,7 @@ public final class MailManager {
 		return inbox;
 	}
 	
-	public final List<Message> getOutbox(int objectId) {
+	public List<Message> getOutbox(int objectId) {
 		final List<Message> outbox = new ArrayList<>();
 		for (Message msg : getMessages()) {
 			if ((msg != null) && (msg.getSenderId() == objectId) && !msg.isDeletedBySender()) {
@@ -152,7 +152,7 @@ public final class MailManager {
 		ThreadPoolManager.getInstance().scheduleGeneral(new MessageDeletionTask(msg.getId()), msg.getExpiration() - System.currentTimeMillis());
 	}
 	
-	public final void markAsReadInDb(int msgId) {
+	public void markAsReadInDb(int msgId) {
 		try (var con = ConnectionFactory.getInstance().getConnection();
 			var ps = con.prepareStatement("UPDATE messages SET isUnread = 'false' WHERE messageId = ?")) {
 			ps.setInt(1, msgId);
@@ -162,7 +162,7 @@ public final class MailManager {
 		}
 	}
 	
-	public final void markAsDeletedBySenderInDb(int msgId) {
+	public void markAsDeletedBySenderInDb(int msgId) {
 		try (var con = ConnectionFactory.getInstance().getConnection();
 			var ps = con.prepareStatement("UPDATE messages SET isDeletedBySender = 'true' WHERE messageId = ?")) {
 			ps.setInt(1, msgId);
@@ -172,7 +172,7 @@ public final class MailManager {
 		}
 	}
 	
-	public final void markAsDeletedByReceiverInDb(int msgId) {
+	public void markAsDeletedByReceiverInDb(int msgId) {
 		try (var con = ConnectionFactory.getInstance().getConnection();
 			var ps = con.prepareStatement("UPDATE messages SET isDeletedByReceiver = 'true' WHERE messageId = ?")) {
 			ps.setInt(1, msgId);
@@ -182,7 +182,7 @@ public final class MailManager {
 		}
 	}
 	
-	public final void removeAttachmentsInDb(int msgId) {
+	public void removeAttachmentsInDb(int msgId) {
 		try (var con = ConnectionFactory.getInstance().getConnection();
 			var ps = con.prepareStatement("UPDATE messages SET hasAttachments = 'false' WHERE messageId = ?")) {
 			ps.setInt(1, msgId);
@@ -192,7 +192,7 @@ public final class MailManager {
 		}
 	}
 	
-	public final void deleteMessageInDb(int msgId) {
+	public void deleteMessageInDb(int msgId) {
 		try (var con = ConnectionFactory.getInstance().getConnection();
 			var ps = con.prepareStatement("DELETE FROM messages WHERE messageId = ?")) {
 			ps.setInt(1, msgId);

src/main/java/com/l2jserver/gameserver/instancemanager/MapRegionManager.java

@@ -123,7 +123,7 @@ public final class MapRegionManager implements IXmlReader {
 		}
 	}
 	
-	public final L2MapRegion getMapRegion(int locX, int locY) {
+	public L2MapRegion getMapRegion(int locX, int locY) {
 		for (L2MapRegion region : REGIONS.values()) {
 			if (region.isZoneInRegion(getMapRegionX(locX), getMapRegionY(locY))) {
 				return region;
@@ -132,7 +132,7 @@ public final class MapRegionManager implements IXmlReader {
 		return null;
 	}
 	
-	public final int getMapRegionLocId(int locX, int locY) {
+	public int getMapRegionLocId(int locX, int locY) {
 		L2MapRegion region = getMapRegion(locX, locY);
 		if (region != null) {
 			return region.getLocId();
@@ -140,19 +140,19 @@ public final class MapRegionManager implements IXmlReader {
 		return 0;
 	}
 	
-	public final L2MapRegion getMapRegion(L2Object obj) {
+	public L2MapRegion getMapRegion(L2Object obj) {
 		return getMapRegion(obj.getX(), obj.getY());
 	}
 	
-	public final int getMapRegionLocId(L2Object obj) {
+	public int getMapRegionLocId(L2Object obj) {
 		return getMapRegionLocId(obj.getX(), obj.getY());
 	}
 	
-	public final int getMapRegionX(int posX) {
+	public int getMapRegionX(int posX) {
 		return (posX >> 15) + 9 + 11;// + centerTileX;
 	}
 	
-	public final int getMapRegionY(int posY) {
+	public int getMapRegionY(int posY) {
 		return (posY >> 15) + 10 + 8;// + centerTileX;
 	}
 	

src/main/java/com/l2jserver/gameserver/instancemanager/MercTicketManager.java

@@ -134,7 +134,7 @@ public final class MercTicketManager {
 		load();
 	}
 	
-	private final void load() {
+	private void load() {
 		try (var con = ConnectionFactory.getInstance().getConnection();
 			var s = con.createStatement();
 			var rs = s.executeQuery("SELECT * FROM castle_siege_guards Where isHired = 1")) {
@@ -365,7 +365,7 @@ public final class MercTicketManager {
 		return ITEM_IDS;
 	}
 	
-	public final List<L2ItemInstance> getDroppedTickets() {
+	public List<L2ItemInstance> getDroppedTickets() {
 		return DROPPED_TICKETS;
 	}
 	
@@ -373,7 +373,7 @@ public final class MercTicketManager {
 	 * Gets the single instance of {@code MercTicketManager}.
 	 * @return single instance of {@code MercTicketManager}
 	 */
-	public static final MercTicketManager getInstance() {
+	public static MercTicketManager getInstance() {
 		return SingletonHolder._instance;
 	}
 	

src/main/java/com/l2jserver/gameserver/instancemanager/PetitionManager.java

@@ -393,7 +393,7 @@ public final class PetitionManager {
 	 * Gets the single instance of {@code PetitionManager}.
 	 * @return single instance of {@code PetitionManager}
 	 */
-	public static final PetitionManager getInstance() {
+	public static PetitionManager getInstance() {
 		return SingletonHolder._instance;
 	}
 	

src/main/java/com/l2jserver/gameserver/instancemanager/PunishmentManager.java

@@ -110,7 +110,7 @@ public final class PunishmentManager {
 	 * Gets the single instance of {@code PunishmentManager}.
 	 * @return single instance of {@code PunishmentManager}
 	 */
-	public static final PunishmentManager getInstance() {
+	public static PunishmentManager getInstance() {
 		return SingletonHolder._instance;
 	}
 	

src/main/java/com/l2jserver/gameserver/instancemanager/RaidBossSpawnManager.java

@@ -53,7 +53,7 @@ public class RaidBossSpawnManager {
 	
 	protected static final Map<Integer, ScheduledFuture<?>> _schedules = new ConcurrentHashMap<>();
 	
-	public static enum StatusEnum {
+	public enum StatusEnum {
 		ALIVE,
 		DEAD,
 		UNDEFINED

src/main/java/com/l2jserver/gameserver/instancemanager/SiegeGuardManager.java

@@ -216,11 +216,11 @@ public final class SiegeGuardManager {
 		}
 	}
 	
-	public final Castle getCastle() {
+	public Castle getCastle() {
 		return _castle;
 	}
 	
-	public final List<L2Spawn> getSiegeGuardSpawn() {
+	public List<L2Spawn> getSiegeGuardSpawn() {
 		return _siegeGuardSpawn;
 	}
 }

src/main/java/com/l2jserver/gameserver/instancemanager/SiegeManager.java

@@ -47,25 +47,25 @@ public final class SiegeManager {
 	
 	private final Map<Integer, List<TowerSpawn>> _flameTowers = new HashMap<>();
 	
-	private int _attackerMaxClans = siege().getAttackerMaxClans();
+	private final int _attackerMaxClans = siege().getAttackerMaxClans();
 	
-	private int _attackerRespawnDelay = siege().getAttackerRespawn();
+	private final int _attackerRespawnDelay = siege().getAttackerRespawn();
 	
-	private int _defenderMaxClans = siege().getDefenderMaxClans();
+	private final int _defenderMaxClans = siege().getDefenderMaxClans();
 	
-	private int _flagMaxCount = siege().getMaxFlags();
+	private final int _flagMaxCount = siege().getMaxFlags();
 	
-	private int _siegeClanMinLevel = siege().getClanMinLevel();
+	private final int _siegeClanMinLevel = siege().getClanMinLevel();
 	
-	private int _siegeLength = siege().getSiegeLength();
+	private final int _siegeLength = siege().getSiegeLength();
 	
-	private int _bloodAllianceReward = siege().getBloodAllianceReward();
+	private final int _bloodAllianceReward = siege().getBloodAllianceReward();
 	
 	protected SiegeManager() {
 		load();
 	}
 	
-	public final void addSiegeSkills(L2PcInstance character) {
+	public void addSiegeSkills(L2PcInstance character) {
 		for (Skill sk : SkillData.getInstance().getSiegeSkills(character.isNoble(), character.getClan().getCastleId() > 0)) {
 			character.addSkill(sk, false);
 		}
@@ -76,7 +76,7 @@ public final class SiegeManager {
 	 * @param castleid
 	 * @return true if the clan is registered or owner of a castle
 	 */
-	public final boolean checkIsRegistered(L2Clan clan, int castleid) {
+	public boolean checkIsRegistered(L2Clan clan, int castleid) {
 		if (clan == null) {
 			return false;
 		}
@@ -102,13 +102,13 @@ public final class SiegeManager {
 		return register;
 	}
 	
-	public final void removeSiegeSkills(L2PcInstance character) {
+	public void removeSiegeSkills(L2PcInstance character) {
 		for (Skill sk : SkillData.getInstance().getSiegeSkills(character.isNoble(), character.getClan().getCastleId() > 0)) {
 			character.removeSkill(sk);
 		}
 	}
 	
-	private final void load() {
+	private void load() {
 		// Gludio
 		_controlTowers.put(1, List.of(siege().getGludioControlTower1(), //
 			siege().getGludioControlTower2(), //
@@ -180,39 +180,39 @@ public final class SiegeManager {
 		}
 	}
 	
-	public final List<TowerSpawn> getControlTowers(int castleId) {
+	public List<TowerSpawn> getControlTowers(int castleId) {
 		return _controlTowers.get(castleId);
 	}
 	
-	public final List<TowerSpawn> getFlameTowers(int castleId) {
+	public List<TowerSpawn> getFlameTowers(int castleId) {
 		return _flameTowers.get(castleId);
 	}
 	
-	public final int getAttackerMaxClans() {
+	public int getAttackerMaxClans() {
 		return _attackerMaxClans;
 	}
 	
-	public final int getAttackerRespawnDelay() {
+	public int getAttackerRespawnDelay() {
 		return _attackerRespawnDelay;
 	}
 	
-	public final int getDefenderMaxClans() {
+	public int getDefenderMaxClans() {
 		return _defenderMaxClans;
 	}
 	
-	public final int getFlagMaxCount() {
+	public int getFlagMaxCount() {
 		return _flagMaxCount;
 	}
 	
-	public final Siege getSiege(ILocational loc) {
+	public Siege getSiege(ILocational loc) {
 		return getSiege(loc.getX(), loc.getY(), loc.getZ());
 	}
 	
-	public final Siege getSiege(L2Object activeObject) {
+	public Siege getSiege(L2Object activeObject) {
 		return getSiege(activeObject.getX(), activeObject.getY(), activeObject.getZ());
 	}
 	
-	public final Siege getSiege(int x, int y, int z) {
+	public Siege getSiege(int x, int y, int z) {
 		for (Castle castle : CastleManager.getInstance().getCastles()) {
 			if (castle.getSiege().checkIfInZone(x, y, z)) {
 				return castle.getSiege();
@@ -221,19 +221,19 @@ public final class SiegeManager {
 		return null;
 	}
 	
-	public final int getSiegeClanMinLevel() {
+	public int getSiegeClanMinLevel() {
 		return _siegeClanMinLevel;
 	}
 	
-	public final int getSiegeLength() {
+	public int getSiegeLength() {
 		return _siegeLength;
 	}
 	
-	public final int getBloodAllianceReward() {
+	public int getBloodAllianceReward() {
 		return _bloodAllianceReward;
 	}
 	
-	public final List<Siege> getSieges() {
+	public List<Siege> getSieges() {
 		List<Siege> sieges = new ArrayList<>();
 		for (Castle castle : CastleManager.getInstance().getCastles()) {
 			sieges.add(castle.getSiege());
@@ -241,7 +241,7 @@ public final class SiegeManager {
 		return sieges;
 	}
 	
-	private final void loadTrapUpgrade(int castleId) {
+	private void loadTrapUpgrade(int castleId) {
 		try (var con = ConnectionFactory.getInstance().getConnection();
 			var ps = con.prepareStatement("SELECT * FROM castle_trapupgrade WHERE castleId=?")) {
 			ps.setInt(1, castleId);
@@ -255,7 +255,7 @@ public final class SiegeManager {
 		}
 	}
 	
-	public static final SiegeManager getInstance() {
+	public static SiegeManager getInstance() {
 		return SingletonHolder._instance;
 	}
 	

src/main/java/com/l2jserver/gameserver/instancemanager/TerritoryWarManager.java

@@ -146,7 +146,7 @@ public final class TerritoryWarManager implements Siegable {
 	 * @param clan The L2Clan of the player
 	 * @return true if the clan is registered
 	 */
-	public final boolean checkIsRegistered(int castleId, L2Clan clan) {
+	public boolean checkIsRegistered(int castleId, L2Clan clan) {
 		if (clan == null) {
 			return false;
 		}
@@ -171,7 +171,7 @@ public final class TerritoryWarManager implements Siegable {
 	 * @param objId
 	 * @return true if the player is registered
 	 */
-	public final boolean checkIsRegistered(int castleId, int objId) {
+	public boolean checkIsRegistered(int castleId, int objId) {
 		if (castleId == -1) {
 			for (int cId : _registeredMercenaries.keySet()) {
 				if (_registeredMercenaries.get(cId).contains(objId)) {
@@ -621,7 +621,7 @@ public final class TerritoryWarManager implements Siegable {
 		}
 	}
 	
-	private final void load() {
+	private void load() {
 		try (var con = ConnectionFactory.getInstance().getConnection();
 			var s = con.createStatement();
 			var rs = s.executeQuery("SELECT * FROM territory_spawnlist")) {
@@ -1386,7 +1386,7 @@ public final class TerritoryWarManager implements Siegable {
 		// TODO(Zoey76): Implement.
 	}
 	
-	public static final TerritoryWarManager getInstance() {
+	public static TerritoryWarManager getInstance() {
 		return SingletonHolder._instance;
 	}
 	

src/main/java/com/l2jserver/gameserver/instancemanager/TownManager.java

@@ -23,7 +23,7 @@ import com.l2jserver.gameserver.model.zone.L2ZoneType;
 import com.l2jserver.gameserver.model.zone.type.L2TownZone;
 
 public final class TownManager {
-	public static final int getTownCastle(int townId) {
+	public static int getTownCastle(int townId) {
 		switch (townId) {
 			case 912:
 				return 1;
@@ -48,7 +48,7 @@ public final class TownManager {
 		}
 	}
 	
-	public static final boolean townHasCastleInSiege(int townId) {
+	public static boolean townHasCastleInSiege(int townId) {
 		int castleIndex = getTownCastle(townId);
 		
 		if (castleIndex > 0) {
@@ -60,11 +60,11 @@ public final class TownManager {
 		return false;
 	}
 	
-	public static final boolean townHasCastleInSiege(int x, int y) {
+	public static boolean townHasCastleInSiege(int x, int y) {
 		return townHasCastleInSiege(MapRegionManager.getInstance().getMapRegionLocId(x, y));
 	}
 	
-	public static final L2TownZone getTown(int townId) {
+	public static L2TownZone getTown(int townId) {
 		for (L2TownZone temp : ZoneManager.getInstance().getAllZones(L2TownZone.class)) {
 			if (temp.getTownId() == townId) {
 				return temp;
@@ -80,7 +80,7 @@ public final class TownManager {
 	 * @param z
 	 * @return
 	 */
-	public static final L2TownZone getTown(int x, int y, int z) {
+	public static L2TownZone getTown(int x, int y, int z) {
 		for (L2ZoneType temp : ZoneManager.getInstance().getZones(x, y, z)) {
 			if (temp instanceof L2TownZone) {
 				return (L2TownZone) temp;

src/main/java/com/l2jserver/gameserver/instancemanager/WalkingManager.java

@@ -77,7 +77,7 @@ public final class WalkingManager implements IXmlReader {
 	}
 	
 	@Override
-	public final void load() {
+	public void load() {
 		parseDatapackFile("data/Routes.xml");
 		LOG.info("Loaded {} walking routes.", _routes.size());
 	}
@@ -411,7 +411,7 @@ public final class WalkingManager implements IXmlReader {
 		}
 	}
 	
-	public static final WalkingManager getInstance() {
+	public static WalkingManager getInstance() {
 		return SingletonHolder.INSTANCE;
 	}
 	

src/main/java/com/l2jserver/gameserver/instancemanager/ZoneManager.java

@@ -312,7 +312,7 @@ public final class ZoneManager implements IXmlReader {
 	}
 	
 	@Override
-	public final void load() {
+	public void load() {
 		_classZones.clear();
 		_spawnTerritories.clear();
 		parseDatapackDirectory("data/zones", false);
@@ -525,7 +525,7 @@ public final class ZoneManager implements IXmlReader {
 	 * @param character the character
 	 * @return the arena
 	 */
-	public final L2ArenaZone getArena(L2Character character) {
+	public L2ArenaZone getArena(L2Character character) {
 		if (character == null) {
 			return null;
 		}
@@ -544,7 +544,7 @@ public final class ZoneManager implements IXmlReader {
 	 * @param character the character
 	 * @return the olympiad stadium
 	 */
-	public final L2OlympiadStadiumZone getOlympiadStadium(L2Character character) {
+	public L2OlympiadStadiumZone getOlympiadStadium(L2Character character) {
 		if (character == null) {
 			return null;
 		}
@@ -616,7 +616,7 @@ public final class ZoneManager implements IXmlReader {
 		return _settings.get(name);
 	}
 	
-	public static final ZoneManager getInstance() {
+	public static ZoneManager getInstance() {
 		return SingletonHolder.INSTANCE;
 	}
 	

src/main/java/com/l2jserver/gameserver/model/AbsorberInfo.java

@@ -50,7 +50,7 @@ public final class AbsorberInfo implements IUniqueId {
 	}
 	
 	@Override
-	public final boolean equals(Object obj) {
+	public boolean equals(Object obj) {
 		if (this == obj) {
 			return true;
 		}
@@ -63,7 +63,7 @@ public final class AbsorberInfo implements IUniqueId {
 	}
 	
 	@Override
-	public final int hashCode() {
+	public int hashCode() {
 		return _objectId;
 	}
 }

src/main/java/com/l2jserver/gameserver/model/AggroInfo.java

@@ -65,7 +65,7 @@ public final class AggroInfo {
 	}
 	
 	@Override
-	public final boolean equals(Object obj) {
+	public boolean equals(Object obj) {
 		if (this == obj) {
 			return true;
 		}
@@ -78,7 +78,7 @@ public final class AggroInfo {
 	}
 	
 	@Override
-	public final int hashCode() {
+	public int hashCode() {
 		return _attacker.getObjectId();
 	}
 	

src/main/java/com/l2jserver/gameserver/model/CropProcure.java

@@ -29,7 +29,7 @@ public final class CropProcure extends SeedProduction {
 		_rewardType = type;
 	}
 	
-	public final int getReward() {
+	public int getReward() {
 		return _rewardType;
 	}
 }

src/main/java/com/l2jserver/gameserver/model/DamageDoneInfo.java

@@ -44,7 +44,7 @@ public final class DamageDoneInfo {
 	}
 	
 	@Override
-	public final boolean equals(Object obj) {
+	public boolean equals(Object obj) {
 		if (this == obj) {
 			return true;
 		}
@@ -57,7 +57,7 @@ public final class DamageDoneInfo {
 	}
 	
 	@Override
-	public final int hashCode() {
+	public int hashCode() {
 		return _attacker.getObjectId();
 	}
 }

src/main/java/com/l2jserver/gameserver/model/Elementals.java

@@ -82,7 +82,7 @@ public final class Elementals {
 		// TODO: Higher stones
 	};
 	
-	public static enum ElementalItemType {
+	public enum ElementalItemType {
 		Stone(3),
 		Roughore(3),
 		Crystal(6),
@@ -96,7 +96,7 @@ public final class Elementals {
 		}
 	}
 	
-	public static enum ElementalItems {
+	public enum ElementalItems {
 		fireStone(FIRE, 9546, ElementalItemType.Stone),
 		waterStone(WATER, 9547, ElementalItemType.Stone),
 		windStone(WIND, 9549, ElementalItemType.Stone),

src/main/java/com/l2jserver/gameserver/model/L2Seed.java

@@ -55,68 +55,68 @@ public final class L2Seed {
 		_seedReferencePrice = (item != null) ? item.getReferencePrice() : 1;
 	}
 	
-	public final int getCastleId() {
+	public int getCastleId() {
 		return _castleId;
 	}
 	
-	public final int getSeedId() {
+	public int getSeedId() {
 		return _seedId;
 	}
 	
-	public final int getCropId() {
+	public int getCropId() {
 		return _cropId;
 	}
 	
-	public final int getMatureId() {
+	public int getMatureId() {
 		return _matureId;
 	}
 	
-	public final int getReward(int type) {
+	public int getReward(int type) {
 		return (type == 1) ? _reward1 : _reward2;
 	}
 	
-	public final int getLevel() {
+	public int getLevel() {
 		return _level;
 	}
 	
-	public final boolean isAlternative() {
+	public boolean isAlternative() {
 		return _isAlternative;
 	}
 	
-	public final int getSeedLimit() {
+	public int getSeedLimit() {
 		return _limitSeeds * rates().getRateDropManor();
 	}
 	
-	public final int getCropLimit() {
+	public int getCropLimit() {
 		return _limitCrops * rates().getRateDropManor();
 	}
 	
-	public final int getSeedReferencePrice() {
+	public int getSeedReferencePrice() {
 		return _seedReferencePrice;
 	}
 	
-	public final int getSeedMaxPrice() {
+	public int getSeedMaxPrice() {
 		return _seedReferencePrice * 10;
 	}
 	
-	public final int getSeedMinPrice() {
+	public int getSeedMinPrice() {
 		return (int) (_seedReferencePrice * 0.6);
 	}
 	
-	public final int getCropReferencePrice() {
+	public int getCropReferencePrice() {
 		return _cropReferencePrice;
 	}
 	
-	public final int getCropMaxPrice() {
+	public int getCropMaxPrice() {
 		return _cropReferencePrice * 10;
 	}
 	
-	public final int getCropMinPrice() {
+	public int getCropMinPrice() {
 		return (int) (_cropReferencePrice * 0.6);
 	}
 	
 	@Override
-	public final String toString() {
+	public String toString() {
 		return "SeedData [_id=" + _seedId + ", _level=" + _level + ", _crop=" + _cropId + ", _mature=" + _matureId + ", _type1=" + _reward1 + ", _type2=" + _reward2 + //
 			", _manorId=" + _castleId + ", _isAlternative=" + _isAlternative + ", _limitSeeds=" + _limitSeeds + ", _limitCrops=" + _limitCrops + "]";
 	}

src/main/java/com/l2jserver/gameserver/model/SpawnListener.java

@@ -26,5 +26,5 @@ import com.l2jserver.gameserver.model.actor.L2Npc;
  */
 
 public interface SpawnListener {
-	public void npcSpawned(L2Npc npc);
+	void npcSpawned(L2Npc npc);
 }

src/main/java/com/l2jserver/gameserver/model/actor/instance/L2DoorInstance.java

@@ -106,7 +106,7 @@ public class L2DoorInstance extends L2Character {
 		
 		int clanhallId = template.getClanHallId();
 		if (clanhallId > 0) {
-			ClanHall hall = ClanHallManager.getAllClanHalls().get(clanhallId);
+			ClanHall hall = ClanHallManager.getInstance().getAllClanHalls().get(clanhallId);
 			if (hall != null) {
 				setClanHall(hall);
 				hall.getDoors().add(this);

src/main/java/com/l2jserver/gameserver/model/actor/instance/L2FestivalGuideInstance.java

@@ -160,7 +160,7 @@ public final class L2FestivalGuideInstance extends L2Npc {
 		}
 	}
 	
-	public final void showChatWindow(L2PcInstance player, int val, String suffix, boolean isDescription) {
+	public void showChatWindow(L2PcInstance player, int val, String suffix, boolean isDescription) {
 		String filename = SevenSigns.SEVEN_SIGNS_HTML_PATH + "festival/";
 		filename += (isDescription) ? "desc_" : "festival_";
 		filename += (suffix != null) ? val + suffix + ".htm" : val + ".htm";
@@ -196,7 +196,7 @@ public final class L2FestivalGuideInstance extends L2Npc {
 		player.sendPacket(ActionFailed.STATIC_PACKET);
 	}
 	
-	private static final String getStatsTable() {
+	private static String getStatsTable() {
 		final StringBuilder tableHtml = new StringBuilder(1000);
 		
 		// Get the scores for each of the festival level ranges (types).
@@ -218,7 +218,7 @@ public final class L2FestivalGuideInstance extends L2Npc {
 		return tableHtml.toString();
 	}
 	
-	private static final String getBonusTable() {
+	private static String getBonusTable() {
 		final StringBuilder tableHtml = new StringBuilder(500);
 		
 		// Get the accumulated scores for each of the festival level ranges (types).

src/main/java/com/l2jserver/gameserver/model/actor/instance/L2PcInstance.java

@@ -976,7 +976,7 @@ public final class L2PcInstance extends L2Playable {
 	}
 	
 	@Override
-	public final PcKnownList getKnownList() {
+	public PcKnownList getKnownList() {
 		return (PcKnownList) super.getKnownList();
 	}
 	
@@ -986,7 +986,7 @@ public final class L2PcInstance extends L2Playable {
 	}
 	
 	@Override
-	public final PcStat getStat() {
+	public PcStat getStat() {
 		return (PcStat) super.getStat();
 	}
 	
@@ -996,7 +996,7 @@ public final class L2PcInstance extends L2Playable {
 	}
 	
 	@Override
-	public final PcStatus getStatus() {
+	public PcStatus getStatus() {
 		return (PcStatus) super.getStatus();
 	}
 	
@@ -1005,14 +1005,14 @@ public final class L2PcInstance extends L2Playable {
 		setStatus(new PcStatus(this));
 	}
 	
-	public final PcAppearance getAppearance() {
+	public PcAppearance getAppearance() {
 		return _appearance;
 	}
 	
 	/**
 	 * @return the base L2PcTemplate link to the L2PcInstance.
 	 */
-	public final L2PcTemplate getBaseTemplate() {
+	public L2PcTemplate getBaseTemplate() {
 		return PlayerTemplateData.getInstance().getTemplate(_baseClass);
 	}
 	
@@ -1020,7 +1020,7 @@ public final class L2PcInstance extends L2Playable {
 	 * @return the L2PcTemplate link to the L2PcInstance.
 	 */
 	@Override
-	public final L2PcTemplate getTemplate() {
+	public L2PcTemplate getTemplate() {
 		return (L2PcTemplate) super.getTemplate();
 	}
 	
@@ -1038,7 +1038,7 @@ public final class L2PcInstance extends L2Playable {
 	
 	/** Return the Level of the L2PcInstance. */
 	@Override
-	public final int getLevel() {
+	public int getLevel() {
 		if (isSubClassActive()) {
 			return getSubClasses().get(getClassIndex()).getStat().getLevel();
 		}
@@ -1315,7 +1315,7 @@ public final class L2PcInstance extends L2Playable {
 	 * Gets the quest states registered for notify of death of this player.
 	 * @return the quest states
 	 */
-	public final Set<QuestState> getNotifyQuestOfDeath() {
+	public Set<QuestState> getNotifyQuestOfDeath() {
 		if (_notifyQuestOfDeathList == null) {
 			synchronized (this) {
 				if (_notifyQuestOfDeathList == null) {
@@ -1327,7 +1327,7 @@ public final class L2PcInstance extends L2Playable {
 		return _notifyQuestOfDeathList;
 	}
 	
-	public final boolean isNotifyQuestOfDeathEmpty() {
+	public boolean isNotifyQuestOfDeathEmpty() {
 		return (_notifyQuestOfDeathList == null) || _notifyQuestOfDeathList.isEmpty();
 	}
 	
@@ -2036,20 +2036,20 @@ public final class L2PcInstance extends L2Playable {
 		getSubStat().setLevel(Math.min(level, getMaxLevel()));
 	}
 	
-	public final int getMaxLevel() {
+	public int getMaxLevel() {
 		return getSubStat().getMaxLevel();
 	}
 	
-	public final int getMaxExpLevel() {
+	public int getMaxExpLevel() {
 		return getSubStat().getMaxExpLevel();
 	}
 	
-	private final PcStat getSubStat() {
+	private PcStat getSubStat() {
 		return isSubClassActive() ? getSubClasses().get(getClassIndex()).getStat() : getStat();
 	}
 	
 	@Override
-	public final boolean addLevel(int value) {
+	public boolean addLevel(int value) {
 		if ((getLevel() + value) > getMaxLevel()) {
 			return false;
 		}
@@ -3428,16 +3428,16 @@ public final class L2PcInstance extends L2Playable {
 		_recentFakeDeathEndTime = protect ? GameTimeController.getInstance().getGameTicks() + (character().getPlayerFakeDeathUpProtection() * GameTimeController.TICKS_PER_SECOND) : 0;
 	}
 	
-	public final boolean isFakeDeath() {
+	public boolean isFakeDeath() {
 		return _isFakeDeath;
 	}
 	
-	public final void setIsFakeDeath(boolean value) {
+	public void setIsFakeDeath(boolean value) {
 		_isFakeDeath = value;
 	}
 	
 	@Override
-	public final boolean isAlikeDead() {
+	public boolean isAlikeDead() {
 		return super.isAlikeDead() || isFakeDeath();
 	}
 	
@@ -3627,7 +3627,7 @@ public final class L2PcInstance extends L2Playable {
 	 * <li>Send a Server->Client packet CharInfo to all L2PcInstance in _KnownPlayers of the L2PcInstance (Public data only)</li> <FONT COLOR=#FF0000><B> <U>Caution</U> : DON'T SEND UserInfo packet to other players instead of CharInfo packet. Indeed, UserInfo packet contains PRIVATE DATA as MaxHP,
 	 * STR, DEX...</B></FONT>
 	 */
-	public final void broadcastUserInfo() {
+	public void broadcastUserInfo() {
 		// Send a Server->Client packet UserInfo to this L2PcInstance
 		sendPacket(new UserInfo(this));
 		
@@ -3639,7 +3639,7 @@ public final class L2PcInstance extends L2Playable {
 		}
 	}
 	
-	public final void broadcastTitleInfo() {
+	public void broadcastTitleInfo() {
 		// Send a Server->Client packet UserInfo to this L2PcInstance
 		sendPacket(new UserInfo(this));
 		sendPacket(new ExBrExtraUserInfo(this));
@@ -3650,7 +3650,7 @@ public final class L2PcInstance extends L2Playable {
 	}
 	
 	@Override
-	public final void broadcastPacket(L2GameServerPacket mov) {
+	public void broadcastPacket(L2GameServerPacket mov) {
 		if (!(mov instanceof CharInfo)) {
 			sendPacket(mov);
 		}
@@ -4029,11 +4029,11 @@ public final class L2PcInstance extends L2Playable {
 		}
 	}
 	
-	public final PreparedListContainer getMultiSell() {
+	public PreparedListContainer getMultiSell() {
 		return _currentMultiSell;
 	}
 	
-	public final void setMultiSell(PreparedListContainer list) {
+	public void setMultiSell(PreparedListContainer list) {
 		_currentMultiSell = list;
 	}
 	
@@ -4744,7 +4744,7 @@ public final class L2PcInstance extends L2Playable {
 	 * @param addToSp
 	 * @param useBonuses
 	 */
-	public final void addExpAndSpQuest(long addToExp, int addToSp) {
+	public void addExpAndSpQuest(long addToExp, int addToSp) {
 		if (addToExp != 0) {
 			getSubStat().addExp(addToExp);
 			SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.EARNED_S1_EXPERIENCE);
@@ -4762,7 +4762,7 @@ public final class L2PcInstance extends L2Playable {
 		sendPacket(new ExBrExtraUserInfo(this));
 	}
 	
-	public final void removeExpAndSp(long removeFromExp, int removeFromSp) {
+	public void removeExpAndSp(long removeFromExp, int removeFromSp) {
 		getSubStat().removeExp(removeFromExp);
 		getSubStat().removeSp(removeFromSp);
 		
@@ -4770,7 +4770,7 @@ public final class L2PcInstance extends L2Playable {
 		sendPacket(new ExBrExtraUserInfo(this));
 	}
 	
-	public final void addExpAndSp(long addToExp, int addToSp, boolean useBonuses) {
+	public void addExpAndSp(long addToExp, int addToSp, boolean useBonuses) {
 		// Allowed to gain exp?
 		if (!getAccessLevel().canGainExp()) {
 			return;
@@ -4825,7 +4825,7 @@ public final class L2PcInstance extends L2Playable {
 		sendPacket(new ExBrExtraUserInfo(this));
 	}
 	
-	public final void removeExp(long exp) {
+	public void removeExp(long exp) {
 		changeKarma(exp);
 		getSubStat().removeExp(exp);
 		
@@ -4845,7 +4845,7 @@ public final class L2PcInstance extends L2Playable {
 		}
 	}
 	
-	public final boolean removeSp(int sp) {
+	public boolean removeSp(int sp) {
 		return getSubStat().removeSp(sp);
 	}
 	
@@ -6912,23 +6912,23 @@ public final class L2PcInstance extends L2Playable {
 	}
 	
 	@Override
-	public final void stopAllEffects() {
+	public void stopAllEffects() {
 		super.stopAllEffects();
 		updateAndBroadcastStatus(2);
 	}
 	
 	@Override
-	public final void stopAllEffectsExceptThoseThatLastThroughDeath() {
+	public void stopAllEffectsExceptThoseThatLastThroughDeath() {
 		super.stopAllEffectsExceptThoseThatLastThroughDeath();
 		updateAndBroadcastStatus(2);
 	}
 	
-	public final void stopAllEffectsNotStayOnSubclassChange() {
+	public void stopAllEffectsNotStayOnSubclassChange() {
 		getEffectList().stopAllEffectsNotStayOnSubclassChange();
 		updateAndBroadcastStatus(2);
 	}
 	
-	public final void stopCubics() {
+	public void stopCubics() {
 		if (!_cubics.isEmpty()) {
 			for (L2CubicInstance cubic : _cubics.values()) {
 				cubic.stopAction();
@@ -6939,7 +6939,7 @@ public final class L2PcInstance extends L2Playable {
 		}
 	}
 	
-	public final void stopCubicsByOthers() {
+	public void stopCubicsByOthers() {
 		if (!_cubics.isEmpty()) {
 			boolean broadcast = false;
 			for (L2CubicInstance cubic : _cubics.values()) {
@@ -8213,7 +8213,7 @@ public final class L2PcInstance extends L2Playable {
 	}
 	
 	@Override
-	public final void onTeleported() {
+	public void onTeleported() {
 		super.onTeleported();
 		
 		if (isInAirShip()) {
@@ -9552,7 +9552,7 @@ public final class L2PcInstance extends L2Playable {
 	}
 	
 	@Override
-	public final void sendDamageMessage(L2Character target, int damage, boolean mcrit, boolean pcrit, boolean miss) {
+	public void sendDamageMessage(L2Character target, int damage, boolean mcrit, boolean pcrit, boolean miss) {
 		// Check if hit is missed
 		if (miss) {
 			if (target.isPlayer()) {
@@ -9720,7 +9720,7 @@ public final class L2PcInstance extends L2Playable {
 		}
 	}
 	
-	private final L2PetLevelData getPetLevelData(int npcId) {
+	private L2PetLevelData getPetLevelData(int npcId) {
 		if (_leveldata == null) {
 			_leveldata = PetDataTable.getInstance().getPetData(npcId).getPetLevelData(getMountLevel());
 		}
@@ -10253,35 +10253,35 @@ public final class L2PcInstance extends L2Playable {
 		return getAppearance().getSex() ? getBaseTemplate().getFCollisionHeightFemale() : getBaseTemplate().getfCollisionHeight();
 	}
 	
-	public final int getClientX() {
+	public int getClientX() {
 		return _clientX;
 	}
 	
-	public final void setClientX(int val) {
+	public void setClientX(int val) {
 		_clientX = val;
 	}
 	
-	public final int getClientY() {
+	public int getClientY() {
 		return _clientY;
 	}
 	
-	public final void setClientY(int val) {
+	public void setClientY(int val) {
 		_clientY = val;
 	}
 	
-	public final int getClientZ() {
+	public int getClientZ() {
 		return _clientZ;
 	}
 	
-	public final void setClientZ(int val) {
+	public void setClientZ(int val) {
 		_clientZ = val;
 	}
 	
-	public final int getClientHeading() {
+	public int getClientHeading() {
 		return _clientHeading;
 	}
 	
-	public final void setClientHeading(int val) {
+	public void setClientHeading(int val) {
 		_clientHeading = val;
 	}
 	
@@ -10289,7 +10289,7 @@ public final class L2PcInstance extends L2Playable {
 	 * @param z
 	 * @return true if character falling now on the start of fall return false for correct coord sync!
 	 */
-	public final boolean isFalling(int z) {
+	public boolean isFalling(int z) {
 		if (isDead() || isFlying() || isFlyingMounted() || isInsideZone(ZoneId.WATER)) {
 			return false;
 		}
@@ -10324,7 +10324,7 @@ public final class L2PcInstance extends L2Playable {
 	/**
 	 * Set falling timestamp
 	 */
-	public final void setFalling() {
+	public void setFalling() {
 		_fallingTimestamp = System.currentTimeMillis() + FALLING_VALIDATION_DELAY;
 	}
 	
@@ -10687,7 +10687,7 @@ public final class L2PcInstance extends L2Playable {
 	 * @param skillId the display skill Id
 	 * @return the custom skill
 	 */
-	public final Skill getCustomSkill(int skillId) {
+	public Skill getCustomSkill(int skillId) {
 		return (_customSkills != null) ? _customSkills.get(skillId) : null;
 	}
 	
@@ -10695,7 +10695,7 @@ public final class L2PcInstance extends L2Playable {
 	 * Add a skill level to the custom skills map.
 	 * @param skill the skill to add
 	 */
-	private final void addCustomSkill(Skill skill) {
+	private void addCustomSkill(Skill skill) {
 		if ((skill != null) && (skill.getDisplayId() != skill.getId())) {
 			if (_customSkills == null) {
 				_customSkills = new ConcurrentHashMap<>();
@@ -10708,7 +10708,7 @@ public final class L2PcInstance extends L2Playable {
 	 * Remove a skill level from the custom skill map.
 	 * @param skill the skill to remove
 	 */
-	private final void removeCustomSkill(Skill skill) {
+	private void removeCustomSkill(Skill skill) {
 		if ((skill != null) && (_customSkills != null) && (skill.getDisplayId() != skill.getId())) {
 			_customSkills.remove(skill.getDisplayId());
 		}
@@ -10977,7 +10977,7 @@ public final class L2PcInstance extends L2Playable {
 		_servitorShare = map;
 	}
 	
-	public final double getServitorShareBonus(Stats stat) {
+	public double getServitorShareBonus(Stats stat) {
 		if (_servitorShare == null) {
 			return 1.0d;
 		}

src/main/java/com/l2jserver/gameserver/model/actor/instance/L2StaticObjectInstance.java

@@ -71,7 +71,7 @@ public final class L2StaticObjectInstance extends L2Character {
 	}
 	
 	@Override
-	public final StaticObjectKnownList getKnownList() {
+	public StaticObjectKnownList getKnownList() {
 		return (StaticObjectKnownList) super.getKnownList();
 	}
 	
@@ -81,7 +81,7 @@ public final class L2StaticObjectInstance extends L2Character {
 	}
 	
 	@Override
-	public final StaticObjStat getStat() {
+	public StaticObjStat getStat() {
 		return (StaticObjStat) super.getStat();
 	}
 	
@@ -91,7 +91,7 @@ public final class L2StaticObjectInstance extends L2Character {
 	}
 	
 	@Override
-	public final StaticObjStatus getStatus() {
+	public StaticObjStatus getStatus() {
 		return (StaticObjStatus) super.getStatus();
 	}
 	
@@ -117,7 +117,7 @@ public final class L2StaticObjectInstance extends L2Character {
 	}
 	
 	@Override
-	public final int getLevel() {
+	public int getLevel() {
 		return 1;
 	}
 	

src/main/java/com/l2jserver/gameserver/model/actor/instance/L2VillageMasterDElfInstance.java

@@ -32,7 +32,7 @@ public final class L2VillageMasterDElfInstance extends L2VillageMasterInstance {
 	}
 	
 	@Override
-	protected final boolean checkVillageMasterRace(PlayerClass pclass) {
+	protected boolean checkVillageMasterRace(PlayerClass pclass) {
 		if (pclass == null) {
 			return false;
 		}

src/main/java/com/l2jserver/gameserver/model/actor/instance/L2VillageMasterDwarfInstance.java

@@ -32,7 +32,7 @@ public final class L2VillageMasterDwarfInstance extends L2VillageMasterInstance
 	}
 	
 	@Override
-	protected final boolean checkVillageMasterRace(PlayerClass pclass) {
+	protected boolean checkVillageMasterRace(PlayerClass pclass) {
 		if (pclass == null) {
 			return false;
 		}

src/main/java/com/l2jserver/gameserver/model/actor/instance/L2VillageMasterFighterInstance.java

@@ -33,7 +33,7 @@ public final class L2VillageMasterFighterInstance extends L2VillageMasterInstanc
 	}
 	
 	@Override
-	protected final boolean checkVillageMasterRace(PlayerClass pclass) {
+	protected boolean checkVillageMasterRace(PlayerClass pclass) {
 		if (pclass == null) {
 			return false;
 		}
@@ -42,7 +42,7 @@ public final class L2VillageMasterFighterInstance extends L2VillageMasterInstanc
 	}
 	
 	@Override
-	protected final boolean checkVillageMasterTeachType(PlayerClass pclass) {
+	protected boolean checkVillageMasterTeachType(PlayerClass pclass) {
 		if (pclass == null) {
 			return false;
 		}

src/main/java/com/l2jserver/gameserver/model/actor/instance/L2VillageMasterKamaelInstance.java

@@ -34,7 +34,7 @@ public final class L2VillageMasterKamaelInstance extends L2VillageMasterInstance
 	}
 	
 	@Override
-	protected final String getSubClassMenu(Race race) {
+	protected String getSubClassMenu(Race race) {
 		if (character().subclassEverywhere() || (race == Race.KAMAEL)) {
 			return "data/html/villagemaster/SubClass.htm";
 		}
@@ -43,17 +43,17 @@ public final class L2VillageMasterKamaelInstance extends L2VillageMasterInstance
 	}
 	
 	@Override
-	protected final String getSubClassFail() {
+	protected String getSubClassFail() {
 		return "data/html/villagemaster/SubClass_Fail_Kamael.htm";
 	}
 	
 	@Override
-	protected final boolean checkQuests(L2PcInstance player) {
+	protected boolean checkQuests(L2PcInstance player) {
 		return player.isNoble() || player.hasQuestCompleted("Q00234_FatesWhisper") || player.hasQuestCompleted("Q00236_SeedsOfChaos");
 	}
 	
 	@Override
-	protected final boolean checkVillageMasterRace(PlayerClass pclass) {
+	protected boolean checkVillageMasterRace(PlayerClass pclass) {
 		if (pclass == null) {
 			return false;
 		}

src/main/java/com/l2jserver/gameserver/model/actor/instance/L2VillageMasterMysticInstance.java

@@ -33,7 +33,7 @@ public final class L2VillageMasterMysticInstance extends L2VillageMasterInstance
 	}
 	
 	@Override
-	protected final boolean checkVillageMasterRace(PlayerClass pclass) {
+	protected boolean checkVillageMasterRace(PlayerClass pclass) {
 		if (pclass == null) {
 			return false;
 		}
@@ -42,7 +42,7 @@ public final class L2VillageMasterMysticInstance extends L2VillageMasterInstance
 	}
 	
 	@Override
-	protected final boolean checkVillageMasterTeachType(PlayerClass pclass) {
+	protected boolean checkVillageMasterTeachType(PlayerClass pclass) {
 		if (pclass == null) {
 			return false;
 		}

src/main/java/com/l2jserver/gameserver/model/actor/instance/L2VillageMasterOrcInstance.java

@@ -32,7 +32,7 @@ public final class L2VillageMasterOrcInstance extends L2VillageMasterInstance {
 	}
 	
 	@Override
-	protected final boolean checkVillageMasterRace(PlayerClass pclass) {
+	protected boolean checkVillageMasterRace(PlayerClass pclass) {
 		if (pclass == null) {
 			return false;
 		}

src/main/java/com/l2jserver/gameserver/model/actor/instance/L2VillageMasterPriestInstance.java

@@ -33,7 +33,7 @@ public final class L2VillageMasterPriestInstance extends L2VillageMasterInstance
 	}
 	
 	@Override
-	protected final boolean checkVillageMasterRace(PlayerClass pclass) {
+	protected boolean checkVillageMasterRace(PlayerClass pclass) {
 		if (pclass == null) {
 			return false;
 		}
@@ -42,7 +42,7 @@ public final class L2VillageMasterPriestInstance extends L2VillageMasterInstance
 	}
 	
 	@Override
-	protected final boolean checkVillageMasterTeachType(PlayerClass pclass) {
+	protected boolean checkVillageMasterTeachType(PlayerClass pclass) {
 		if (pclass == null) {
 			return false;
 		}

src/main/java/com/l2jserver/gameserver/model/announce/IAnnouncement.java

@@ -26,19 +26,19 @@ import com.l2jserver.gameserver.model.interfaces.IUpdatable;
  * @author UnAfraid
  */
 public interface IAnnouncement extends IStorable, IUpdatable, IDeletable {
-	public int getId();
+	int getId();
 	
-	public AnnouncementType getType();
+	AnnouncementType getType();
 	
-	public void setType(AnnouncementType type);
+	void setType(AnnouncementType type);
 	
-	public boolean isValid();
+	boolean isValid();
 	
-	public String getContent();
+	String getContent();
 	
-	public void setContent(String content);
+	void setContent(String content);
 	
-	public String getAuthor();
+	String getAuthor();
 	
-	public void setAuthor(String author);
+	void setAuthor(String author);
 }

src/main/java/com/l2jserver/gameserver/model/clientstrings/BuilderContainer.java

@@ -29,7 +29,7 @@ final class BuilderContainer extends Builder {
 	}
 	
 	@Override
-	public final String toString(final Object param) {
+	public String toString(final Object param) {
 		return toString(new Object[] {
 			param
 		});
@@ -68,7 +68,7 @@ final class BuilderContainer extends Builder {
 	}
 	
 	@Override
-	public final int getIndex() {
+	public int getIndex() {
 		return -1;
 	}
 }

src/main/java/com/l2jserver/gameserver/model/clientstrings/BuilderObject.java

@@ -32,7 +32,7 @@ final class BuilderObject extends Builder {
 	}
 	
 	@Override
-	public final String toString(final Object param) {
+	public String toString(final Object param) {
 		return param == null ? "null" : param.toString();
 	}
 	
@@ -45,12 +45,12 @@ final class BuilderObject extends Builder {
 	}
 	
 	@Override
-	public final int getIndex() {
+	public int getIndex() {
 		return _index;
 	}
 	
 	@Override
-	public final String toString() {
+	public String toString() {
 		return "[PARAM-" + (_index + 1) + "]";
 	}
 }

src/main/java/com/l2jserver/gameserver/model/clientstrings/BuilderText.java

@@ -29,7 +29,7 @@ final class BuilderText extends Builder {
 	}
 	
 	@Override
-	public final String toString(final Object param) {
+	public String toString(final Object param) {
 		return toString();
 	}
 	
@@ -39,12 +39,12 @@ final class BuilderText extends Builder {
 	}
 	
 	@Override
-	public final int getIndex() {
+	public int getIndex() {
 		return -1;
 	}
 	
 	@Override
-	public final String toString() {
+	public String toString() {
 		return _text;
 	}
 }

src/main/java/com/l2jserver/gameserver/model/clientstrings/FastStringBuilder.java

@@ -29,13 +29,13 @@ final class FastStringBuilder {
 		_array = new char[capacity];
 	}
 	
-	public final void append(final String text) {
+	public void append(final String text) {
 		text.getChars(0, text.length(), _array, _len);
 		_len += text.length();
 	}
 	
 	@Override
-	public final String toString() {
+	public String toString() {
 		return new String(_array);
 	}
 }

src/main/java/com/l2jserver/gameserver/model/conditions/ConditionListener.java

@@ -30,5 +30,5 @@ public interface ConditionListener {
 	/**
 	 * Notify changed.
 	 */
-	public void notifyChanged();
+	void notifyChanged();
 }

src/main/java/com/l2jserver/gameserver/model/drops/GeneralDropItem.java

@@ -82,35 +82,35 @@ public final class GeneralDropItem implements IDropItem {
 	/**
 	 * @return the _amountStrategy
 	 */
-	public final IAmountMultiplierStrategy getAmountStrategy() {
+	public IAmountMultiplierStrategy getAmountStrategy() {
 		return _amountStrategy;
 	}
 	
 	/**
 	 * @return the _chanceStrategy
 	 */
-	public final IChanceMultiplierStrategy getChanceStrategy() {
+	public IChanceMultiplierStrategy getChanceStrategy() {
 		return _chanceStrategy;
 	}
 	
 	/**
 	 * @return the _preciseStrategy
 	 */
-	public final IPreciseDeterminationStrategy getPreciseStrategy() {
+	public IPreciseDeterminationStrategy getPreciseStrategy() {
 		return _preciseStrategy;
 	}
 	
 	/**
 	 * @return the _killerStrategy
 	 */
-	public final INonGroupedKillerChanceModifierStrategy getKillerChanceModifierStrategy() {
+	public INonGroupedKillerChanceModifierStrategy getKillerChanceModifierStrategy() {
 		return _killerStrategy;
 	}
 	
 	/**
 	 * @return the _dropCalculationStrategy
 	 */
-	public final IDropCalculationStrategy getDropCalculationStrategy() {
+	public IDropCalculationStrategy getDropCalculationStrategy() {
 		return _dropCalculationStrategy;
 	}
 	
@@ -118,7 +118,7 @@ public final class GeneralDropItem implements IDropItem {
 	 * Gets the item id
 	 * @return the item id
 	 */
-	public final int getItemId() {
+	public int getItemId() {
 		return _itemId;
 	}
 	
@@ -126,7 +126,7 @@ public final class GeneralDropItem implements IDropItem {
 	 * Gets the base min drop count
 	 * @return the min
 	 */
-	public final long getMin() {
+	public long getMin() {
 		return _min;
 	}
 	
@@ -135,7 +135,7 @@ public final class GeneralDropItem implements IDropItem {
 	 * @param victim the victim who drops the item
 	 * @return the min modified by any rates.
 	 */
-	public final long getMin(L2Character victim) {
+	public long getMin(L2Character victim) {
 		return (long) (getMin() * getAmountMultiplier(victim));
 	}
 	
@@ -143,7 +143,7 @@ public final class GeneralDropItem implements IDropItem {
 	 * Gets the base max drop count
 	 * @return the max
 	 */
-	public final long getMax() {
+	public long getMax() {
 		return _max;
 	}
 	
@@ -152,7 +152,7 @@ public final class GeneralDropItem implements IDropItem {
 	 * @param victim the victim who drops the item
 	 * @return the max modified by any rates.
 	 */
-	public final long getMax(L2Character victim) {
+	public long getMax(L2Character victim) {
 		return (long) (getMax() * getAmountMultiplier(victim));
 	}
 	
@@ -160,7 +160,7 @@ public final class GeneralDropItem implements IDropItem {
 	 * Gets the chance of this drop item.
 	 * @return the chance
 	 */
-	public final double getChance() {
+	public double getChance() {
 		return _chance;
 	}
 	
@@ -170,7 +170,7 @@ public final class GeneralDropItem implements IDropItem {
 	 * @param victim the victim who drops the item
 	 * @return the chance modified by any rates.
 	 */
-	public final double getChance(L2Character victim) {
+	public double getChance(L2Character victim) {
 		return getChance() * getChanceMultiplier(victim);
 	}
 	
@@ -181,19 +181,19 @@ public final class GeneralDropItem implements IDropItem {
 	 * @param killer who kills the victim
 	 * @return a chance to drop modified by deep blue drop rules
 	 */
-	public final double getChance(L2Character victim, L2Character killer) {
+	public double getChance(L2Character victim, L2Character killer) {
 		return (getKillerChanceModifier(victim, killer) * getChance(victim));
 	}
 	
 	@Override
-	public final List<ItemHolder> calculateDrops(L2Character victim, L2Character killer) {
+	public List<ItemHolder> calculateDrops(L2Character victim, L2Character killer) {
 		return _dropCalculationStrategy.calculateDrops(this, victim, killer);
 	}
 	
 	/**
 	 * @return <code>true</code> if chance over 100% should be handled
 	 */
-	public final boolean isPreciseCalculated() {
+	public boolean isPreciseCalculated() {
 		return _preciseStrategy.isPreciseCalculated(this);
 	}
 	
@@ -203,7 +203,7 @@ public final class GeneralDropItem implements IDropItem {
 	 * @param killer who kills the victim
 	 * @return a number between 0 and 1 (usually)
 	 */
-	protected final double getKillerChanceModifier(L2Character victim, L2Character killer) {
+	protected double getKillerChanceModifier(L2Character victim, L2Character killer) {
 		return _killerStrategy.getKillerChanceModifier(this, victim, killer);
 	}
 	
@@ -212,7 +212,7 @@ public final class GeneralDropItem implements IDropItem {
 	 * @param victim who drops the item
 	 * @return
 	 */
-	protected final double getAmountMultiplier(L2Character victim) {
+	protected double getAmountMultiplier(L2Character victim) {
 		return _amountStrategy.getAmountMultiplier(this, victim);
 	}
 	
@@ -221,7 +221,7 @@ public final class GeneralDropItem implements IDropItem {
 	 * @param victim who drops the item
 	 * @return
 	 */
-	protected final double getChanceMultiplier(L2Character victim) {
+	protected double getChanceMultiplier(L2Character victim) {
 		return _chanceStrategy.getChanceMultiplier(this, victim);
 	}
 }

src/main/java/com/l2jserver/gameserver/model/drops/GroupedGeneralDropItem.java

@@ -67,7 +67,7 @@ public final class GroupedGeneralDropItem implements IDropItem {
 	 * Gets the chance of this drop item.
 	 * @return the chance
 	 */
-	public final double getChance() {
+	public double getChance() {
 		return _chance;
 	}
 	
@@ -75,14 +75,14 @@ public final class GroupedGeneralDropItem implements IDropItem {
 	 * Gets the items.
 	 * @return the items
 	 */
-	public final List<GeneralDropItem> getItems() {
+	public List<GeneralDropItem> getItems() {
 		return _items;
 	}
 	
 	/**
 	 * @return the strategy
 	 */
-	public final IGroupedItemDropCalculationStrategy getDropCalculationStrategy() {
+	public IGroupedItemDropCalculationStrategy getDropCalculationStrategy() {
 		return _dropCalculationStrategy;
 	}
 	
@@ -96,7 +96,7 @@ public final class GroupedGeneralDropItem implements IDropItem {
 	/**
 	 * @return the _preciseStrategy
 	 */
-	public final IPreciseDeterminationStrategy getPreciseStrategy() {
+	public IPreciseDeterminationStrategy getPreciseStrategy() {
 		return _preciseStrategy;
 	}
 	
@@ -104,7 +104,7 @@ public final class GroupedGeneralDropItem implements IDropItem {
 	 * Sets an item list to this drop item.
 	 * @param items the item list
 	 */
-	public final void setItems(List<GeneralDropItem> items) {
+	public void setItems(List<GeneralDropItem> items) {
 		_items = Collections.unmodifiableList(items);
 	}
 	
@@ -112,7 +112,7 @@ public final class GroupedGeneralDropItem implements IDropItem {
 	 * Returns a list of items in the group with chance multiplied by chance of the group
 	 * @return the list of items with modified chances
 	 */
-	public final List<GeneralDropItem> extractMe() {
+	public List<GeneralDropItem> extractMe() {
 		List<GeneralDropItem> items = new ArrayList<>();
 		for (final GeneralDropItem item : getItems()) {
 			// precise and killer strategies of the group
@@ -125,7 +125,7 @@ public final class GroupedGeneralDropItem implements IDropItem {
 	 * statically normalizes a group, useful when need to convert legacy SQL data
 	 * @return a new group with items, which have a sum of getChance() of 100%
 	 */
-	public final GroupedGeneralDropItem normalizeMe() {
+	public GroupedGeneralDropItem normalizeMe() {
 		double sumchance = 0;
 		for (GeneralDropItem item : getItems()) {
 			sumchance += (item.getChance() * getChance()) / 100;
@@ -147,7 +147,7 @@ public final class GroupedGeneralDropItem implements IDropItem {
 	 * @param killer
 	 * @return a new normalized group with all drop modifiers applied
 	 */
-	public final GroupedGeneralDropItem normalizeMe(L2Character victim, L2Character killer) {
+	public GroupedGeneralDropItem normalizeMe(L2Character victim, L2Character killer) {
 		return normalizeMe(victim, killer, true, 1);
 	}
 	
@@ -158,7 +158,7 @@ public final class GroupedGeneralDropItem implements IDropItem {
 	 * @param chanceModifier an additional chance modifier
 	 * @return a new normalized group with all drop modifiers applied
 	 */
-	public final GroupedGeneralDropItem normalizeMe(L2Character victim, L2Character killer, double chanceModifier) {
+	public GroupedGeneralDropItem normalizeMe(L2Character victim, L2Character killer, double chanceModifier) {
 		return normalizeMe(victim, killer, true, chanceModifier);
 	}
 	
@@ -167,7 +167,7 @@ public final class GroupedGeneralDropItem implements IDropItem {
 	 * @param victim
 	 * @return a new normalized group with all victim modifiers applied
 	 */
-	public final GroupedGeneralDropItem normalizeMe(L2Character victim) {
+	public GroupedGeneralDropItem normalizeMe(L2Character victim) {
 		return normalizeMe(victim, null, false, 1);
 	}
 	
@@ -177,7 +177,7 @@ public final class GroupedGeneralDropItem implements IDropItem {
 	 * @param chanceModifier an additional chance modifier
 	 * @return a new normalized group with all victim modifiers applied
 	 */
-	public final GroupedGeneralDropItem normalizeMe(L2Character victim, double chanceModifier) {
+	public GroupedGeneralDropItem normalizeMe(L2Character victim, double chanceModifier) {
 		return normalizeMe(victim, null, false, chanceModifier);
 	}
 	
@@ -189,7 +189,7 @@ public final class GroupedGeneralDropItem implements IDropItem {
 	 * @param chanceModifier an additional chance modifier
 	 * @return a new normalized group with all drop modifiers applied
 	 */
-	private final GroupedGeneralDropItem normalizeMe(L2Character victim, L2Character killer, boolean applyKillerModifier, double chanceModifier) {
+	private GroupedGeneralDropItem normalizeMe(L2Character victim, L2Character killer, boolean applyKillerModifier, double chanceModifier) {
 		if (applyKillerModifier) {
 			chanceModifier *= (getKillerChanceModifier(victim, killer));
 		}
@@ -214,7 +214,7 @@ public final class GroupedGeneralDropItem implements IDropItem {
 	}
 	
 	@Override
-	public final List<ItemHolder> calculateDrops(L2Character victim, L2Character killer) {
+	public List<ItemHolder> calculateDrops(L2Character victim, L2Character killer) {
 		return _dropCalculationStrategy.calculateDrops(this, victim, killer);
 	}
 	
@@ -224,7 +224,7 @@ public final class GroupedGeneralDropItem implements IDropItem {
 	 * @param killer who kills the victim
 	 * @return a number between 0 and 1 (usually)
 	 */
-	public final double getKillerChanceModifier(L2Character victim, L2Character killer) {
+	public double getKillerChanceModifier(L2Character victim, L2Character killer) {
 		return _killerChanceModifierStrategy.getKillerChanceModifier(this, victim, killer);
 	}
 	

src/main/java/com/l2jserver/gameserver/model/drops/IDropItem.java

@@ -34,5 +34,5 @@ public interface IDropItem {
 	 * @param killer the killer
 	 * @return {@code null} or empty collection if there are no drops, a collection containing all items to drop otherwise
 	 */
-	public List<ItemHolder> calculateDrops(L2Character victim, L2Character killer);
+	List<ItemHolder> calculateDrops(L2Character victim, L2Character killer);
 }

src/main/java/com/l2jserver/gameserver/model/drops/IDropItemFactory.java

@@ -29,5 +29,5 @@ public interface IDropItemFactory {
 	 * @param chance the chance of this drop item
 	 * @return the drop item created by this factory
 	 */
-	public IDropItem newDropItem(int itemId, long min, long max, double chance);
+	IDropItem newDropItem(int itemId, long min, long max, double chance);
 }

src/main/java/com/l2jserver/gameserver/model/drops/IGroupedDropItemFactory.java

@@ -22,5 +22,5 @@ package com.l2jserver.gameserver.model.drops;
  * @author Battlecruiser
  */
 public interface IGroupedDropItemFactory {
-	public GroupedGeneralDropItem newGroupedDropItem(double chance);
+	GroupedGeneralDropItem newGroupedDropItem(double chance);
 }

src/main/java/com/l2jserver/gameserver/model/drops/strategy/IAmountMultiplierStrategy.java

@@ -30,11 +30,11 @@ import com.l2jserver.gameserver.model.itemcontainer.Inventory;
  * @author Battlecruiser
  */
 public interface IAmountMultiplierStrategy {
-	public static final IAmountMultiplierStrategy DROP = DEFAULT_STRATEGY(rates().getDeathDropAmountMultiplier());
-	public static final IAmountMultiplierStrategy SPOIL = DEFAULT_STRATEGY(rates().getCorpseDropAmountMultiplier());
-	public static final IAmountMultiplierStrategy STATIC = (item, victim) -> 1;
+	IAmountMultiplierStrategy DROP = DEFAULT_STRATEGY(rates().getDeathDropAmountMultiplier());
+	IAmountMultiplierStrategy SPOIL = DEFAULT_STRATEGY(rates().getCorpseDropAmountMultiplier());
+	IAmountMultiplierStrategy STATIC = (item, victim) -> 1;
 	
-	public static IAmountMultiplierStrategy DEFAULT_STRATEGY(final double defaultMultiplier) {
+	static IAmountMultiplierStrategy DEFAULT_STRATEGY(final double defaultMultiplier) {
 		return (item, victim) -> {
 			double multiplier = 1;
 			if (victim.isChampion()) {
@@ -55,5 +55,5 @@ public interface IAmountMultiplierStrategy {
 		};
 	}
 	
-	public double getAmountMultiplier(GeneralDropItem item, L2Character victim);
+	double getAmountMultiplier(GeneralDropItem item, L2Character victim);
 }

src/main/java/com/l2jserver/gameserver/model/drops/strategy/IChanceMultiplierStrategy.java

@@ -30,11 +30,11 @@ import com.l2jserver.gameserver.model.itemcontainer.Inventory;
  * @author Battlecruiser
  */
 public interface IChanceMultiplierStrategy {
-	public static final IChanceMultiplierStrategy DROP = DEFAULT_STRATEGY(rates().getDeathDropChanceMultiplier());
-	public static final IChanceMultiplierStrategy SPOIL = DEFAULT_STRATEGY(rates().getCorpseDropChanceMultiplier());
-	public static final IChanceMultiplierStrategy STATIC = (item, victim) -> 1;
+	IChanceMultiplierStrategy DROP = DEFAULT_STRATEGY(rates().getDeathDropChanceMultiplier());
+	IChanceMultiplierStrategy SPOIL = DEFAULT_STRATEGY(rates().getCorpseDropChanceMultiplier());
+	IChanceMultiplierStrategy STATIC = (item, victim) -> 1;
 	
-	public static final IChanceMultiplierStrategy QUEST = (item, victim) -> {
+	IChanceMultiplierStrategy QUEST = (item, victim) -> {
 		double championmult;
 		if ((item.getItemId() == Inventory.ADENA_ID) || (item.getItemId() == Inventory.ANCIENT_ADENA_ID)) {
 			championmult = customs().getChampionAdenasRewardsChance();
@@ -45,7 +45,7 @@ public interface IChanceMultiplierStrategy {
 		return (customs().championEnable() && (victim != null) && victim.isChampion()) ? (rates().getRateQuestDrop() * championmult) : rates().getRateQuestDrop();
 	};
 	
-	public static IChanceMultiplierStrategy DEFAULT_STRATEGY(final double defaultMultiplier) {
+	static IChanceMultiplierStrategy DEFAULT_STRATEGY(final double defaultMultiplier) {
 		return (item, victim) -> {
 			float multiplier = 1;
 			if (victim.isChampion()) {
@@ -65,5 +65,5 @@ public interface IChanceMultiplierStrategy {
 		};
 	}
 	
-	public double getChanceMultiplier(GeneralDropItem item, L2Character victim);
+	double getChanceMultiplier(GeneralDropItem item, L2Character victim);
 }

src/main/java/com/l2jserver/gameserver/model/drops/strategy/IDropCalculationStrategy.java

@@ -30,7 +30,7 @@ import com.l2jserver.gameserver.model.holders.ItemHolder;
  * @author Battlecruiser
  */
 public interface IDropCalculationStrategy {
-	public static final IDropCalculationStrategy DEFAULT_STRATEGY = (item, victim, killer) -> {
+	IDropCalculationStrategy DEFAULT_STRATEGY = (item, victim, killer) -> {
 		double chance = item.getChance(victim, killer);
 		if (chance > (Rnd.nextDouble() * 100)) {
 			int amountMultiply = 1;
@@ -47,5 +47,5 @@ public interface IDropCalculationStrategy {
 		return null;
 	};
 	
-	public List<ItemHolder> calculateDrops(GeneralDropItem item, L2Character victim, L2Character killer);
+	List<ItemHolder> calculateDrops(GeneralDropItem item, L2Character victim, L2Character killer);
 }

src/main/java/com/l2jserver/gameserver/model/drops/strategy/IGroupedItemDropCalculationStrategy.java

@@ -38,7 +38,7 @@ public interface IGroupedItemDropCalculationStrategy {
 	/**
 	 * The default strategy used in L2J to calculate drops. When the group's chance raises over 100% and group has precise calculation, the dropped item's amount increases.
 	 */
-	public static final IGroupedItemDropCalculationStrategy DEFAULT_STRATEGY = new IGroupedItemDropCalculationStrategy() {
+	IGroupedItemDropCalculationStrategy DEFAULT_STRATEGY = new IGroupedItemDropCalculationStrategy() {
 		private final Map<GroupedGeneralDropItem, GeneralDropItem> singleItemCache = new ConcurrentHashMap<>();
 		
 		private GeneralDropItem getSingleItem(GroupedGeneralDropItem dropItem) {
@@ -81,7 +81,7 @@ public interface IGroupedItemDropCalculationStrategy {
 	/**
 	 * This strategy calculates a group's drop by calculating drops of its individual items and merging its results.
 	 */
-	public static final IGroupedItemDropCalculationStrategy DISBAND_GROUP = (item, victim, killer) -> {
+	IGroupedItemDropCalculationStrategy DISBAND_GROUP = (item, victim, killer) -> {
 		List<ItemHolder> dropped = new ArrayList<>();
 		for (IDropItem dropItem : item.extractMe()) {
 			dropped.addAll(dropItem.calculateDrops(victim, killer));
@@ -92,7 +92,7 @@ public interface IGroupedItemDropCalculationStrategy {
 	/**
 	 * This strategy when group has precise calculation rolls multiple times over group to determine drops when group's chance raises over 100% instead of just multiplying the dropped item's amount. Thus it can produce different items from group at once.
 	 */
-	public static final IGroupedItemDropCalculationStrategy PRECISE_MULTIPLE_GROUP_ROLLS = (item, victim, killer) -> {
+	IGroupedItemDropCalculationStrategy PRECISE_MULTIPLE_GROUP_ROLLS = (item, victim, killer) -> {
 		if (!item.isPreciseCalculated()) {
 			// if item hasn't precise calculation there's no change from DEFAULT_STRATEGY
 			return DEFAULT_STRATEGY.calculateDrops(item, victim, victim);
@@ -113,5 +113,5 @@ public interface IGroupedItemDropCalculationStrategy {
 		return dropped.isEmpty() ? null : dropped;
 	};
 	
-	public List<ItemHolder> calculateDrops(GroupedGeneralDropItem item, L2Character victim, L2Character killer);
+	List<ItemHolder> calculateDrops(GroupedGeneralDropItem item, L2Character victim, L2Character killer);
 }

src/main/java/com/l2jserver/gameserver/model/drops/strategy/IKillerChanceModifierStrategy.java

@@ -30,7 +30,7 @@ import com.l2jserver.gameserver.util.Util;
  * @author Battlecruiser
  */
 public interface IKillerChanceModifierStrategy extends INonGroupedKillerChanceModifierStrategy {
-	public static final IKillerChanceModifierStrategy DEFAULT_STRATEGY = (item, victim, killer) -> {
+	IKillerChanceModifierStrategy DEFAULT_STRATEGY = (item, victim, killer) -> {
 		int levelDifference = victim.getLevel() - killer.getLevel();
 		if ((victim.isRaid()) && npc().useDeepBlueDropRulesRaid()) {
 			// FIXME: Config?
@@ -41,7 +41,7 @@ public interface IKillerChanceModifierStrategy extends INonGroupedKillerChanceMo
 		}
 		return 1;
 	};
-	public static final INonGroupedKillerChanceModifierStrategy DEFAULT_NONGROUP_STRATEGY = (item, victim, killer) -> {
+	INonGroupedKillerChanceModifierStrategy DEFAULT_NONGROUP_STRATEGY = (item, victim, killer) -> {
 		if (((!(victim.isRaid())) && npc().useDeepBlueDropRules()) || ((victim.isRaid()) && npc().useDeepBlueDropRulesRaid())) {
 			int levelDifference = victim.getLevel() - killer.getLevel();
 			if (item.getItemId() == Inventory.ADENA_ID) {
@@ -54,10 +54,10 @@ public interface IKillerChanceModifierStrategy extends INonGroupedKillerChanceMo
 	
 	IKillerChanceModifierStrategy NO_RULES = (item, victim, killer) -> 1;
 	
-	public double getKillerChanceModifier(IDropItem item, L2Character victim, L2Character killer);
+	double getKillerChanceModifier(IDropItem item, L2Character victim, L2Character killer);
 	
 	@Override
-	public default double getKillerChanceModifier(GeneralDropItem item, L2Character victim, L2Character killer) {
+	default double getKillerChanceModifier(GeneralDropItem item, L2Character victim, L2Character killer) {
 		return getKillerChanceModifier((IDropItem) item, victim, killer);
 	}
 }

src/main/java/com/l2jserver/gameserver/model/drops/strategy/INonGroupedKillerChanceModifierStrategy.java

@@ -25,5 +25,5 @@ import com.l2jserver.gameserver.model.drops.GeneralDropItem;
  * @author Battlecruiser
  */
 public interface INonGroupedKillerChanceModifierStrategy {
-	public double getKillerChanceModifier(GeneralDropItem item, L2Character victim, L2Character killer);
+	double getKillerChanceModifier(GeneralDropItem item, L2Character victim, L2Character killer);
 }

src/main/java/com/l2jserver/gameserver/model/drops/strategy/IPreciseDeterminationStrategy.java

@@ -26,15 +26,15 @@ import com.l2jserver.gameserver.model.drops.IDropItem;
  * @author Battlecruiser
  */
 public interface IPreciseDeterminationStrategy {
-	public static final IPreciseDeterminationStrategy ALWAYS = dropItem -> true;
+	IPreciseDeterminationStrategy ALWAYS = dropItem -> true;
 	
-	public static final IPreciseDeterminationStrategy DEFAULT = dropItem -> general().preciseDropCalculation();
+	IPreciseDeterminationStrategy DEFAULT = dropItem -> general().preciseDropCalculation();
 	
-	public static final IPreciseDeterminationStrategy NEVER = dropItem -> false;
+	IPreciseDeterminationStrategy NEVER = dropItem -> false;
 	
 	/**
 	 * @param dropItem
 	 * @return <code>true</code> if drop calculation strategy should use precise rules
 	 */
-	public boolean isPreciseCalculated(IDropItem dropItem);
+	boolean isPreciseCalculated(IDropItem dropItem);
 }

src/main/java/com/l2jserver/gameserver/model/entity/Castle.java

@@ -709,7 +709,7 @@ public final class Castle extends AbstractResidence {
 		}
 	}
 	
-	public final L2DoorInstance getDoor(int doorId) {
+	public L2DoorInstance getDoor(int doorId) {
 		if (doorId <= 0) {
 			return null;
 		}
@@ -722,26 +722,26 @@ public final class Castle extends AbstractResidence {
 		return null;
 	}
 	
-	public final List<L2DoorInstance> getDoors() {
+	public List<L2DoorInstance> getDoors() {
 		return _doors;
 	}
 	
-	public final int getOwnerId() {
+	public int getOwnerId() {
 		return _ownerId;
 	}
 	
-	public final L2Clan getOwner() {
+	public L2Clan getOwner() {
 		return (_ownerId != 0) ? ClanTable.getInstance().getClan(_ownerId) : null;
 	}
 	
-	public final Siege getSiege() {
+	public Siege getSiege() {
 		if (_siege == null) {
 			_siege = new Siege(this);
 		}
 		return _siege;
 	}
 	
-	public final Calendar getSiegeDate() {
+	public Calendar getSiegeDate() {
 		return _siegeDate;
 	}
 	
@@ -760,23 +760,23 @@ public final class Castle extends AbstractResidence {
 		return _siegeTimeRegistrationEndDate;
 	}
 	
-	public final int getTaxPercent() {
+	public int getTaxPercent() {
 		return _taxPercent;
 	}
 	
-	public final double getTaxRate() {
+	public double getTaxRate() {
 		return _taxRate;
 	}
 	
-	public final long getTreasury() {
+	public long getTreasury() {
 		return _treasury;
 	}
 	
-	public final boolean getShowNpcCrest() {
+	public boolean getShowNpcCrest() {
 		return _showNpcCrest;
 	}
 	
-	public final void setShowNpcCrest(boolean showNpcCrest) {
+	public void setShowNpcCrest(boolean showNpcCrest) {
 		if (_showNpcCrest != showNpcCrest) {
 			_showNpcCrest = showNpcCrest;
 			updateShowNpcCrest();

src/main/java/com/l2jserver/gameserver/model/entity/Fort.java

@@ -703,16 +703,16 @@ public final class Fort extends AbstractResidence {
 		}
 	}
 	
-	public final L2Clan getOwnerClan() {
+	public L2Clan getOwnerClan() {
 		return _fortOwner;
 	}
 	
-	public final void setOwnerClan(L2Clan clan) {
+	public void setOwnerClan(L2Clan clan) {
 		setVisibleFlag(clan != null);
 		_fortOwner = clan;
 	}
 	
-	public final L2DoorInstance getDoor(int doorId) {
+	public L2DoorInstance getDoor(int doorId) {
 		if (doorId <= 0) {
 			return null;
 		}
@@ -725,15 +725,15 @@ public final class Fort extends AbstractResidence {
 		return null;
 	}
 	
-	public final List<L2DoorInstance> getDoors() {
+	public List<L2DoorInstance> getDoors() {
 		return _doors;
 	}
 	
-	public final L2StaticObjectInstance getFlagPole() {
+	public L2StaticObjectInstance getFlagPole() {
 		return _flagPole;
 	}
 	
-	public final FortSiege getSiege() {
+	public FortSiege getSiege() {
 		if (_siege == null) {
 			synchronized (this) {
 				if (_siege == null) {
@@ -744,15 +744,15 @@ public final class Fort extends AbstractResidence {
 		return _siege;
 	}
 	
-	public final Calendar getSiegeDate() {
+	public Calendar getSiegeDate() {
 		return _siegeDate;
 	}
 	
-	public final void setSiegeDate(Calendar siegeDate) {
+	public void setSiegeDate(Calendar siegeDate) {
 		_siegeDate = siegeDate;
 	}
 	
-	public final int getOwnedTime() {
+	public int getOwnedTime() {
 		if (_lastOwnedTime.getTimeInMillis() == 0) {
 			return 0;
 		}
@@ -760,7 +760,7 @@ public final class Fort extends AbstractResidence {
 		return (int) ((System.currentTimeMillis() - _lastOwnedTime.getTimeInMillis()) / 1000);
 	}
 	
-	public final int getTimeTillRebelArmy() {
+	public int getTimeTillRebelArmy() {
 		if (_lastOwnedTime.getTimeInMillis() == 0) {
 			return 0;
 		}
@@ -768,7 +768,7 @@ public final class Fort extends AbstractResidence {
 		return (int) (((_lastOwnedTime.getTimeInMillis() + (fortress().getMaxKeepTime() * 3600000L)) - System.currentTimeMillis()) / 1000L);
 	}
 	
-	public final long getTimeTillNextFortUpdate() {
+	public long getTimeTillNextFortUpdate() {
 		if (_FortUpdater[0] == null) {
 			return 0;
 		}
@@ -812,7 +812,7 @@ public final class Fort extends AbstractResidence {
 	 *         1 - independent<BR>
 	 *         2 - contracted with castle<BR>
 	 */
-	public final int getFortState() {
+	public int getFortState() {
 		return _state;
 	}
 	
@@ -825,7 +825,7 @@ public final class Fort extends AbstractResidence {
 	 *            </ul>
 	 * @param castleId the Id of the contracted castle (0 if no contract with any castle)
 	 */
-	public final void setFortState(int state, int castleId) {
+	public void setFortState(int state, int castleId) {
 		_state = state;
 		_castleId = castleId;
 		try (var con = ConnectionFactory.getInstance().getConnection();
@@ -842,7 +842,7 @@ public final class Fort extends AbstractResidence {
 	/**
 	 * @return the fortress type (0 - small (3 commanders), 1 - big (4 commanders + control room))
 	 */
-	public final int getFortType() {
+	public int getFortType() {
 		return _fortType;
 	}
 	
@@ -850,7 +850,7 @@ public final class Fort extends AbstractResidence {
 	 * @param npcId the Id of the ambassador NPC
 	 * @return the Id of the castle this ambassador represents
 	 */
-	public final int getCastleIdByAmbassador(int npcId) {
+	public int getCastleIdByAmbassador(int npcId) {
 		return _envoyCastles.get(npcId);
 	}
 	
@@ -858,21 +858,21 @@ public final class Fort extends AbstractResidence {
 	 * @param npcId the Id of the ambassador NPC
 	 * @return the castle this ambassador represents
 	 */
-	public final Castle getCastleByAmbassador(int npcId) {
+	public Castle getCastleByAmbassador(int npcId) {
 		return CastleManager.getInstance().getCastleById(getCastleIdByAmbassador(npcId));
 	}
 	
 	/**
 	 * @return the Id of the castle contracted with this fortress
 	 */
-	public final int getContractedCastleId() {
+	public int getContractedCastleId() {
 		return _castleId;
 	}
 	
 	/**
 	 * @return the castle contracted with this fortress ({@code null} if no contract with any castle)
 	 */
-	public final Castle getContractedCastle() {
+	public Castle getContractedCastle() {
 		return CastleManager.getInstance().getCastleById(getContractedCastleId());
 	}
 	
@@ -880,14 +880,14 @@ public final class Fort extends AbstractResidence {
 	 * Check if this is a border fortress (associated with multiple castles).
 	 * @return {@code true} if this is a border fortress (associated with more than one castle), {@code false} otherwise
 	 */
-	public final boolean isBorderFortress() {
+	public boolean isBorderFortress() {
 		return _availableCastles.size() > 1;
 	}
 	
 	/**
 	 * @return the amount of barracks in this fortress
 	 */
-	public final int getFortSize() {
+	public int getFortSize() {
 		return getFortType() == 0 ? 3 : 5;
 	}
 	

src/main/java/com/l2jserver/gameserver/model/entity/Instance.java

@@ -757,7 +757,7 @@ public final class Instance {
 	 * @param killer the character that killed the {@code victim}
 	 * @param victim the character that was killed by the {@code killer}
 	 */
-	public final void notifyDeath(L2Character killer, L2Character victim) {
+	public void notifyDeath(L2Character killer, L2Character victim) {
 		final InstanceWorld instance = InstanceManager.getInstance().getPlayerWorld(victim.getActingPlayer());
 		if (instance != null) {
 			instance.onDeath(killer, victim);

src/main/java/com/l2jserver/gameserver/model/entity/Siegable.java

@@ -30,37 +30,37 @@ import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
  * @author JIV
  */
 public interface Siegable {
-	public void startSiege();
+	void startSiege();
 	
-	public void endSiege();
+	void endSiege();
 	
-	public L2SiegeClan getAttackerClan(int clanId);
+	L2SiegeClan getAttackerClan(int clanId);
 	
-	public L2SiegeClan getAttackerClan(L2Clan clan);
+	L2SiegeClan getAttackerClan(L2Clan clan);
 	
-	public List<L2SiegeClan> getAttackerClans();
+	List<L2SiegeClan> getAttackerClans();
 	
-	public List<L2PcInstance> getAttackersInZone();
+	List<L2PcInstance> getAttackersInZone();
 	
-	public boolean checkIsAttacker(L2Clan clan);
+	boolean checkIsAttacker(L2Clan clan);
 	
-	public L2SiegeClan getDefenderClan(int clanId);
+	L2SiegeClan getDefenderClan(int clanId);
 	
-	public L2SiegeClan getDefenderClan(L2Clan clan);
+	L2SiegeClan getDefenderClan(L2Clan clan);
 	
-	public List<L2SiegeClan> getDefenderClans();
+	List<L2SiegeClan> getDefenderClans();
 	
-	public boolean checkIsDefender(L2Clan clan);
+	boolean checkIsDefender(L2Clan clan);
 	
-	public List<L2Npc> getFlag(L2Clan clan);
+	List<L2Npc> getFlag(L2Clan clan);
 	
-	public Calendar getSiegeDate();
+	Calendar getSiegeDate();
 	
-	public boolean giveFame();
+	boolean giveFame();
 	
-	public int getFameFrequency();
+	int getFameFrequency();
 	
-	public int getFameAmount();
+	int getFameAmount();
 	
-	public void updateSiege();
+	void updateSiege();
 }

src/main/java/com/l2jserver/gameserver/model/entity/clanhall/AuctionableHall.java

@@ -62,37 +62,37 @@ public final class AuctionableHall extends ClanHall {
 	/**
 	 * @return if clanHall is paid or not
 	 */
-	public final boolean getPaid() {
+	public boolean getPaid() {
 		return _paid;
 	}
 	
 	/** Return lease */
 	@Override
-	public final int getLease() {
+	public int getLease() {
 		return _lease;
 	}
 	
 	/** Return PaidUntil */
 	@Override
-	public final long getPaidUntil() {
+	public long getPaidUntil() {
 		return _paidUntil;
 	}
 	
 	/** Return Grade */
 	@Override
-	public final int getGrade() {
+	public int getGrade() {
 		return _grade;
 	}
 	
 	@Override
-	public final void free() {
+	public void free() {
 		super.free();
 		_paidUntil = 0;
 		_paid = false;
 	}
 	
 	@Override
-	public final void setOwner(L2Clan clan) {
+	public void setOwner(L2Clan clan) {
 		super.setOwner(clan);
 		_paidUntil = System.currentTimeMillis();
 		initialyzeTask(true);
@@ -102,7 +102,7 @@ public final class AuctionableHall extends ClanHall {
 	 * Initialize Fee Task
 	 * @param forced
 	 */
-	private final void initialyzeTask(boolean forced) {
+	private void initialyzeTask(boolean forced) {
 		long currentTime = System.currentTimeMillis();
 		if (_paidUntil > currentTime) {
 			ThreadPoolManager.getInstance().scheduleGeneral(new FeeTask(), _paidUntil - currentTime);
@@ -178,7 +178,7 @@ public final class AuctionableHall extends ClanHall {
 	}
 	
 	@Override
-	public final void updateDb() {
+	public void updateDb() {
 		try (var con = ConnectionFactory.getInstance().getConnection();
 			var ps = con.prepareStatement("UPDATE clanhall SET ownerId=?, paidUntil=?, paid=? WHERE id=?")) {
 			ps.setInt(1, getOwnerId());