接口与继承（补充）

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

类的多态
父类引用指向子类对象

多态条件

要实现类的多态，需要如下条件
1. 父类（接口）引用指向子类对象
2. 调用的方法有重写

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

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

如果父类和子类创建的是静态方法，结果会调用引用所在的父类方法；

如果父类和子类创建的是非静态方法，结果会调用引用所指向的子类方法；

Object类

1.Object类是所有类的父类

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

2.toString()

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

public class Hero {
    public String name;
    protected float hp;
      
    public String toString(){
        return name;
    }
      
    public static void main(String[] args) {
         
        Hero h = new Hero();
        h.name = "盖伦";
        System.out.println(h.toString());
        //直接打印对象就是打印该对象的toString()返回值
        System.out.println(h);
    }
}

3.finalize() 

当一个对象没有任何引用指向的时候，它就满足垃圾回收的条件

当它被垃圾回收的时候，它的finalize() 方法就会被调用。

finalize() 不是开发人员主动调用的方法，而是由虚拟机JVM调用的。

4.equals()

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

5.==

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

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));
        System.out.println(h1==h2);
        System.out.println(h1==h3);
    }
}

 6.hashCode()

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

7.线程同步相关方法

Object还提供线程同步相关方法
wait()
notify()
notifyAll()

8.getClass()

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

final

final修饰类，方法，基本类型变量。

1.final修饰类

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

2.final修饰方法

final修饰的方法不能够被重写

3.final修饰基本类型变量

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

4.final修饰引用
h引用被修饰成final，表示该引用只有1次指向对象的机会。但是依然通过h引用修改对象的属性值hp，因为hp并没有final修饰。

5.常量

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

抽象abstract

1.抽象类

为Hero增加一个抽象方法 attack，并且把Hero声明为abstract的。
APHero,ADHero,ADAPHero是Hero的子类，继承了Hero的属性和方法。
但是各自的攻击手段是不一样的，所以继承Hero类后，这些子类就必须提供不一样的attack方法实现。

package charactor;

public abstract class Hero {
	String name;

	float hp;

	float armor;

	int moveSpeed;

	public static void main(String[] args) {

	}

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

}

2.抽象类可以没有抽象方法

Hero类可以在不提供抽象方法的前提下，声明为抽象类
一旦一个类被声明为抽象类，就不能够被直接实例化

3.抽象类和接口的区别

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

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

package charactor;
 
public interface AP {
 
	public static final int resistPhysic = 100;
	
	//resistMagic即便没有显式的声明为 public static final
	//但依然默认为public static final
	int resistMagic = 0; 
	
    public void magicAttack();
}

补充：final和abstract是两个冲突的修饰符，不能同时用这两修饰符修饰同一个东西，但是abstract类里面的属性可以是final修饰的。如果这个类设置final形式，这个类的所有方法都会被设置为final，这个类的变量可以设置为final或者非final。

抽象类中可以包含static属性和方法，但是对于同一方法而言，不能同时被static和abstract修饰。