目录
本文代码内容来自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" - 当一个类存在抽象方法的时候,该类必须被声明为抽象类
- 一个抽象类也可以没有抽象方法
- 抽象类不能被直接实例化
- 继承抽象类的子类必须提供父类中抽象方法的实现
抽象类和接口的区别
- 子类最多只能继承一个抽象类,却可以实现任意个接口
- 抽象类可以被修饰为:
public,protected,package,private
静态和非静态
final和非final
接口中声明的属性只能是(默认):
public
静态
final - 抽象类和接口都可以有实体方法,称为默认方法。
内部类
内部类是定义在另一个类中的类。
- 内部类方法可以访问该类定义所在的作用域中的数据, 包括私有的数据。
- 内部类可以对同一个包中的其他类隐藏起来。
- 当想要定义一个回调函数且不想编写大量代码时,使用匿名(anonymous) 内部类比较便捷。
内部类分为四种:
- 非静态内部类
- 静态内部类
- 匿名类
- 本地类
非静态内部类
非静态内部类可以直接在一个类里面定义。只有在外部类对象存在时,才有意义。
-非静态内部类的实例化必须以一个外部类的实例为基础。
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();
}
}