java接口与继承

1.关键词实现接口 implements

public interface AP {
    public void magicAttack();
}

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

2.对象转型

ADHero ad = new ADHero();

在这个例子里，有一个对象 new ADHero(), 同时也有一个引用ad
对象是有类型的，是ADHero
引用也是有类型的，是ADHero
通常情况下，引用类型和对象类型是一样的
接下来要讨论的类型转换的问题，指的是引用类型和对象类型不一致的情况下的转换问题

子类转父类（向上转型），一定可以

package charactor;
public class Hero {
    public String name;
    protected float hp;
    public static void main(String[] args) {
        Hero h = new Hero();
        ADHero ad = new ADHero();
        //类型转换指的是把一个引用所指向的对象的类型，转换为另一个引用的类型
        //把ad引用所指向的对象的类型是ADHero
        //h引用的类型是Hero
        //把ADHero当做Hero使用，一定可以
        h = ad;
    }
}

父类转子类（向下转型）
父类转子类，有的时候行，有的时候不行，所以必须进行强制转换。

package charactor;
import charactor1.Support;
public class Hero {
    public String name;
    protected float hp;
    public static void main(String[] args) {
        Hero h =new Hero();
        ADHero ad = new ADHero();
        Support s =new Support();
          
        h = ad;
        //成功
        ad = (ADHero) h;
        h = s;
       // 失败
        ad = (ADHero)h;
    }
}

没有继承关系的两个类，互相转换，一定会失败

package charactor;
public class Hero {
    public String name;
    protected float hp;
    public static void main(String[] args) {
        ADHero ad = new ADHero();
        APHero ap = new APHero();
        // 没有继承关系的类型进行互相转换一定会失败，所以会出现编译错误
        ad = (ADHero) ap;
    }
}

实现类转换成接口（向上转型），一定可以成功

package charactor;
public class Hero {
    public String name;
    protected float hp;
    public static void main(String[] args) {
        ADHero ad = new ADHero();
        AD adi = ad;
    }    
}

接口转换成实现类（向下转型）

package charactor;
public class Hero {
    public String name;
    protected float hp;
    public static void main(String[] args) {
        ADHero ad = new ADHero();
// ad引用指向ADHero， 而adi引用是接口类型：AD，实现类转换为接口，是向上转型，所以无需强制转换，并且一定能成功
        AD adi = ad;
// adi实际上是指向一个ADHero的，所以能够转换成功
        ADHero adHero = (ADHero) adi;
//adi引用所指向的对象是一个ADHero，要转换为ADAPHero就会失败。
        ADAPHero adapHero = (ADAPHero) adi;
//假设能够转换成功，那么就可以使用magicAttack方法，而adi引用所指向的对象ADHero是没有magicAttack方法的。
        adapHero.magicAttack();
    }
}

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

package charactor;
public class Hero {
    public String name;
    protected float hp;
    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);
    }
}

3.重写

子类可以继承父类的对象方法
在继承后，重复提供该方法，就叫做方法的重写
又叫覆盖 override

4.多态

操作符的多态:
符号 + 可以作为算数运算，也可以作为字符串连接
类的多态:
父类引用指向子类对象

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

父类（接口）引用指向子类对象
调用的方法有重写

5.隐藏

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

6.关键字 supper

super可以在子类中调用父类构造函数、父类属性、父类方法。

7.Object类

所有的类都继承了Object类，Object类提供了一些方法，所有的类都可以调用

方法	功能
toString()	返回当前对象的字符串表达
finalize()	当一个对象没有任何引用指向的时候，它就满足垃圾回收的条件,当它被垃圾回收的时候，它的finalize() 方法就会被调用。
equals()	equals() 用于判断两个对象的内容是否相同
==	这不是Object的方法，但是用于判断两个对象是否相同。更准确的讲，用于判断两个引用，是否指向了同一个对象
......	还有很多

8.关键字 final

final修饰类，方法，基本类型变量，引用的时候分别有不同的意思。
final放在变量类型之前

final修饰对象	作用
类	类无法被继承
方法	方法不能被重写
基本类型变量	变量只有1次赋值机会
引用	引用只有1次指向对象的机会
常量	常量是可公开、直接访问，不会变化的值。 public static final int itemTotalNumber = 6

9.抽象类

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

子类必须实现父类的抽象方法
类可以在不提供抽象方法的前提下，声明为抽象类。一旦一个类被声明为抽象类，就不能够被直接实例化
抽象类和接口的区别：
（1）子类只能继承一个抽象类，不能继承多个。子类可以实现多个接口
（2）抽象类可以定义：
public,protected,package,private
静态和非静态属性
final和非final属性
但是接口中声明的属性，只能是
public
静态
final的
即便没有显式的声明
抽象类和接口都可以有实体方法。接口中的实体方法，叫做默认方法

10.内部类

内部类分为四种：
非静态内部类
静态内部类
匿名类
本地类

非静态内部类：
战斗成绩只有在一个英雄对象存在的时候才有意义
所以实例化BattleScore 的时候，必须建立在一个存在的英雄的基础上
语法: new 外部类().new 内部类()
作为Hero的非静态内部类，是可以直接访问外部类的private实例属性name的
静态内部类：
在一个类里面声明一个静态内部类
比如敌方水晶，当敌方水晶没有血的时候，己方所有英雄都取得胜利，而不只是某一个具体的英雄取得胜利。
与非静态内部类不同，静态内部类水晶类的实例化不需要一个外部类的实例为基础，可以直接实例化
语法：new 外部类.静态内部类();
因为没有一个外部类的实例，所以在静态内部类里面不可以访问外部类的实例属性和方法
除了可以访问外部类的私有静态成员外，静态内部类和普通类没什么大的区别
匿名类：
匿名类指的是在声明一个类的同时实例化它，使代码更加简洁精练
通常情况下，要使用一个接口或者抽象类，都必须创建一个子类；
有的时候，为了快速使用，直接实例化一个抽象类，并“当场”实现其抽象方法。
既然实现了抽象方法，那么就是一个新的类，只是这个类，没有命名。
这样的类，叫做匿名类
本地类
本地类可以理解为有名字的匿名类
内部类与匿名类不一样的是，内部类必须声明在成员的位置，即与属性和方法平等的位置。
本地类和匿名类一样，直接声明在代码块里面，可以是主方法，for循环里等等地方

11.默认方法

默认方法是JDK8新特性，指的是接口也可以提供具体方法了，而不像以前，只能提供抽象方法

Mortal 这个接口，增加了一个默认方法 revive，这个方法有实现体，并且被声明为了default

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

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