1.5 多态
*多态(polymorphic)
*方法或对象具有多种形态，是面向对象的第三大特征，多态是建立在封装和继承基础之上的
1.多态的具体体现
1.方法的多态
（重写和重载体现了多态）
2.对象的多态
1.一个对象的编译类型和运行类型可以不一致
Animal animal = new Dog(); //animal编译类型是Animal，运行类型是Dog
animal = new Cat();
2.编译类型在定义对象时，就确定了，不能改变
3.运行类型是可以变化的
4.编译类型看定义时=号的左边，运行类型看 = 号的右边
class Cat extends Animal
{
public void cry()
{
System.out.println("小猫喵喵叫")
}
}
class Animal
{
public void cry()
{
System.out.println("动物在叫")
}
}
main()
{
Animal animal = new Cat();
animal.cry(); //小猫喵喵叫
//若此时改为Dog类，则会执行Dog类下的方法
animal = new Dog();
animal.cry();
}
2.多态的细节
1.多态的前提：两个对象(类)存在继承关系
2.本质：父类的引用指向了子类的对象
3.语法：父类类型 引用名 = new 子类类型();
4.特点：编译类型看左边，运行类型看右边
5.如果子类中写有父类没有的方法，那么如果运用了多态，就调用不了子类特有的成员方法
3.多态的向上转型
*(子类转换成父类)
*父类也可以是爷爷类(基类)
4.多态的向下转型
1.语法： 子类类型 引用名 = (子类类型) 父类引用
2.只能强转父类的引用，不能强转父类的对象
3.要求父类的引用必须指向的是当前目标类型的对象
4.当向下转型后，可以调用子类类型中所有的成员
main()
{
Animal animal = new Cat(); //原来的animal的运行类型是Cat对象，所以可以在下面强转为Cat类型
Cat cat = (Cat) animal;//强转父类引用为为子类 这样就可以调用子类的特有成员方法
}
5.注意事项和细节
1.属性没有重写直说，属性的值看编译类型
class Base
{
int money = 10;
}
class Sub extends Base
{
int money = 20;
}
main()
{
Base base = new Base();
base.money;//10
Sub sub = new Sub();
sub.money;//20
}
2.instanceof 比较操作符，用于判断对象的运行类型是否为XX类型或XX类型的子类型
class AA{}//父类
class BB extends AA{}//子类
main()
{
BB bb = new BB();
System.out.println(bb instanceof BB);//bb是不是BB的类型，返回结果为boolean值
System.out.println(bb instanceof AA);
//aa 编译类型 AA，运行类型BB
AA aa = new BB();
System.out.println(aa instanceof AA);//true
System.out.println(aa instanceof BB);//true
}
6.动态绑定机制
1.当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定
2.当调用对象属性时，没有动态绑定机制，哪里声明(函数里面的成员属性为函数所在类下的成员属性)，哪里使用
class A
{
public int i = 10;
public int sum()
{
return getI() + 10;
}
public int sum1()
{
return i +10;
}
public int getI()
{
return i;
}
}
class B extends A
{
public int i =20;
public int sum()
{
return i +20;
}
public int getI()
{
return i;
}
public int sum1()
{
return i +10;
}
}
main()
{
A a = new B();//向上转型
System.out.println(a.sum());//40
System.out.println(a.sum1());//30
}
7.多态的应用
1.多态数组
*数组的定义类型为父类类型，里面保存的实际元素类型为子类类型
class Teacher extends Person
{
String name;
int salary;
public void say(){}
public void teach(){}
}
class Student extends Person
{
String name;
int score;
public void say(){}
public void study(){}
}
class Person
{
public void say(){}
}
main()
{
Person[] persons = new Person[5];
persons[0] = new Person("jack", 20);
persons[1] = new Student("jack",18,100);
persons[2] = new Teach("scott" ,30 ,20000);
for(int i = 0;i<3;i++)
{
System.out.println(persons[i].say());//动态板顶机制
if(persons[i] instancof Student)
{
Student student = (Student)persons[i];//向下转型
student.study();
}else if(persons[i] instanceof Teacher)
{
Teacher teacher = (Teacher)persons[i];
teacher.teach();
} else
{
System.out.println("你的类型有误，请自己检查...")
}
}
}
2.多态参数
*方法定义的形参类型为父类类型，实参类型允许为子类类型
1.6 Object类
1.equals方法
* == 是一个比较运算符
1.==：既可以判断基本类型，又可以判断引用类型
2.==：如果判断基本类型，判断的是值是否相等
3.==：如果判断引用类型，判断的是地址是否相等，即判定是不是同一个对象
4.equals：是Object类的方法，只能判断引用类型
5.默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等。比如Integer，String
2.重写equals方法
class Person
{
private String name;
private int age;
private char gender;
//重写Object的equals方法
public boolean equals(Object obj)
{
if(this == obj)
{
return true;
}
}
//类型判断
if(obj instanceof Person)
{
//是Person,我们才比较
Person p = (Person)obj;
return this.name.equals(p.name) && this.age == p.age && this.gender == p.gender;
}
//如果不是Person类型，则直接返回false
return false;
}
1.7 hashCode
*hashCode返回该对象的哈希码值
*总结：
1.提高具有哈希结构的容器的效率
2.两个引用，如果指向的是同一个对象，则哈希值肯定是一样的
3.两个引用，如果指向的是不同对象，则哈希值是不一样的
4.哈希值主要根据地址号来的，不能完全将哈希值等价于地址
1.8 toString
*返回该对象的字符串表示
*基本介绍
1.默认返回：全类名(包名 + 类名) + @ + 哈希值的十六进制
2.当直接输出一个对象时，toString会被默认调用
System.out.println(monster);
System.out.println(monster.toString());
//这两个是等价的
1.9 finalize
1.当对象被回收时，系统自动调用该对象的finalize方法，子类可以重写该方法，做一些释放资源的操作
2.什么时候被回收：当某个对象没有任何引用时，则jvm就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁对象前，会先调用finalize方法
3.垃圾回收机制的调用，是由系统来决定，也可以通过System.gc()主动触发垃圾回收机制
main()
{
Car bmw = new("宝马");
bmw = null;
System.gc(); //主动调用垃圾回收器
}
1.10 断点调试(debug)
1.在开发中，新手程序员在查找错误时，这时老程序员就会温馨提示，可以用断点调试，一步一步的看原码执行的过程，发现错误
2.在断点调试过程中，是运行状态，是以对象的运行类型来执行的
1.断点调试介绍
1.断点调试是指在程序的某一行设置一个断点，调试时，程序运行到这一行就会停住，然后可以一步一步往下调试，调试过程中可以看各个变量当前的值
2.断点调试的快捷键
F7(跳入) ：跳入方法内
F8(跳过) ：逐行执行代码
shift + F8(跳出)
F9(resume,执行到下一个断点)
