使用final修饰的方法不能被子类覆写：
class A {
public final void print(){
System.out.println("hello");
}
}
class B extends A{
public void print(){
System.out.println("world");
}
}
报错：Cannot override the final method from A

被final修饰的变量即成为常量，常量是不能被修改的：
class A {
private final String info = "hello";
public final void print(){
info = "Hello world";
}
}
报错：The final field A.info cannot be assigned
注意：final变量的命名规则
在使用final声明变量时，要求全部的字母大写，如INFO，这点在开发中是非常重要的。
如果一个程序中的变量使用public static final声明，则此变量将称为全局常量。

恶搞明星脸蛋,凤姐和葛优那个更有可塑性。

==================抽象类===================
1.1 抽象类的基本概念
通过继承可以从原有的类派生出新的类。原有的类称为基类或父类，而新的类则称为派生类或子类。通过继承机制，派生出的新类不仅可以保留原有类的功能，而且还可以拥有更多的功能。
除了上述的机制之外，在Java中也可以创建一种类专门用来当作父类，这种类称为“抽象类”。抽象类的作用类似“模板”，其目的是要设计者依据它的格式来修改并创建新的类。但是并不能直接由抽象类创建对象，只能通过抽象类派生出新的类，再由它来创建对象。但是在抽象类的使用中同样存在单继承的局限，即一个子类只能继承一个抽象类。
抽象类的定义及使用规则如下：
1.包含一个抽象方法的类必须是抽象类。
2.抽象类和抽象方法都要使用abstract关键字声明。
3.抽象方法只需要声明而不需要实现。
4.抽象类必须被子类继承，子类（如果不是抽象类）必须覆写抽象类中全部抽象方法。
抽象类的定义格式：
abstract class 抽象类名称{
属性;
访问权限 返回值类型 方法名称(参数){
return 返回值;
}
访问权限 abstract 返回值类型 方法名称(参数){
}
}
从以上格式中可以发现，抽象类的定义比普通类多了一些抽象方法，其他地方与普通类的组成基本上都是一样的。

定义一个抽象类：
abstract class A{
public static final String FLAG = "CHINA";
private String name = "LHB";
public abstract void print();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
在以上的A类中，因为定义了print()的抽象方法，所以此类的声明为abstract class。

定义完成一个抽象类后，就可以编写一个子类继承此抽象类。子类必须覆写抽象类中的全部抽象方法。
继承抽象类：
class B extends A{
public void print(){
System.out.println("FLAG：" + FLAG);
System.out.println("姓名：" + super.getName());
}
}
abstract class AbstractDemo02{
public static void main(String[] args) {
B b = new B();
b.print();
}
}
运行结果：
FLAG：CHINA
姓名：LHB
以上程序完成了抽象类的基本操作，子类覆写了抽象方法，然后在主方法中通过子类的实例化就可以调用被子类覆写过的方法。如下图所示：

图中，抽象类使用了abstract的方式表示，抽象类的图形也可以通过类名加斜体的方式表示，如下图：

抽象类可以使用final关键字声明吗？
不可以。因为抽象类必须被子类覆写，如果用final关键字声明，则此类不能被子类继承。
抽象方法不要用private声明：在使用abstract关键字修饰抽象类方法时不能使用private修饰，因为抽象方法必须被子类覆写，如果用private声明，则子类是无法覆写的。
抽象类中可以定义构造方法吗？
抽象类允许定义构造方法，因为抽象类依然使用的是类的继承关系，而且抽象类中也存在各个属性，所以子类在实例化之前必须先要对父类进行实例化。
字抽象类中定义构造方法：
abstract class A0601{
public A0601(){
System.out.println("A抽象类中的构造方法");
}
}
class B0601 extends A0601{
public B0601(){
System.out.println("B子类中的构造方法");
}
}
class AbstractDemo03{
public static void main(String[] args) {
B0601 b = new B0601();
}
}
运行结果：
A抽象类中的构造方法
B子类中的构造方法
从以上程序中可以方法，抽象类中定义了抽象方法，但是定义的抽象方法并不能被外部直接调用，在子类实例化前也同样会默认调用父类中的无参构造，也就是说子类实际上也隐含一个super关键字调用构造方法的语句。

既然子类可以通过super调用抽象类中的构造方法，那么也可以直接在子类指定调用中的指定参数的构造方法。
范例：调用抽象类中指定参数的构造方法
abstract class Person0611{
private String name;
private int age;
public Person0611(String name,int age) {
this.setName(name);
this.setAge(age);
}
public abstract String getInfo();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}

class Student0611 extends Person0611{
private String school;
public Student0611(String name,int age,String school){
super(name, age);
this.setSchool(school);
}
public String getInfo() {
return "姓名：" + super.getName()+
"；年龄：" + super.getAge()+
"；学校：" + this.getSchool();
}
public String getSchool() {
return school;
}
public void setSchool(String school) {
this.school = school;
}
}

class AbstractDemo04{
public static void main(String[] args) {
Student0611 st = new Student0611("张三",12,"清华大学");
System.out.println(st.getInfo());
}
}
运行结果：
姓名：张三；年龄：12；学校：清华大学
以上程序在实例化Student类时先调用了抽象类中的构造方法，将姓名和年龄进行设置，然后再通过覆写的getInfo()输出信息。
抽象类与普通类：
实际上抽象类就是比普通类多定义了一个抽象方法，除了不能直接进行对象的实例化操作之外并没有任何的不同。

凤姐来啦

有人说我是过来混经验的，我转身就是一巴掌:你TM说的不是废话吗！
✎﹏₯㎕﹍﹍
还会有什么痛比废墟的绿更鲜明，
千年来我一直保持清醒，
在寻找永恒的所谓爱情，
这难道是宿命。

每当看到楼上在厚颜无耻的刷经验我都会默默地转身离开。不带走一片云彩。