抽象类和抽象方法的初步理解和使用

抽象类和接口，在实际的开发中应用很多。对于新手来说，平时接触的接口多实现和抽象类的多继承常常是系统中已经具备的，所做的工作以舔砖加瓦，简单来说就是别人搭架子，你来砌墙。从头到尾自己来定义接口/抽象类、写各种实现类或者子类的机会显得弥足珍贵。

本文不讨论接口和抽象类的异同，直接就上次研究synchronize()锁写的代码进行实践，虽然情境很简单，但是思想表达到位足矣：抽出不同业务需求子类的共同实现在父类中实现，子类则根据自己的业务需求重写父类中的抽象方法

后面还准备写一篇实践接口的多实现的文章，丰富一下。可以预料，像我这种对抽出共有方法有执念（见文章《代码模块化和可读性的tradeoff》）的人，以后会大量的应用抽象类和接口。。。

好了言归正传，直接上代码吧，上次用到的加线程锁的两种方式：synchronize关键字以及ReentrantLock锁的lock方法，因为先写了synchronize方法，一些逻辑和实现都在这个类里面

public class TrySimpleLock {

public static void main(String[] args) {
final TrySimpleLock simpleLock = new TrySimpleLock();
final TrySimpleLock simpleLockSecond = new TrySimpleLock();

new Thread(() -> simpleLock.f()).start();
simpleLock.g();
new Thread(() -> simpleLockSecond.h()).start();
}

public void f() {
combinedPr
c569
int();
}

public void g() {
combinedPrint();
}

public void h() {
combinedPrint();
}

public void loop() {
for (int i = 0; i < 3; i++) {
print(true);
getSlower();
}
}

private void synchronizedLoop() {
synchronized (this) {
loop();
}
}

public void print(boolean flag) {
String result;
int threadOrder = 3;
if (flag) {
result = ": Positive in ";
threadOrder += 2;
} else {
result = ": Negative in ";
}
JoePrint.print(Thread.currentThread().getName() + result + Thread.currentThread().getStackTrace()[threadOrder].getMethodName() + "()");
}

private void combinedPrint() {
print(false);
synchronizedLoop();
print(false);
}

private void getSlower() {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

然后嫌麻烦，用ReentrantLock的类就大量引用上面类中的方法：

public class TryReentrantLock {
private Lock lock = new ReentrantLock();
private TrySimpleLock simpleLock = new TrySimpleLock();

public static void main(String[] args) {
TryReentrantLock reentrantLock = new TryReentrantLock();
new Thread(() -> reentrantLock.f()).start();
reentrantLock.g();
new Thread(() -> reentrantLock.h()).start();
}

public void f() {
combinedPrint();
}

public void g() {
combinedPrint();
}

public void h() {
combinedPrint();
}

private void combinedPrint() {
simpleLock.print(false);
synchronizedLoop();
simpleLock.print(false);
}

private void synchronizedLoop() {
lock.lock();
try {
simpleLock.loop();
} finally {
lock.unlock();
}
}

}

这样也不是不可以，但是总觉得，如果使用抽象类把他们梳理起来，也是极好的

于是进行了尝试，抽象类如下：

public abstract class AbstractTryLock {

protected void f() {
combinedPrint();
}

protected void g() {
combinedPrint();
}

protected void h() {
combinedPrint();
}

protected void loop() {
for (int i = 0; i < 3; i++) {
print(true);
getSlower();
}
}

protected abstract void synchronizedLoop();

protected void print(boolean flag) {
String result;
int threadOrder = 3;
if (flag) {
result = ": Positive in ";
threadOrder += 2;
} else {
result = ": Negative in ";
}
JoePrint.print(Thread.currentThread().getName() + result + Thread.currentThread().getStackTrace()[threadOrder].getMethodName() + "()");
}

protected void combinedPrint() {
print(false);
synchronizedLoop();
print(false);
}

protected void getSlower() {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

被瘦身之后的子类

public class TrySimpleLock extends AbstractTryLock {

public static void main(String[] args) {
final TrySimpleLock simpleLock = new TrySimpleLock();
final TrySimpleLock simpleLockSecond = new TrySimpleLock();

new Thread(() -> simpleLock.f()).start();
simpleLock.g();
new Thread(() -> simpleLockSecond.h()).start();
}

@Override
protected void synchronizedLoop() {
synchronized (this) {
loop();
}
}
}

public class TryReentrantLock extends AbstractTryLock {
private Lock lock = new ReentrantLock();

public static void main(String[] args) {
TryReentrantLock reentrantLock = new TryReentrantLock();
new Thread(() -> reentrantLock.f()).start();
reentrantLock.g();
new Thread(() -> reentrantLock.h()).start();
}

@Override
protected void synchronizedLoop() {
lock.lock();
try {
loop();
} finally {
lock.unlock();
}
}

}