1.final类：不允许任何类继承，并且不允许其他人对这个类进行任何改动；

当被某个类设置为final类时，类中的所有方法都被隐式的设置为final形式，但是final类中的成员变量既可以被定义为final形式，又可以被定义为非final形式。

例1：使用final修饰五星红旗类，输出“五星红旗是由红色的旗面和5颗黄色的五角星组成的”，运行效果如下：

public final class FiveStarRedFlag {
    int starNum;
    String starColor;
    String backgroundColor;
    public FiveStarRedFlag(int starNum,String starColor,String backgroundColor){
        this.starNum=starNum;
        this.starColor=starColor;
        this.backgroundColor=backgroundColor;
    }
    public static void main(String[] args){
        FiveStarRedFlag fg=new FiveStarRedFlag(5,"黄色","红色");
        System.out.println("五星红旗是由"+fg.backgroundColor+"的旗面和"+fg.starNum+"颗"+fg.starColor+"的五角星组成的");
    }
}

2.final方法：不能被重写 。

将方法定义为final类型可以防止子类修改该方法的定义与实现方式，同时final方法的执行效率要高于非final方法。如果一个父类的某个方法被设置为private修饰符，子类将无法访问该方法，自然无法覆盖该方法，所以一个定义为 private的方法隐式被指定为final类型，这样无须将一个定义为private的方法再定义为final类型。

练习：编写交通类，将遵守交通规则的方法设为final()方法，不管是行人，非机动车辆，还是机动车辆，遵守的交通规则都是一样的，例如红灯停，绿灯行等。运行效果如下：

class Traffic{
    String TrafficRule;
    public Traffic(String TrafficRule){
        this.TrafficRule=TrafficRule;
    }
    public final String Obey(){
        return this.TrafficRule+"要遵守交通规则，红灯停，绿灯行，黄灯需要等一等！";
    }
}
class Pedestrian extends Traffic{
    public Pedestrian(String TrafficRule){
        super(TrafficRule);
    }
}
class motorvehicle extends Traffic{
    public motorvehicle(String TrafficRule){
        super(TrafficRule);
    }
}
class nonmotorvehicle extends Traffic{
    public nonmotorvehicle(String TrafficRule){
        super(TrafficRule);
    }
}

public class TrafficFinalMethod {
    public static void main(String[] args){
        Pedestrian p=new Pedestrian("行人");
        System.out.println(p.Obey());
        motorvehicle m=new motorvehicle("机动车");
        System.out.println(m.Obey());
        nonmotorvehicle n=new nonmotorvehicle("非机动车");
        System.out.println(n.Obey());
    }
}

 3.final变量：可用于修饰变量，一旦变量被final修饰，就不可以再改变变量的值。通常，把被final修饰的变量称作常量。

final修饰变量时，必须在声明时对其进行赋值操作。final除了可以修饰基本数据类型的常量，还可以修饰对象引用，例如被final修饰的数组。一旦一个对象引用被final修饰后，它只能恒定指向一个对象，无法指向另一个对象。一个既是static又是final的字段占据了一段不能改变的存储空间。

练习1：动车组每节车厢只有108个座位，共有10节车厢，现有旅客1189人，从控制台输出滞留旅客的人数。运行效果如下：

public class TravelPeople {
    final int num=10;//声明一个常量，10节车厢
    int seatnum=108; //每节车厢108个座位
    int peoplenum=1189; //现有旅客1189人
    public void travel(){
        int A; //滞留人员数量
        A=peoplenum-(seatnum *num);
        System.out.println("滞留旅客的人数是："+A);
    }

//
    public static void main(String[] args){
        TravelPeople t=new TravelPeople();
        t.travel();

    }
}

练习2：将π的值设为常量，在控制台输入水泥柱的底面周长后，输出该水泥柱的直径。运行效果如下：

import java.util.Scanner;
public class Yuanzhu {
    final double pi=3.14;
    double d;
    public void calculate(double num){
        d=num/pi;
        System.out.println("水泥柱的直径是"+d);
    }
    public static void main(String[] args){
        Yuanzhu y=new Yuanzhu();
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入水泥柱的地面周长：");
        double ZhouChang=sc.nextDouble();
        y.calculate(ZhouChang);


    }
}