方法重写
1. 掌握方法重写
方法重写:在子类继承了父类的信息之后
(构造方法不能重写),如果有的方法不是太适合/强大,可以根据子类的需求进行方法的重新编写。
方法重写的规则(何种情况下 认定它为方法重写):
方法名相同、参数列表相同、返回值类型相同或者是其子类(多态)、访问修饰符不能严于父类,(不能抛出比父类更大和更多的异常)。
public class Pet{
public void show(){
syso(name);
syso(health);
syso(love);
}
}
// 子类重写父类的方法
public class Dog extends Pet{
// 访问修饰符不能严于父类
@Override // 检验是否是合格的方法重写
public void show(){
// 重写后的代码
}
}
当子类重写了父类的方法之后,执行此方法时,会执行子类重写后的方法。
疑问:
1.既然子类都要重新编写一次方法,何必在父类中提供此方法? (多态)
以目前的眼光:子类在重写方法时 还可以调用父类原有的代码内容。
// 子类重写方法时 如果是对原有方法进行添加额外功能 则可以利用父类中部分代码进行复用 (父类中的该方法留之有用)
// (了解)子类重写方法时 如果是对原有方法直接颠覆 那么父类中的该方法则失去了复用的价值 (你觉得该方法就可以删除了 但是我告诉你不能删!!!<多态>)
2. 掌握方法重写和重载的区别(面试题)
方法重写:在子类中,出现的和父类的方法名相同
,参数列表也相同,返回值类型相同或为其子类,访问权限修饰不能严于父类,不能抛出比父类更多更大的异常。
方法重载:在同一个类中,出现的方法名相同
,参数列表不同的情况。 与方法的返回值类型和访问修饰符无关。
Arrays.toString();
System.out.println();
public void method1(){
}
public int method1(int a){
}
3. 了解Object类
在Java中是单根继承的,它有且仅有一个父类。
Object类它是Java中最顶级的类,我们一般称它为超类
祖宗类
。所有的Java类一定是直接或者间接继承自Object
。
- 如果你定义一个类 它默认就继承了Object类
- 如果你单单定义了一个父类和子类, 子类继承自父类 父类继承自Object类
我们在以前调用方法时 应该见到了很多莫名其妙的方法,我们在学了继承之后知道,如果子类不定义方法,却还可以使用,说明此方法来自于他的父类。 我们见到的这些莫名其妙的方法就是继承自Object类。
快捷键:Ctrl+T 可以查看某个类的继承体系
Ctrl+O 可以查看某个类中的方法和属性
在Object中有一些经常被使用的方法:
boolean equals(Object obj); // 在判断字符串内容时
public boolean equals(Object obj) {
return (this == obj); // 利用 == 比较内容
}
String类对此方法进行了重写,所以才可以进行字符串内容的比较。
String toString(Object obj); // 在数组转换为数组内容字符串时
public String toString() {
// getClass().getName() 获取类名 类名@7831231 例如:Student@787822
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
重写equals方法
字符串比较内容。
// Eclipse快捷键 : 快速重写equals Alt+Shift + S -> h
// 重写了Object类中的equals方法
// stu1.equals(stu2)
// stu1:this
// stu2:obj
@Override
public boolean equals(Object obj) {
// 通过==比较两者 因为是引用数据类型 所以比较地址值 地址值相同是同一个对象
if (this == obj)
return true; // 同一个对象 内容一致
// 判断obj是否为空
if (obj == null)
return false; // stu1能直接调用方法说明stu1不为空 而stu2为null 两者肯定不相同
// 判断是否是相同类型
if (getClass() != obj.getClass())
return false; // 例如:狗对象和学生对象 肯定内容不一样 没必要比较
// 向下转型(强转) int num = (int)10.1;
// 将stu2转换为Student类型的对象
Student other = (Student) obj;
// 比较stu1的名字是否为空 this.name
if (name == null) {
// 如果为空 判断stu2的名字是否为空 如果stu2的名字不是null 则无需比较了
if (other.name != null)
return false;
// 如果name都不为空 那么通过字符串的equals方法来直接比较名字的内容是否相同
} else if (!name.equals(other.name))
return false; // 如果name不一样 其他属性不用再比了
// 比较学生编号 如果学生编号不一致 返回false
if (stuNo != other.stuNo)
return false;
// 如果最终走到这里 说明他们的两个属性内容确实完全一致 返回true
return true;
}
String字符串其实本质(底层)就是一个字符数组。
他重写equals()方法就是在比较字符数组的内容。
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = value.length;
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}
equals和==的区别
默认情况下 equals和==都是一样的。
但是String重写了equals方法,可以比较字符串的内容了。
== 它比较引用数据类型比较的是地址值。 stu2 == stu3(X)
== 它比较基本数据类型比较的是内容。 10 == 12(√)
**
2.继承
1. 理解继承的作用
继承是Java中实现代码重用的重要手段。
继承是面向对象的三大特性之一。
在两个类实现了继承之后,会产生子类和父类的概念,而子类可以拥有父类中的属性和方法,子类还可以对这些方法进行重写。(古代皇帝 继承了 皇位 可能会对原有的不太好的制度进行变更)
Java中继承是单根继承,一个类有且仅有一个亲爹。
2. 掌握继承的基本使用
-
将多个类(子类)抽取公共代码(属性、方法)到父类中。
子类 is a 父类
public class Pet{
// 公共代码
}
- 使用子类去继承父类,即可拥有父类中的公共代码
public class Dog extends Pet{
// 自己特有的
// 继承了父类中公共的
}
继承的注意事项
- 子类不是无限继承父类中的内容,它只能继承父类中非私有(非private修饰)的代码,也不能继承构造方法,也不能继承不同包中,默认修饰的内容。
只能继承父类中非私有(非private修饰)的代码:private修饰的内容是私有的,只能在本类中使用。(话糙理不糙:你爸爸的闺女 不是你的闺女 你是无法继承这关系)
不能继承构造方法:构造方法是用来初始化对象(对象创建),它是给父类创建对象用的。(话糙理不糙:生你爸爸的人 不能生你)
不能继承不同包中,默认修饰的内容。
修饰符\作用域 | 本类 | 同包 | 子类 | 任何地方(同一个项目) |
---|---|---|---|---|
private | √ | |||
默认的 | √ | √ | ||
protected | √ | √ | √ | |
public | √ | √ | √ | √ |
- 子类和父类之间要有is a的关系 不要学了继承 瞎用
3. 掌握super关键字的使用
类似于this,this表示当前类的某个对象,谁在调用谁就是当前对象,super表示当前类的父类的对象
。
this可以调用自己的属性(this.xx)、自己的方法(this.xxx())、自己的构造(this())。
super可以调用父类的属性(super.xxx)、父类的方法(super.xx())、父类的构造(super())。
this和super在构造中调用其他构造时,只能出现在有效代码的第一行。
子类继承父类之后,子类的构造方法中会自动添加父类构造的调用代码。
public Dog(){
super();
}
4. 继承之后 加载顺序
父类静态代码块 、 父类构造代码块 父类的构造方法 子类的静态代码块 子类的构造代码块 子类的构造方法
父类静态代码块 -> 子类的静态代码块 -> 【 父类的构造代码块 -> 父类的构造方法 -> 子类的构造代码块 -> 子类的构造方法 】