方法重写
方法重写介绍
- 可以在父类和子类中写参数列表、方法名称完全一样的方法。
- 需要注意子类的返回类型要和父类的返回类型一致，或者子类的返回类型比父类的返回类型要小。
- 子类方法不能缩小父类方法的访问权限。public -> protected -> 默认 -> private
方法重写与方法重载的区别
- 作用范围：方法重写在父子类中的两个方法。而方法重载是本类中的两个方法。
- 方法名：重写和重载的方法名都必须相同。
- 形参：方法重写的形参必须一模一样。而方法重载的形参必须在个数、类型、顺序中至少有一个不一样。
- 返回类型：方法重写的返回类型必须和父类的返回类型一致或者是父类的子类。方法重写的返回类型没有要求。
- 修饰符：方法重写的修饰符在子类中不能缩小父类的访问权限。
多态
为什么使用多态，有什么作用？
- 因为使用传统的方法代码复用性不高，并且不方便维护。而多态可以解决这个问题。
多态的基本介绍
- 方法或对象具有多种形态。是面向对象的第三大特征，多态是建立在封装和继承的基础上的。
- 多态的具体体现：
- 方法的多态体现在方法的重载和重写。
- 对象的多态（重点）：
- 可以把一个父类的引用赋给子类的对象。例如
Animal animal = new Dog();。其中Animal为编译类型，Dog为运行类型。 - 一个对象的编译类型和运行类型可以不一致。
- 编译类型在创建对象时就已经确定了，不能改变。
- 运行类型可以变化。例如
animal = new Cat();，就把运行类型从Dog变为了Cat。 - 创建对象时 = 号左边的是编译类型。 = 号右边的是运行类型。
多态的例子
- 在使用多态前：
public void feed(dog,bone){
System.out.println("主人" + name + "给"+ dog.getName() + "喂" + bone.getName());
}
主函数：
Master luo = new Master("luo");
Dog dog = new Dog("tom");
Bone bone = new Bone("骨头");
luo.feed(dog,bone);
这一个feed函数输出的是一个动物和一个食物，如果有很多动物和食物的话，就需要写很多个feed函数，导致代码复用性不高。
- 多态可以将父类的引用赋给子类的对象。Animal是父类，dog,cat是其子类，Food是父类，bone,fish是子类。我们便可以将feed函数的形参改为父类的引用，在使用feed函数时传入父类的子类对象，因为animal是编译类型，子类的dog是运行类型（实际运行的），所以在feed函数中运行的实际上是传入的子类对象。这样就可以只写一个feed函数，而传入的子类可以有很多种，提高了代码的复用性。
public void feed(Animal animal,Food food){
System.out.println("主人" + name + "给"+ animal.getName() + "喂" + food.getName());
}
Master luo = new Master("luo");
Dog dog = new Dog("tom");
Bone bone = new Bone("骨头");
luo.feed(dog,bone);
以上两种运行结果相同。
- 再看下面例子：
父类
public class Father {
private String name;
private int age;
public void eat() {
System.out.println("父类的eat");
}
public void show() {
System.out.println("父类的show");
}
}
子类：
public class Son extends Father{
public Son() {
}
public void eat(){
System.out.println("子类的eat");
}
public void show1(){
System.out.println("子类特有的show");
}
}
Main函数：
public class Main_ {
public static void main(String[] args) {
Father father = new Son(); //father为编译类型，son为运行类型,如果编译类型换为Object也可以
father.show();
}
}
- father这个引用可以调用父类的所有成员（需要注意访问权限），不能调用子类的特有成员，因为编译类型为父类。
- 如果子类中有和父类同名的成员时，father可以调用子类的同名成员，并且会优先调用，因为继承的本质会从子类由上查找。
Father father = new Son();这种将父类的引用指向子类的对象时，叫做向上转型。- 向下转型：
Father father = new Son();
Son son = (Son) father; //这一步是向下转型
son.show1(); //son的特有方法
向下转型就是将已经向上转型的Son对象转回来，son引用重新指向Son对象，这样就可以访问到子类的特有成员了。
- 需要注意的是只能转为原来的子类对象，并且编译类型也只能是原来指向的对象，不能是其他的对象了。
多态的注意事项
- 属性没有重写之说。属性直接看编译类型。
instanceof比较操作符，用于判断对象的运行类型是否为该类型或者该类型的子类。输出结果为true或false。
public class Test {
public static void main(String[] args) {
AA aa = new BB();
System.out.println(aa instanceof BB); //输出为true
}
}
class AA{}
class BB extends AA{}
Java动态绑定机制
- 当调用对象方法时，该方法会和对象的内存地址、运行类型绑定。
- 当调用对象属性时，没有绑定机制，哪里声明就调用谁。
多态的应用
多态数组
- define: 数组的定义类型是父类类型，里面保存的元素类型为子类类型。
public class PolyArray_ {
public static void main(String[] args) {
Person[] person = new Person[3];
person[0] = new Person("qqq",10);
person[1] = new Student("ww", 20, 100);
person[2] = new Teacher("eee",30,20000);
for (int i = 0; i < person.length; i++) {
System.out.println(person[i].say());
if (person[i] instanceof Student) { //判断person[i]的运行类型是否为Student,以此可以调用Student里的特有方法
((Student)person[i]).listen();
} else if (person[i] instanceof Teacher) {
((Teacher)person[i]).teach();
} else if (person[i] instanceof Person) {
System.out.println("此为Person类型");
}else {
System.out.println("你的类型有误");
}
}
}
}
这样就可实现使用同一个方法调用两个不同的对象。并可以加以判断。
Object类
equals方法
- == 与equals的对比；
- ==是一个比较运算符：
- 既可以判断基本类型，也可以判断引用类型。
- 判断基本类型，判断的是值是否相等。例如int i = 10; double d = 10.0;
- 如果判断引用类型，判断的是地址是否相等，即判定是不是同一个对象。
- equals是判断值是否相等。
如何看JDK源码
- 选中方法ctrl + B;
重写equals方法
- 例如判断两个Person对象的内容是否相等，如果两个Person对象的属性值都相等，则返回true，否则返回false。
- 因为equals判断的是两个值是否相等，假如person1.equals(person2)，person1和person2是两个不同的对象，肯定返回的是false，如果要实现要求，就可以重写equals方法。
public class Equals_ {
public static void main(String[] args) {
Person person1 = new Person("jack", 20, 'k');
Person person2 = new Person("jack", 20, 'k');
System.out.println(person1.equals(person2));
}
}
class Person {
private String name;
private int age;
private char gender;
public boolean equals(Object obj) {
//如果比较的两个对象是同一个对象，直接返回ture
if (this == obj){
return true;
}
//如果不同，则想判断obj是否为person，如果是，再比较属性
if (obj instanceof Person) {
Person person = (Person) obj; //因为obj起先为object类型，是Person的父类。向下转型，为了获取obj的属性
return this.name.equals(person.name) && this.age == person.age && this.gender == person.gender;
}
return false;
}
public Person(String name, int age, char gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
}
hashcode方法
- 返回该对象的哈希码值。
- 作用：
- 提高具有哈希结构的容器的效率。
- 两个引用，如果指向同一个对象，则哈希码值一定相等。如果是指向两个不同的对象，则哈希码值不相等（也有概率相等）。
- 哈希值主要是根据地址来的，但不等同于哈希值。
- 获取哈希码值:
对象.hashcode();
toString方法
- 当toString()方法未重写时，会调用jdk源码的toString方法，输出为该对象的包名、类名、转为16进制的哈希值。
- 重写后当直接输出对象时会默认调用toString方法，输出信息。
public class ToString_ {
public static void main(String[] args) {
Monster op = new Monster("op", 10);
//未重写toString方法时会出输出包名 + 类名 + 哈希值(转为16进制的)
//重写后会把对象的属性信息输出出来
System.out.println(op.toString());
}
}
class Monster {
private String name;
private int age;
public Monster(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Monster{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
finalize方法
- 当对象对回收时，系统自动调用该对象的finalize方法。子类可以重写该方法，做一些释放资源的操作（例如释放数据库的连接、打开的文件等）。
- 什么时候回回收：当某个对象没有任何引用时，该jvm就会认为该对象是个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象时，会先调用finalize方法。
- 例如
Person person = new Person();
person = null;
这时候，Person对象就没有引用指向它，此时就是一个垃圾对象。但是jvm并不会立即销毁，因为jvm有着自己的gc算法，但是我们可以调用System.gc()来主动调用finalize方法。
断点调试（debug）
- Define: 断点调试是指程序在某一行设置一个断点，调试时，程序运行到一行就会停住，然后一步一步往下调试，调试过程中可以看到各个变量当前的值。出错的话，调试到出错的代码行即显示错误，停下分析代码找到bug。
- 注意在断点调试过程中，是运行状态，是以对象的运行类型来执行的。
- 快捷键：F7：跳入方法内。F8：逐行执行代码。Shift + F8：跳出方法。F9：进入下一个断点。
- 实例1：
- 实例2：数组越界
在运行到arr[3]时，就报了一个数组越界的警告。说明在前面运行都没问题，运行到这一步时发生了错误，便可以分析时哪里错了。 - 实例3：追踪一个对象的创建过程：
-
- 加载类信息
-
- 初始化
- 2.1. 默认初始化，2.2. 显示初始化，2.3.构造器初始化
-
- 地址返回
-
什么时候可以直接调用方法，什么时候调用方法需要先创建对象？
- 调用一个类的静态方法时直接调用即可，不是静态方法就需要先创建对象，再调用对象的方法。
3244
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
