java语言知识模块
finalize() 方法
Java 允许定义这样的方法,它在对象被垃圾收集器析构(回收)之前调用,这个方法叫做 finalize( ),它用来清除回收对象。
例如,你可以使用 finalize() 来确保一个对象打开的文件被关闭了。
在 finalize() 方法里,你必须指定在对象销毁时候要执行的操作。
finalize() 一般格式是:
关于
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<T> {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关键字。迪米特原则的核心观念就是类间解耦,弱耦合,只有弱耦合后,类的复用率才可以提高。其结果就是产生了大量的中转或跳转类,导致系统复杂,为维护带来了难度。所以,我们在实践时要反复权衡,即要让结构清晰,又做到高内聚低耦合。