java基础复习——接口和继承

接口

在设计LOL的时候，进攻类英雄有两种，一种是进行物理系攻击，一种是进行魔法系攻击

这时候，就可以使用接口来实现这个效果。

接口就像是一种约定，我们约定某些英雄是物理系英雄，那么他们就一定能够进行物理攻击（前提是继承物理攻击的接口）

代码实例：

public class Hero {//基类                                         
    public String name;
    protected float hp;
}

public interface AD {
        //物理伤害
    public void physicAttack();
}

public class ADHero extends Hero implements AD{
 	//继承了  Hero类，且实现了AD接口
    @Override
    public void physicAttack() {
        System.out.println("进行物理攻击");
    }
 
}

实现某个接口，就相当于承诺了某种约定

所以，实现了AD这个接口，就必须提供AD接口中声明的方法physicAttack()
实现在语法上使用关键字 implements

public interface AP {
 
    public void magicAttack();
}

当然也能实现两个接口，让他具有两种攻击能力

//同时能进行物理和魔法伤害的英雄
public class ADAPHero extends Hero implements AD,AP{
  
    @Override
    public void magicAttack() {
        System.out.println("进行魔法攻击");
    }
  
    @Override
    public void physicAttack() {
        System.out.println("进行物理攻击");
    }
  
}

对象转型

一般来说，无需强转的就一定能转。
需要强转的，如果转型后的类型中的方法，在原类型中没有，则会强转失败。

重写

子类可以继承父类的对象方法

在继承后，重复提供该方法，就叫做方法的重写

又叫覆盖 override

多态

操作符的多态
“+” 可以作为算数运算，也可以作为字符串连接

类的多态
父类引用指向子类对象（其实是靠 对象方法的重写 实现的多态）

隐藏

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

隐藏，就是子类覆盖父类的类方法

super关键字

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

public class ADHero extends Hero implements AD{
  
    @Override
    public void physicAttack() {
        System.out.println("进行物理攻击");
    }
     
    public ADHero(String name){
        super(name);
        System.out.println("AD Hero的构造方法");
    }
     
    public static void main(String[] args) {
        new ADHero("德莱文");
    }
  
}

也可通过super调用父类的moveSpeed属性

public class ADHero extends Hero implements AD{
 
    int moveSpeed=400; //移动速度
 
    @Override
    public void physicAttack() {
        System.out.println("进行物理攻击");
    }
     
    public int getMoveSpeed(){
        return this.moveSpeed;
    }
     
    public int getMoveSpeed2(){
        return super.moveSpeed;
    }
     
    public static void main(String[] args) {
        ADHero h= new ADHero();
         
        System.out.println(h.getMoveSpeed());
        System.out.println(h.getMoveSpeed2());
         
    }
  
}

ADHero重写了useItem方法，并且在useItem中通过super调用父类的useItem方法

public class ADHero extends Hero implements AD {
 
    int moveSpeed = 400; // 移动速度
 
    @Override
    public void physicAttack() {
        System.out.println("进行物理攻击");
    }
 
    public int getMoveSpeed() {
        return this.moveSpeed;
    }
 
    public int getMoveSpeed2() {
        return super.moveSpeed;
    }
 
    // 重写useItem，并在其中调用父类的userItem方法
    public void useItem(Item i) {
        System.out.println("adhero use item");
        super.useItem(i);
    }
 
    public static void main(String[] args) {
        ADHero h = new ADHero();
 
        LifePotion lp = new LifePotion();
 
    }
 
}

Object类

Object类是所有类的父类

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

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

当一个对象没有任何引用指向的时候，它就满足垃圾回收的条件
当它被垃圾回收的时候，它的finalize() 方法就会被调用。
finalize() 不是开发人员主动调用的方法，而是由虚拟机JVM调用的。

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

假设，当两个英雄的hp相同的时候，我们就认为这两个英雄相同

public class Hero {
    public String name;
    protected float hp;
      
    public boolean equals(Object o){
        if(o instanceof Hero){
            Hero h = (Hero) o;
            return this.hp == h.hp;
        }
        return false;
    }
      
    public static void main(String[] args) {
        Hero h1= new Hero();
        h1.hp = 300;
        Hero h2= new Hero();
        h2.hp = 400;
        Hero h3= new Hero();
        h3.hp = 300;
         
        System.out.println(h1.equals(h2));
        System.out.println(h1.equals(h3));
    }
}

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

final

当Hero被修饰成final的时候，表示Hero不能够被继承
其子类会出现编译错误

Hero的useItem方法被修饰成final,那么该方法在ADHero中，不能够被重写

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

final修饰引用
h引用被修饰成final，表示该引用只有1次指向对象的机会

用来定义常量：
常量指的是可以公开，直接访问，不会变化的值

public static final int itemTotalNumber = 6;

抽象类

在类中声明一个方法，这个方法没有实现体，是一个“空”方法

这样的方法就叫抽象方法，使用修饰符“abstract"

在被继承后，抽象方法必须被实现。

当一个类有抽象方法的时候，该类必须被声明为抽象类

抽象类可以没有抽象方法
一旦一个类被声明为抽象类，就不能够被直接实例化

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