Java小记之抽象类，final关键字，接口（附上一篇补充）

抽象类：Abstract

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

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

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

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

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

Final 关键字：

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

-final的方法不能被重写

-final的类不能够被继承

public class TestFinal {

 public static void main (String args[]){

    T t = new T ();

    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 int id  = 1;  //  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，无需修改任何。