本文代码内容来自HOW2J.CN。

接口

接口（interface）用来描述类有什么功能，而不给出每个功能的具体实现。

• 一个类可以实现（implement）多个接口。
• 一旦一个类实现了某个接口，他就必须提供接口中声明的方法。

创建接口

package charactor;
public interface AD{
	public void physicAttack();
}

实现接口

package charactor;
public class ADHero extends Hero implements AD{
	@override
	public void physicAttack(){
		System.out.println(\"进行物理攻击\");
	}
}

@override表示下面这个方法是从父类/接口 继承过来的，需要你重写一次，这样就可以方便你阅读，也不怕会忘记。

对象间的类型转换

子类转父类

也称向上转型：父类对象<–子类对象，可以直接转换

父类转子类

也称向下转型：子类对象<–父类对象，转换有风险，需强制类型转换

没有继承关系

转换必定失败

instanceof

instanceof关键字用来判断一个引用所指向的对象是否是某类或者其子类，返回boolean。

System.out.println(h1 instanceof ADHero);

重写 override

重写也叫覆盖
在子类中重新提供父类中的对象方法就是重写
在子类中重新提供父类中的**静态方法（类方法）**叫做隐藏

多态

多态是同一个行为具有多个不同表现形式或形态的能力。
多态存在的条件：

• 继承
• 重写
• 父类引用指向子类对象

super关键字

super和this类似，只不过this指的是当前类，super指的是当前类的父类。

final

final修饰类

被final修饰的类不能被继承

final修饰方法

被final修饰的方法不能被子类重写

final修饰基本变量

被final修饰的基本变量只有一次赋值机会，赋值以后就不能更改

final修饰引用

被final修饰的引用只有一次指向对象的机会（对象的属性可以修改）

abstract

• 在类中声明一个方法，这个方法没有实现体，是一个“空”方法
  这样的方法就叫抽象方法，使用修饰符“abstract\"
• 当一个类存在抽象方法的时候，该类必须被声明为抽象类
• 一个抽象类也可以没有抽象方法
• 抽象类不能被直接实例化
• 继承抽象类的子类必须提供父类中抽象方法的实现

抽象类和接口的区别

1. 子类最多只能继承一个抽象类，却可以实现任意个接口
2. 抽象类可以被修饰为：
     public，protected，package，private
     静态和非静态
     final和非final
   接口中声明的属性只能是（默认）：
     public
     静态
     final
3. 抽象类和接口都可以有实体方法，称为默认方法。

内部类

内部类是定义在另一个类中的类。

• 内部类方法可以访问该类定义所在的作用域中的数据， 包括私有的数据。
• 内部类可以对同一个包中的其他类隐藏起来。
• 当想要定义一个回调函数且不想编写大量代码时，使用匿名（anonymous) 内部类比较便捷。

内部类分为四种：

1. 非静态内部类
2. 静态内部类
3. 匿名类
4. 本地类

非静态内部类

非静态内部类可以直接在一个类里面定义。只有在外部类对象存在时，才有意义。
-非静态内部类的实例化必须以一个外部类的实例为基础。
new 外部类().new 内部类();
在静态内部类里面可以访问外部类的实例属性

package charactor;
public class Hero {
    private String name; // 姓名 
    float hp; // 血量 
    float armor; // 护甲 
    int moveSpeed; // 移动速度 
    // 非静态内部类，只有一个外部类对象存在的时候，才有意义
    // 战斗成绩只有在一个英雄对象存在的时候才有意义
    class BattleScore {
        int kill;
        int die;
        int assit; 
        public void legendary() {
            if (kill >= 8)
                System.out.println(name + \"超神！\");
            else
                System.out.println(name + \"尚未超神！\");
        }
    } 
    public static void main(String[] args) {
        Hero garen = new Hero();
        garen.name = \"盖伦\";
        // 实例化内部类
        // BattleScore对象只有在一个英雄对象存在的时候才有意义
        // 所以其实例化必须建立在一个外部类对象的基础之上
        BattleScore score = garen.new BattleScore();
        score.kill = 9;
        score.legendary();
    } 
}

静态内部类

静态内部类的实例化不需要以一个外部类的实例为基础

• 可以直接实例化。
  new 外部类.静态内部类();
  因为没有一个外部类的实例，所以在静态内部类里面不可以访问外部类的实例属性和方法
• 除了可以访问外部类的私有静态成员外，静态内部类和普通类没什么大的区别

package charactor;  
public class Hero {
    public String name;
    protected float hp;  
    private static void battleWin(){
        System.out.println(\"battle win\");
    }     
    //敌方的水晶
    static class EnemyCrystal{
        int hp=5000;         
        //如果水晶的血量为0，则宣布胜利
        public void checkIfVictory(){
            if(hp==0){
                Hero.battleWin();                 
                //静态内部类不能直接访问外部类的对象属性
                System.out.println(name + \" win this game\");
            }
        }
    }     
    public static void main(String[] args) {
        //实例化静态内部类
        Hero.EnemyCrystal crystal = new Hero.EnemyCrystal();
        crystal.checkIfVictory();
    }  
}

匿名类

匿名类在声明一个类的同时对其进行实例化，是代码更加简洁精炼。

• 通常情况下，要使用一个接口或者抽象类，都必须创建一个子类
  有的时候，为了快速使用，直接实例化一个抽象类，并“当场”实现其抽象方法。
  既然实现了抽象方法，那么就是一个新的类，只是这个类，没有命名。
• 在匿名类中使用外部的局部变量，外部的局部变量必须修饰为final

package charactor;   
public abstract class Hero {
    String name; //姓名          
    float hp; //血量          
    float armor; //护甲          
    int moveSpeed; //移动速度      
    public abstract void attack();      
    public static void main(String[] args) {          
        ADHero adh=new ADHero();
        //通过打印adh，可以看到adh这个对象属于ADHero类
        adh.attack();
        System.out.println(adh);          
        Hero h = new Hero(){
            //当场实现attack方法
            public void attack() {
                System.out.println(\"新的进攻手段\");
            }
        };
        h.attack();
        //通过打印h，可以看到h这个对象属于Hero$1这么一个系统自动分配的类名          
        System.out.println(h);
    }     
}

本地类

本地类可以理解为有名字的匿名类

package charactor;  
public abstract class Hero {
    String name; //姓名          
    float hp; //血量          
    float armor; //护甲          
    int moveSpeed; //移动速度      
    public abstract void attack();      
    public static void main(String[] args) {          
        //与匿名类的区别在于，本地类有了自定义的类名
        class SomeHero extends Hero{
            public void attack() {
                System.out.println( name+ \" 新的进攻手段\");
            }
        }         
        SomeHero h  =new SomeHero();
        h.name =\"地卜师\";
        h.attack();
    }      
}