java语言知识模块

finalize() 方法

Java 允许定义这样的方法，它在对象被垃圾收集器析构(回收)之前调用，这个方法叫做 finalize( )，它用来清除回收对象。

例如，你可以使用 finalize() 来确保一个对象打开的文件被关闭了。

在 finalize() 方法里，你必须指定在对象销毁时候要执行的操作。

finalize() 一般格式是：

protectedvoidfinalize(){ // 在这里终结代码}

关于

Java 中的两种排序方式：

Comparable 自然排序。（实体类实现）
Comparator 是定制排序。（无法修改实体类时，直接在调用方创建）

Comparable 自然排序

Comparable 在 java.lang 包下，是一个接口，内部只有一个方法 compareTo()：

1

2

3

      public interface Comparable<T> { 
     

          public int compareTo(T o);
     

}

Comparable 可以让实现它的类的对象进行比较，具体的比较规则是按照 compareTo 方法中的规则进行。这种顺序称为自然顺序。

compareTo 方法的返回值有三种情况：

e1.compareTo(e2) > 0 即 e1 > e2
e1.compareTo(e2) = 0 即 e1 = e2
e1.compareTo(e2) < 0 即 e1 < e2

使用：

class Book implements  Comparable{
  private String name;
    private int count;
    public BookBean(String name, int count) {
        this.name = name;
        this.count = count;
    }
  @Override
    public int compareTo(Object another) {
        if (another instanceof BookBean){
            BookBean anotherBook = (BookBean) another;
            int result;
            //比如这里按照书价排序
            result = getCount() - anotherBook.getCount();     
          //或者按照 String 的比较顺序
          //result = getName().compareTo(anotherBook.getName());
            if (result == 0){   //当书价一致时，再对比书名。 保证所有属性比较一遍
                result = getName().compareTo(anotherBook.getName());
            }
            return result;
        }
        // 一样就返回 0
        return 0;
}

Comparator 定制排序

Comparator 在 java.util 包下，也是一个接口，JDK 1.8 以前只有两个方法：

public interface Comparator {

public int compare(T lhs, T rhs);  
public boolean equals(Object object);

}

Comparator 则是在外部制定排序规则，然后作为排序策略参数传递给某些类，比如 Collections.sort(), Arrays.sort(), 或者一些内部有序的集合（比如 SortedSet，SortedMap 等）。

使用方式主要分三步：

创建一个 Comparator 接口的实现类，并赋值给一个对象在 compare 方法中针对自定义类写排序规则
将 Comparator 对象作为参数传递给排序类的某个方法
向排序类中添加 compare 方法中使用的自定义类

// 1.创建一个实现 Comparator 接口的对象
Comparator comparator = new Comparator() {
    @Override
    public int compare(Object object1, Object object2) {
        if (object1 instanceof NewBookBean && object2 instanceof NewBookBean){
            NewBookBean newBookBean = (NewBookBean) object1;
            NewBookBean newBookBean1 = (NewBookBean) object2;
            //具体比较方法参照 自然排序的 compareTo 方法，这里只举个栗子
            return newBookBean.getCount() - newBookBean1.getCount();
        }
        return 0;
    }
};
//2.将此对象作为形参传递给 TreeSet 的构造器中
TreeSet treeSet = new TreeSet(comparator);
//3.向 TreeSet 中添加 步骤 1 中 compare 方法中设计的类的对象
treeSet.add(new NewBookBean("A",34));
treeSet.add(new NewBookBean("S",1));
treeSet.add( new NewBookBean("V",46));
treeSet.add( new NewBookBean("Q",26));

算法模块：

算法之大O表示法：

o表示order（大约） n代表函数输入规模。表示函数执行步骤数量和输入规模之间的关系。

本表示法只关注影响函数性能最大的因素，略过其他所有因素。

编程规范模块

模块化设计特征

函数和子程序的规模应该尽量小
函数的意图要尽量具体单一
函数重用场合要多
函数命名要规范，使用意图非常明显
函数对外部代码环境应该没有（负面）影响
函数的执行过程不依赖所处系统状态

SOLID原则

单一职责原则（Single Responsibility Principle）
开放闭合原则（Open/Closed Principle）
里氏替换原则（Liskov Substitution Principle）、
接口分离原则（Interface Segregation Principle）
依赖倒置原则（Dependency Inversion Principle）

单一职责原则：

类应该只有一个职责，并且有且仅有一个（或一类）改变的原因。

开放闭合原则：

类（函数）对扩展是开放的，对修改是封闭的。基类代码被修改的时候所有子类的行为都会受到影响。添加新行为的时候应该创建新的派生类不要修改基类。

里氏替换原则：

如果C类继承自P类，那么对于接受P类型的参数的函数而言，C P 两种类型应该是可以替换的。

注意：如果子类不能完整地实现父类的方法，或者父类的一些方法在子类中已经发生畸变，则建议断开继承关系，采用依赖，聚集，组合等关系代替继承。

自我理解：尽量少用继承，改成实现接口。如果有继承，尽量不要重写父类中已有的方法。或者说，最好的情况是，基类是无法被实例化的。子类可以扩展父类的功能，但不能改变父类原有的功能。

接口分离原则：

避免富余接口，不要让类承担过多不必要的职责。应该创建一些独立的，规模小的接口。

依赖倒置原则：

应该依赖抽象而不应该依赖具体。尽量多写实现抽象类和接口的代码，少写实现具体类的代码。

使用：依赖注入

class B{
}
class A{
  public void Do(){
    B b = new B();//现在A依赖B
  }
}

A的依赖对象应该从具体转向抽象：

interface IB{
  //...
}
class B1 implements IB{
  //...
}
class B2 implements IB{
  //...
}
class A{
  public void Do(IB b){
    //b 可以是B1 或者B2
  }
}

还有一大设计原则

迪米特原则：

迪米特原则(Law of Demeter,LoD)，也叫最少知识原则(Low knowledge Principle,LKP):

一个对象应该对其他对象有最少的了解。

通俗的讲：一个类对自己需要耦合或调用的类知道的最少，你(被耦合或调用的类)的内部是如何复杂和我没有关系，我就知道你提供的public方法，我只调用这些方法，其它的我不关心。

一个类公开的public方法和属性越多，修改时涉及的面也就越大，变更引起的风险扩散也就越大。因此，为了保持朋友类间的距离，在设计时需要反复衡量：是否还可以再减少public方法和属性，是否可以修改为private,package-private,protected等访问权限，是否可以加上final关键字。

迪米特原则的核心观念就是类间解耦，弱耦合，只有弱耦合后，类的复用率才可以提高。其结果就是产生了大量的中转或跳转类，导致系统复杂，为维护带来了难度。所以，我们在实践时要反复权衡，即要让结构清晰，又做到高内聚低耦合。