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接口的类，都需要做改动。
但是引入了默认方法后，原来的类，不需要做任何改动，并且还能得到这个默认方法
通过这种手段，就能够很好的扩展新的类，并且做到不影响原来的类
