关键字final

final 表示不可改变的含义

• 采用 final 修饰的类不能被继承
• 采用 final 修饰的方法不能被覆盖
• 采用 final 修饰的变量不能被修改
• final 修饰的变量必须显示初始化如果修饰的引用，那么这个引用只能指向一个对象，也就是说这个引用不能再次赋值，但被指向的对象是可以修改的

构造方法不能被 final 修饰会影响 JAVA类的初始化:final 定义的静态常量调用时不会执行 java 的类初始化方法，也就是说不会执行 static 代码块等相关语句，这是由 java 虚拟机规定的。我们不需要了解的很深，有个概念就可以了。final修饰的实例变量一般和static联合使用，称为常量。public static final double PI = 3.1415926;

采用 final 修饰的类不能被继承

格式：

• 含义：当前这个类不能有任何的子类。（太监类）
• 注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写（因为没儿子。）

package cn.itcast.day11.demo01;/*
当final关键字用来修饰一个类的时候，格式：
public final class 类名称 {// ...
}*/
public final class MyClass /*extends Object*/ {public void method() {System.out.println("方法执行！");}}

采用 final 修饰的方法不能被覆盖

格式：

• 含义：当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。
• 注意：对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。

class A1 {public final void test1() {}
}

final修饰局部变量

• 基本类型不能被修改

public class PackTest {public static void main(String[] args) {// 声明变量，使用final修饰 final int a;// 第一次赋值 a = 10;// 第二次赋值 a = 20; // 报错,不可重新赋值// 声明变量，直接赋值，使用final修饰final int b = 10;// 第二次赋值 b = 20; // 报错,不可重新赋值 }
}

final修饰局部变量

• 引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能再更改。但是不影响对象内部的成员变量值的修改，代码如下：

public class PackTest {public static void main(String[] args) {// 创建 User 对象 final User u = new User();// 创建 另一个 User对象u = new User(); // 报错，指向了新的对象，地址值改变。 // 调用setName方法u.setName("张三"); // 可以修改 }
}

final修饰成员变量 

对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不可变。

• 由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了。
• 对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一。
• 必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值。

显示初始化：

public class PackTest {final String USERNAME = "张三";private int age;}

构造方法初始化：

public class PackTest {final String USERNAME;private int age;public PackTest(String username, int age) {this.USERNAME = username;this.age = age;}
}

抽象类概述

父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有 意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。类和类之间具有共同特征，将这些共同特征提取出来，形成的就是抽象类。类本身是不存在的，所以抽象类无法创建对象《无法实例化》。

抽象类与抽象方法

• 用abstract关键字来修饰一个类，这个类叫做抽象类。
• 用abstract来修饰一个方法，该方法叫做抽象方法。 抽象方法：只有方法的声明，没有方法的实现。以分号结束： 比如：public abstract void talk();

抽象方法

使用 abstract 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。

定义格式：

抽象类

如果一个类包含抽象方法，那么该类必须是抽象类。抽象的方法只需在抽象类中，提供声明，不需要实现，起到了一个强制的约束作用，要求子类必须实现

定义格式：

抽象类的成员特点

• 成员变量：既可以是变量也可以是常量
• 构造方法：可以有空参构造也可以有参构造
• 成员方法：可以有抽象方法也可以有普通方法

package demo06;/** abstract关键字的使用* 1.abstract:抽象的* 2.abstract可以用来修饰的结构：类、方法** 3. abstract修饰类：抽象类* 	> 此类不能实例化*      > 抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）*      > 开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作*** 4. abstract修饰方法：抽象方法* 		> 抽象方法只有方法的声明，没有方法体* 		> 包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。*      > 若子类重写了父类中的所有的抽象方法后，此子类方可实例化*        若子类没有重写父类中的所有的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰*        package com.atguigu.java;*  abstract使用上的注意点：* 1.abstract不能用来修饰：属性、构造器等结构* 2.abstract不能用来修饰私有方法、静态方法、final的方法、final的类**/public class AbstractTest {public static void main(String[] args) {//一旦Person类抽象了，就不可实例化//	Person p1 = new Person();}
}abstract class Creature {public abstract void breath();
}abstract class Person extends Creature {String name;int age;public Person() {}public Person(String name, int age) {this.name = name;this.age = age;}//抽象方法public abstract void eat();public void walk() {System.out.println("人走路");}}class Student extends Person {public Student(String name, int age) {super(name, age);}public Student() {}public void eat() {System.out.println("学生多吃有营养的食物");}@Overridepublic void breath() {System.out.println("学生应该呼吸新鲜的没有雾霾的空气");}
}

抽象的使用

继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该父 类的抽象方法，否则，从最初的父类到最终的子类都不能创建对象，失去意义。

代码演示

/*
抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束。
抽象类：抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可。
如何使用抽象类和抽象方法：
1. 不能直接创建new抽象类对象。
2. 必须用一个子类来继承抽象父类。
3. 子类必须覆盖重写抽象父类当中所有的抽象方法。
覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后补上方法体大括号。
4. 创建子类对象进行使用。*/
public abstract class Animal {// 这是一个抽象方法，代表吃东西，但是具体吃什么（大括号的内容）不确定。public abstract void eat();// 这是普通的成员方法public void normalMethod() {}}

实现抽象类

package cn.itcast.day09.demo11;public class Cat extends Animal {@Overridepublic void eat() {System.out.println("猫吃鱼");}}

此时的方法重写，是子类对父类抽象方法的完成实现，我们将这种方法重写的操作，也叫做实现方法。

定义测试类

package cn.itcast.day09.demo11;public class DemoMain {public static void main(String[] args) {//  Animal animal = new Animal(); // 错误写法！不能直接创建抽象类对象Cat cat = new Cat();cat.eat();}}

注意事项

抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。

• 理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。

抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

• 理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。

抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

• 理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设 计。

抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。

• 理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。 

抽象类不能被 final 修饰

• 抽象方法不能被 final 修饰，因为抽象方法就是被子类实现的

Java语言中凡是没有方法体的方法都是抽象方法。不对，错误的。

• Object类中就有很多方法都没有方法体，都是以“;”结尾的，但他们都不是抽象方法，例如：public native int hashCode();这个方法底层调用了C++写的动态链接库程序。前面修饰符列表中没有：abstract。有一个native。表示调用JVM本地程序。

应用

• 抽象类中可以包含方法实现，可以将一些公共的代码放到抽象类中，另外在抽象类中可以定义一些抽象的方法，这样就会存在一个约束，而子类必须实现我们定义的方法，如：teacher 必须实现 printInfo 方法，Student 也必须实现 printInfo 方法，方法名称不能修改，必须为 printInfo，这样就能实现多态的机制，有了多态的机制，我们在运行期就可以动态的调用子类的方法。所以在运行期可以灵活的互换实现。

模板方法设计模式(TemplateMethod)

• 抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模 板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象 类的行为方式。

解决的问题：

• 当功能内部一部分实现是确定的，一部分实现是不确定的。这时可以 把不确定的部分暴露出去，让子类去实现。
• 换句话说，在软件开发中实现一个算法时，整体步骤很固定、通用， 这些步骤已经在父类中写好了。但是某些部分易变，易变部分可以抽 象出来，供不同子类实现。这就是一种模板模式。