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;//10Sub 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，运行类型BBAA aa = new BB();System.out.println(aa instanceof AA);//trueSystem.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());//40System.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类型，则直接返回falsereturn 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,执行到下一个断点)