Java final关键字与抽象类深度解析
二、final关键字
各位同学，接下来我们学习一个在面向对象编程中偶尔会用到的一个关键字叫final，也是为后面学习抽象类和接口做准备的。
2.1 final修饰符的特点(面试题)
我们先来认识一下final的特点，final关键字是最终的意思，可以修饰类、修饰方法、修饰变量。
- final修饰类：该类称为最终类，特点是不能被继承 - final修饰方法：该方法称之为最终方法，特点是不能被重写。 - final修饰变量：该变量只能被赋值一次。
接下来我们分别演示一下，先看final修饰类的特点
public class Test1 { // 目标: final的作用 } // final修饰类：该类称为最终类，特点是不能被继承 // 应用场景: 比如工具类, 只需要使用静态方法, 不需要被继承 final class A{} class B extends A{} // 此时就会报错再来演示一下final修饰方法的特点
public class Test1 { // 目标: final的作用 } // 2、final修饰方法：该方法称之为最终方法，特点是不能被重写。 class C{ public final void test(){ } } class D extends C{ @Override public void test() { // 此时会报错 } }再演示一下final修饰变量的特点
情况一
情况二
情况三
2.2 补充知识：常量
刚刚我们学习了final修饰符的特点，在实际运用当中经常使用final来定义常量。先说一下什么是Java中的常量？
被 static final 修饰的成员变量，称之为常量。
通常用于记录系统的配置信息
接下来我们用代码来演示一下
public class Constant { //常量: 定义一个常量表示学校名称 //为了方便在其他类中被访问所以一般还会加上public修饰符 //常量命名规范：建议都采用大写字母命名，多个单词之前有_隔开 public static final String SCHOOL_NAME = "胜雅教育"; }public class FinalDemo2 { public static void main(String[] args) { //由于常量是static的，所以在使用时直接用类名就可以调用 System.out.println(Constant.SCHOOL_NAME); System.out.println(Constant.SCHOOL_NAME); System.out.println(Constant.SCHOOL_NAME); System.out.println(Constant.SCHOOL_NAME); System.out.println(Constant.SCHOOL_NAME); System.out.println(Constant.SCHOOL_NAME); System.out.println(Constant.SCHOOL_NAME); } }关于常量的原理，同学们也可以了解一下：在程序编译后，常量会“宏替换”，出现常量的地方，全都会被替换为其记住的字面量，这样可以保证使用常量和直接用字面量的性能是一样的。把代码反编译后，其实代码是下面的样子
public class FinalDemo2 { public static void main(String[] args) { // 编译时会直接将SCHOOL_NAME转成胜雅教育, 不存在根据名称找值的问题, 所以性能是一样的 System.out.println("胜雅教育"); System.out.println("胜雅教育"); System.out.println("胜雅教育"); System.out.println("胜雅教育"); System.out.println("胜雅教育"); System.out.println("胜雅教育"); System.out.println("胜雅教育"); } }三、抽象类
同学们，接下来我们学习Java中一种特殊的类，叫抽象类。为了让同学们掌握抽象类，会先让同学们认识一下什么是抽象类以及抽象类的特点，再学习一个抽象类的常见应用场景。
3.1 认识抽象类
我们先来认识一下什么是抽象类，以及抽象类有什么特点。
在Java中有一个关键字叫abstract，它就是抽象的意思，它可以修饰类也可以修饰方法。
- 被abstract修饰的类，就是抽象类 - 被abstract修饰的方法，就是抽象方法（不允许有方法体）
接下来用代码来演示一下抽象类和抽象方法
//abstract修饰类，这个类就是抽象类 public abstract class A{ //abstract修饰方法，这个方法就是抽象方法 public abstract void test(); }抽象类的注意事项、特点(面试题) 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类。 类该有的成员（成员变量、方法、构造器）抽象类都可以有。 抽象类最主要的特点：抽象类不能创建对象，仅作为一种特殊的父类，让子类继承并实现。 一个类继承抽象类，必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。
类的成员（成员变量、成员方法、构造器），类的成员都可以有。如下面代码
// 抽象类 public abstract class A { //成员变量 private String name; static String schoolName; //构造方法 public A(){ } //抽象方法 public abstract void test(); //实例方法 public String getName() { return name; } public void setName(String name) { this.name = name; } }抽象类是不能创建对象的，如果创建抽象类的对象就会报错
抽象类虽然不能创建对象，但是它可以作为父类让子类继承。而且子类继承父类必须重写父类的所有抽象方法。
//B类继承A类，必须复写test方法 public class B extends A { @Override public void test() { } }子类继承父类如果不复写父类的抽象方法，要想不出错，这个子类也必须是抽象类
//B类基础A类，此时B类也是抽象类，这个时候就可以不重写A类的抽象方法 public abstract class B extends A { }3.2 抽象类的好处
接下来我们用一个案例来说一下抽象类的应用场景和好处。
好处: 多个类中只要有重复代码（包括相同的方法签名），我们都应该抽取到父类中去，此时，父类中就有可能存在只有方法签名的方法，这时，父类必定是一个抽象类了，我们抽出这样的抽象类，就是为了更好的支持多态。
分析需求发现，该案例中猫和狗都有名字这个属性，也都有叫这个行为，所以我们可以将共性的内容抽取成一个父类，Animal类，但是由于猫和狗叫的声音不一样，于是我们在Animal类中将叫的行为写成抽象的。代码如下
public abstract class Animal { private String name; //动物叫的行为：不具体，是抽象的 public abstract void cry(); public String getName() { return name; } public void setName(String name) { this.name = name; } }接着写一个Animal的子类，Dog类。代码如下
public class Dog extends Animal{ public void cry(){ System.out.println(getName() + "汪汪汪的叫~~"); } }然后，再写一个Animal的子类，Cat类。代码如下
public class Cat extends Animal{ public void cry(){ System.out.println(getName() + "喵喵喵的叫~~"); } }最后，再写一个测试类，Test类。
public class Test2 { public static void main(String[] args) { // 目标：掌握抽象类的使用场景和好处. Animal a = new Dog(); a.cry(); //这时执行的是Dog类的cry方法 } }再学一招，假设现在系统有需要加一个Pig类，也有叫的行为，这时候也很容易原有功能扩展。只需要让Pig类继承Animal，复写cry方法就行。
public class Pig extends Animal{ @Override public void cry() { System.out.println(getName() + "嚯嚯嚯~~~"); } }此时，创建对象时，让Animal接收Pig，就可以执行Pig的cry方法
public class Test2 { public static void main(String[] args) { // 目标：掌握抽象类的使用场景和好处. Animal a = new Pig(); a.cry(); //这时执行的是Pig类的cry方法 } }综上所述，我们总结一下抽象类的使用场景和好处
1.用抽象类可以把父类中相同的代码，包括方法声明都抽取到父类，这样能更好的支持多态，一提高代码的灵活性。 2.反过来用，我们不知道系统未来具体的业务实现时，我们可以先定义抽象类，将来让子类去实现，以方便系统的扩展。
3.3 模板方法模式
学习完抽象类的语法之后，接下来，我们学习一种利用抽象类实现的一种设计模式。先解释下一什么是设计模式？设计模式是解决某一类问题的最优方案。
设计模式在一些源码中经常会出现，还有以后面试的时候偶尔也会被问到，所以在合适的机会，就会给同学们介绍一下设计模式的知识。
那模板方法设计模式解决什么问题呢？模板方法模式主要解决方法中存在重复代码的问题
比如A类和B类都有sing()方法，sing()方法的开头和结尾都是一样的，只是中间一段内容不一样。此时A类和B类的sing()方法中就存在一些相同的代码。
怎么解决上面的重复代码问题呢？ 我们可以写一个抽象类C类，在C类中写一个doSing()的抽象方法。再写一个sing()方法，代码如下：
// 模板方法设计模式 public abstract class C { // 模板方法 public final void sing(){ System.out.println("唱一首你喜欢的歌："); doSing(); System.out.println("唱完了!"); } public abstract void doSing(); }然后，写一个A类继承C类，复写doSing()方法，代码如下
public class A extends C{ @Override public void doSing() { System.out.println("我是一只小小小小鸟，想要飞就能飞的高~~~"); } }接着，再写一个B类继承C类，也复写doSing()方法，代码如下
public class B extends C{ @Override public void doSing() { System.out.println("我们一起学猫叫，喵喵喵喵喵喵喵~~"); } }最后，再写一个测试类Test
public class Test { public static void main(String[] args) { // 目标：搞清楚模板方法设计模式能解决什么问题，以及怎么写。 B b = new B(); b.sing(); } }综上所述：模板方法模式解决了多个子类中有相同代码的问题。具体实现步骤如下
第1步：定义一个抽象类，把子类中相同的代码写成一个模板方法。 第2步：把模板方法中不能确定的代码写成抽象方法，并在模板方法中调用。 第3步：子类继承抽象类，只需要重写父类抽象方法就可以了。
多学一招：建议使用final关键字修饰模板方法，为什么？
模板方法是给对象直接使用的，不能被子类重写。 一旦子类重写了模板方法，模板方法就失效了。