一、什么是接口

        接口就像是一种模板，接口中放着没有内容的方法，类要是使用接口就必须声明接口中的方法。下面继续以LOL游戏为例：

LOL的英雄，有些能够使用物理攻击，有些能够使用魔法攻击击，有些则两种攻击都能使用，因此可以将英雄分为ADHero类、APHero和ADAPHero类，其继承了Hero 类，继承了name,hp,armor等属性。

        以物理攻击为例，声明一个方法 physicAttack 物理攻击，其即在ADHero类中，也在ADAPHero类中，一种方法是在ADHero类中定义physicAttack 方法，ADAPHero类再继承ADHero类；而另一种方法就是使用接口。（为什么用要用接口而不一直使用继承呢，之后会补上）

        定义一个AD接口，里面提供了physicAttack()方法，但是没有方法体，是一个“空”方法。

interface AD {
    public void physicAttack();//物理攻击
}

        ADHero类实现AD接口，使用关键字 implements（这类似于继承extends），而且必须声明AD中的方法。

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

        同理，我们可以创建AP接口，ADAPHero类同时实现AD、AP接口。

public class ADAPHero extends Hero implements AD,AP{
  
    @Override
    public void magicAttack() {
        System.out.println("进行魔法攻击");
    }
  
    @Override
    public void physicAttack() {
        System.out.println("进行物理攻击");
    }  
}

二、对象转型

1.引用类型？对象类型？

public class MAIN {   
    public static void main(String[] args) {        
        ADHero ad = new ADHero();  
        Hero h = new ADHero();       
    }
}

        通过之前的学习我们可以知道，第一个对象是ADHero()，引用是ad，其类型都是ADHero（一般情况下，引用类型和对象类型是一样的）；第二个对象是ADHero()，引用是h，对象的类型是ADHero，引用的类型是Hero。

        当引用、对象类型不同时，只能使用引用类型中的方法，即h只能使用Hero中的方法，而ADHero中新增的不行。

2.类型转换

（1）类与类的转换

        和基本类型转换相似，子类转父类能够自动转，而父类转子类需要强转，但风险自担（很简单AD英雄是英雄，英雄可不一定是AD英雄），当然没有继承关系的两个类互相转换，一定会失败。

 

         但是转完之后，h依然不能使用ADHero()中的方法。

（2）类与接口的转换

        引用ad指向的对象是ADHero类型，这个类型实现了AD接口。从语义上来讲，把一个ADHero当做AD来使用，而AD接口只有一个physicAttack方法，这就意味着转换后就有可能要调用physicAttack方法，而ADHero一定是有physicAttack方法的，所以转换是能成功的。（即类转接口一定可以）

public static void main(String[] args) {
    ADHero ad = new ADHero();          
    AD adi = ad;
}

       第四行：adi实际上是指向一个ADHero的，所以能够转换成功。
       第五行：adi引用所指向的对象是一个ADHero，要转换为ADAPHero就会失败。    

public static void main(String[] args) {
    ADHero ad = new ADHero();            
    AD adi = ad;   
    ADHero adHero = (ADHero) adi;            
    ADAPHero adapHero = (ADAPHero) adi;
    adapHero.magicAttack();
}

3.  instanceof   

        判断一个引用所指向的对象，是否是Hero类型，或者Hero的子类

public static void main(String[] args) {
    ADHero ad = new ADHero();
    APHero ap = new APHero();
         
    Hero h1= ad;
    Hero h2= ap;
         
    //判断引用h1指向的对象，是否是ADHero类型
    System.out.println(h1 instanceof ADHero);
         
    //判断引用h2指向的对象，是否是APHero类型
    System.out.println(h2 instanceof APHero);
         
    //判断引用h1指向的对象，是否是Hero的子类型
    System.out.println(h1 instanceof Hero);
}

三、重写

        重写很简单，就是子类使用了父类的方法，但是子类想做出点改变。比如Hero类中有attack()方法，产生的效果是进行攻击，而ADHero也有attack()，但是产生的效果是进行AD攻击。

class Hero {
    public void attack() {
        System.out.println(" 进行了一次攻击");
    }
}
class ADHero extends Hero {
    public void attack() {
        System.out.println(" 进行了一次AD攻击");
    }
}

        可想而知，如果没有重写这样的机制，子类，一旦继承了父类，所有方法都不能修改了。但是子类又希望提供一点不同的功能，为了达到这个目的，只能放弃继承父类，重新编写所有的属性和方法，然后在编写effect的时候，做一点小改动，这样就增加了开发时间和维护成本。

四、多态

        多态: 都是同一个类型，调用同一个方法，却能呈现不同的状态。

1.操作符的多态

        同一个操作符在不同情境下，具备不同的作用
        如果+号两侧都是整型，那么+代表 数字相加
        如果+号两侧，任意一个是字符串，那么+代表字符串连接

2.类的多态条件

        要实现类的多态，需要如下条件

        1. 父类（接口）引用指向子类对象

        2. 调用的方法有重写

五、隐藏

        与重写类似，方法的重写是子类覆盖父类的对象方法；隐藏，就是子类覆盖父类的类方法。

        类方法就是静态方法。

六、super关键字

1.实例化子类，父类的构造方法一定会被调用

        实例化一个ADHero(), 其构造方法会被调用
        其父类的构造方法也会被调用
        并且是父类构造方法先调用
        子类构造方法会默认调用父类的无参的构造方法

 2.super的用法和this很像，super是调用父类的方方法，而this是调用自己的。        

七、final修饰符

1.final修饰的类不能被继承；

2.inal修饰的方法不能被重写；

3.final修饰基本类型变量，表示该变量只有一次赋值机会；

        常量指的是可以公开，直接访问，不会变化的值

4.final修饰引用，表示该引用只有1次指向对象的机会。

八、object类

        Object类是所有类的父类，声明一个类的时候，默认是继承了Object。

1.toString()

        Object类提供一个toString方法，所以所有的类都有toString方法，toString()的意思是返回当前对象的字符串表达。

2.finalize()

        当一个对象没有任何引用指向的时候，它就满足垃圾回收的条件。当它被垃圾回收的时候，它的finalize() 方法就会被调用。

3. equals()

        equals() 用于判断两个对象的内容是否相同。

4.==

        这不是Object的方法，但是用于判断两个对象是否相同。更准确的讲，用于判断两个引用，是否指向了同一个对象。

5.hashCode()

        hashCode方法返回一个对象的哈希值。

6.Object还提供线程同步相关方法

7.getClass()

        getClass()会返回一个对象的类对象。

九、抽象类

1.抽象类

        在类中声明一个方法，这个方法没有实现体，是一个“空”方法；
        这样的方法就叫抽象方法，使用修饰符“abstract"；
        当一个类有抽象方法的时候，该类必须被声明为抽象类。

public abstract class Hero { 
    // 抽象方法attack
    // Hero的子类会被要求实现attack方法
    public abstract void attack();
 
}

        可以在不提供抽象方法的前提下，声明为抽象类。

        一旦一个类被声明为抽象类，就不能够被直接实例化。

2.抽象类和接口的区别

（1）区别1：
        子类只能继承一个抽象类，不能继承多个
        子类可以实现多个接口
（2）区别2：
        抽象类可以定义：public,protected,package,private、静态和非静态属性、final和非final属性
        但是接口中声明的属性，只能是：public、静态、final的，即便没有显式的声明

        注: 抽象类和接口都可以有实体方法。 接口中的实体方法，叫做默认方法。

3.默认方法

        默认方法是JDK8新特性，指的是接口也可以提供具体方法了，而不像以前，只能提供抽象方法。例如Mortal 这个接口，增加了一个默认方法 revive，这个方法有实现体，并且被声明为了default。

interface Mortal {
	public void die();
	default public void revive() {
		System.out.println("本英雄复活了");
	}
}

        假设没有默认方法这种机制，那么如果要为Mortal增加一个新的方法revive,那么所有实现了Mortal接口的类，都需要做改动。
        但是引入了默认方法后，原来的类，不需要做任何改动，并且还能得到这个默认方法。
        通过这种手段，就能够很好的扩展新的类，并且做到不影响原来的类。

十、内部类

1.非静态内部类

        非静态内部类可以直接在一个类里面定义。

        语法: new 外部类().new 内部类()。

        作为非静态内部类，是可以直接访问外部类的private实例属性的。

class Hero {
	private String name; // 姓名

	// 非静态内部类，只有一个外部类对象存在的时候，才有意义
	// 战斗成绩只有在一个英雄对象存在的时候才有意义
	class BattleScore {
		int kill;
		int die;
		int assit;

		public void legendary() {
			if (kill >= 8)
				System.out.println(name + "超神！");
			else
				System.out.println(name + "尚未超神！");
		}
	}
}	

public class MAIN {
    public static void main(String[] args) {
		Hero garen = new Hero();
		garen.name = "盖伦";
		// 实例化内部类
		// BattleScore对象只有在一个英雄对象存在的时候才有意义
		// 所以其实例化必须建立在一个外部类对象的基础之上
		BattleScore score = garen.new BattleScore();
		score.kill = 9;
		score.legendary();
	}
}

2.静态内部类

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

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 class MAIN {
    public static void main(String[] args) {
        //实例化静态内部类
        Hero.EnemyCrystal crystal = new Hero.EnemyCrystal();
        crystal.checkIfVictory();
    }
}

3.匿名类

        匿名类指的是在声明一个类的同时实例化它，使代码更加简洁精练；
        通常情况下，要使用一个接口或者抽象类，都必须创建一个子类；
        有的时候，为了快速使用，直接实例化一个抽象类，并“当场”实现其抽象方法。既然实现了抽象方法，那么就是一个新的类，只是这个类，没有命名。 这样的类，叫做匿名类。

abstract class Hero {
    String name; //姓名          
    float hp; //血量          
    float armor; //护甲          
    int moveSpeed; //移动速度
      
    public abstract void attack();
}
public abstract class Hero {
    public static void main(String[] args) {                   
        Hero h = new Hero(){
            //当场实现attack方法
            public void attack() {
                System.out.println("新的进攻手段");
            }
        };
        h.attack();         
        System.out.println(h);
    }
}

        在匿名类中使用外部的局部变量，外部的局部变量必须修饰为final。
        注：在jdk8中，已经不需要强制修饰成final了，如果没有写final，不会报错，因为编译器偷偷的帮你加上了看不见的final。

4.本地类

        本地类可以理解为有名字的匿名类。
        内部类与匿名类不一样的是，内部类必须声明在成员的位置，即与属性和方法平等的位置。本地类和匿名类一样，直接声明在代码块里面，可以是主方法，for循环里等等地方。

abstract class Hero {
    String name; //姓名          
    float hp; //血量          
    float armor; //护甲          
    int moveSpeed; //移动速度
      
    public abstract void attack();
}
public abstract class Hero {
    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();
    }
}