抽象类：Abstract

定义：用abstract 关键字来修饰一个类时，这个类叫做抽象类，用abstract来修饰一个方法是，该方法叫做抽象方法。

----含有抽象方法的类，必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写；

----抽象类不能被实例化，一般是用来重写；

----抽象方法只需声明，而不需实现。如：public abstract void enjoy（）{ }；

----当一个类中有抽象方法的时候，这个类是抽象类，如：abstract class Animal{} 

Final 关键字：

-final的变量的值不能被改变（包括final的成员变量，局部变量，形参）

-final的方法不能被重写

-final的类不能够被继承

public class TestFinal {

 ();
    t.i = 9;
  }
}
class T {
 final int i = 8;  //不允许改变
}
结果：错误；即使写t.i = 8,也会报错；
final 指向特定，只能读而不能改变；


class T {
 final int i = 8;  //不允许改变
public final void m(){
 
    }
}
class TT extends T{
public void m(){
  }
}

报错：m不能被覆盖（重写）；

final class T {
 final int i = 8;  //不允许改变
public final void m(){
 
    }
}
class TT extends T{
public void m(){
  }
}

报错：不能继承；

Interface （接口）：

定义：抽象方法和常量值的定义的集合。

本质上，接口是一种特殊的抽象类，这种抽象类中只包含定义常量和方法的定义，而没有变量和方法的实现。

举例：

public interface Runner {
public static final
public void start();  //不用写abstract
public void run ();
public void stop();
}
-多个无关的类可以实现同一个接口
-一个类可以实现多个无关的接口
-与继承关系类似，接口与实现之间存在多态性
-定义Java类的语法格式：
   <modifier> class <name> [extends <superclass>]
[implements <interface>]   [, <interface> *]
{ <declarations>*}

Interface的特性：

-接口可以多重实现，一个类可以有多个接口；

-接口中只能声明的属性为public static final；

-接口中只能定义抽象方法，方法只能是public；

-接口可以继承其他的接口，并添加新的属性和抽象方法。

实例1：

interface Singer {
public void sing();
public void sleep();
}
class Student implements Singer{ //实现接口，相当于实现接口所定义的抽象方法
private String name;
Student(String name){
this.name = name;
   }
  public void study(){
System.out.println("studying");
}
   public String getName() {return name;}
   public void sing() {
System.out.println ("student is singing");
  }
   public void sleep() {
System.out.println ("student is sleeping");
  }
}

实例2：

interface Singer {
public void sing();
public void sleep();
}
interface Painter {
public void paint();
public void eat();
}
class Student implements Singer,Painter {  // 一个类实现多个无关接口 ,Student 该成teacher，就是多个无关的类，实现同一个接口
private String name;
Student(String name){
this.name = name;
   }
  public void study(){
System.out.println("studying");
}
   public String getName() {return name;}
   public void sing() {
System.out.println ("student is singing");
  }
   public void sleep() {
System.out.println ("student is sleeping");
  }
public void paint() {System.out.println("Student is painting");}
public void eat() {System.out.println("Student is eating");
 }

所有方法必须全部实现。

实例3：

public class Test {
public static void main (String args[]){
 Singer s1 = new Student ("le");
s1.sing();
s1.sleep();
Singer s2 = new Teacher ("seven");
s2.sing():
s2.sleep();
Painter p1 = (Painter) s2;
s2.paint(); s2.eat();
   }
}

虽然每个new出来的对象不属于本身的类，但是，本身的对象属于哪个类就能调用本身所属类的方法，不管它是被本身的类new出来的；

这种就是呈现出了多态性，接口与实现之间存在多态性。

public interface Valuable{
public double getMoney();
}
public interface Protectable {
public void beProtected();
}
interface A extends Protectable {    //接口与接口之间可以继承
  void m(); 
}
abstract class Animal {
private String name;
abstract void enjoy();
}
class GoldenMonkey extends Animal implements Valuable , Protectable {
public double getMoney () {
return 1000;
          }
public void beProtected() {
 System.out.println ("live in the room");
     }
public void enjoy (); {}
public void test() {
 Valuable v = new GoldenMonkey() ;
v.getMoney();
Protectable p = (Protectable) v;
p.beProtected();
   }
}

Add: 

补充下前一篇小记的多态实例：

实例：

分析游戏物体的多态包装。

游戏：雷电

1.子弹类：各个位置的子弹是对象，飞机类：飞机1，飞机2·····；

2.如果丰富游戏，需要添加其他的类，如各种boss的出现；这种情况对编码造成了麻烦。

3.解决方法：添加一个总的父类，GameObject类，定义一个Create()方法，然后在每一个子类中，自己重写Create方法，得到需要的Object，无需修改任何。