1. 引用数据类型的类型转换
引用数据类型转换的前提是：转换的两个对象之间必须存在继承或者实现关系
引用数据类型的转换就是一般与特殊之间的转换
1.1 上溯造型（子类对象自动转换成父类对象）
燕子类是特殊的，是子类；鸟类是一般的，是父类。
逻辑上“将燕子类看做成鸟类”是说得通，可以理解为“将子类看做成父类”。
Parent p; //父类对象
Child c = new Child(); //子类对象
p = c; //上溯造型
可以简写为
Parent p = new Child();
子类对象转换成父类对象后，会丢失自己特有的属性和行为。
燕子被看做成鸟类之后，不再具有燕子的特征。
鸟类
public class Bird {
public String name;
public void eat() {
System.out.println(name+"正在吃");
}
}
燕子类
public class Swallow extends Bird{
public void fly() {
System.out.println(name+"正在飞");
}
}
测试类
public class Test {
public static void main(String[] args) {
Swallow s = new Swallow();
s.name="燕子";
s.eat();
s.fly();
System.out.println("======================");
Bird b = new Swallow();
b.name = "燕子";
b.eat();
//b.fly(); //将燕子当做鸟看待，丢失燕子的特性
}
}
1.2 下溯造型（父类对象强制转换成子类对象）
下溯造型成功的前提：父类对象必须经过该子类的上溯造型后，再进行下溯造型才能成功。
- Swallow -> Bird -> Swallow OK
- Bird -> Swallow NG
- Swallow -> Bird -> Other NG
下溯造型的示例，可以看出，只有new的是Cat时，才能转成Cat。不能转成其他。（new的是哪个类就能转换成哪个类的对象）
public class Test {
public static void main(String[] args) {
Animal a = new Cat(); //上溯造型
Cat c = (Cat) a;//下溯造型
c.climb(); //下溯造型成功
System.out.println("===========");
Animal x = new Cat(); //上溯造型
Dog d = (Dog) a;//下溯造型
d.swim(); //下溯造型失败
System.out.println("===========");
Animal z = new Animal();//普通动物
Cat y = (Cat) z;//下溯造型
y.climb();//下溯造型失败
}
}
类型转换异常
上下溯造型的内存理解
顺着句柄的方向能够访问到类型即可转换成功，否则转换失败
内存理解
2. 重载
重载也被为overload，编译时多态。
重载体现现实世界中，某个事物在某个行为上有多种表现形式。比如：麻雀既吃粮食也吃害虫。
体现在编程上某个类中的同名方法名出现多次。
重载的要求：
- 方法名必须一致
- 参数列表必须不一致
(1)参数个数不同
public void eat() {}
public void eat(int a) {}
(2)参数类型不同
public void eat(int a) {}
public void eat(String a) {}
(3)参数类型顺序不同
public void eat(int a, String b) {}
public void eat(String a, int b) {}
- 与返回值类型无关
重载有关笔试题：
已知某个类中定义了public void display()方法，以下哪个方法不能存在在该类中
- public int display(int a) OK
- public int display() NG
- public double displya() OK (方法名不一致，正常定义方法)
- public void display(int a, String b) OK
- public void display(String a) OK
3. 重写（覆盖）
重写也被为override，运行时多态。
重写体现现实世界中，子类和父类在某个行为上有不同表现形式，不同子类之间有不同表现形式。比如：鸟类在吃的行为可以认为是杂食的，老鹰这类鸟吃肉，蜂鸟吃蜂蜜。
体现在编程上子类改写（覆盖）父类同名，同参数，同返回值类型方法的行为，子类方法的访问权限必须大于等于父类方法的访问权限。
重写的要求：
- 必须发生在继承或实现关系中
- 子类方法的方法名必须与父类方法的方法名一致
- 子类方法的参数列表必须与父类方法的参数列表一致
- 子类方法的返回值类型必须与父类方法的返回值一致
- 子类方法的访问权限必须不低于父类方法的访问权限
鸟类
public class Bird {
public void eat() {
System.out.println("父类:鸟类可以吃任何东西");
}
}
麻雀类
public class Sparrow extends Bird{
@Override
public void eat() {
System.out.println("子类：麻雀吃东西");
}
}
测试类
public class Test {
public static void main(String[] args) {
Bird b = new Bird();
b.eat();
Sparrow s = new Sparrow();
s.eat(); //子类方法覆盖掉父类方法，结果显示子类内容
}
}
经典笔面试题1：重载与重写的区别？
重载：同一个类，方法名同名不同参，与返回值无关
重写：继承关系中，子类改写父类同名同参同返回值类型，访问权限大于等于父类
经典笔面试题2：已知某个父类中定义了public void display()方法，以下哪个方法不能存在在该类的子类中
(1) public void display() OK 重写
(2) public void display(int a) OK 重载（从父类继承了public void display()方法）
(3) public int display(int a) OK 重载
(4) public int display() NG 重名了但既不是重写也不是重载
(5) public int displya() OK 不重名
4. 多态的形成
多态：同一个行为在类自身中有多种表现形式，或者在继承关系中，子类与父类表现的不一致。
- 重载
编译时多态 - 重写
运行时多态
(1)继承或实现关系
(2)重写
(3)上溯造型（父类的引用，子类的实例化）
多态的内存理解
动物类
public class Animal {
public void sound() {
System.out.println("动物会叫");
}
}
猫类
ublic class Cat extends Animal{
@Override
public void sound() {
System.out.println("猫：喵喵");
}
}
测试类
public class Test {
public static void main(String[] args) {
Animal a = new Cat();
a.sound(); //执行的Cat类中sound方法
}
}
笔试和面试题一般都会与多态相关的问题。
public class Parent{
public void haha(){
System.out.println("Parent Method Invoke");
}
}
public class Child extends Parent{
public void haha(){
System.out.println("Child Method Invoke");
}
}
public class Test{
public void static main(String[] args){
Parent p = new Child();
p.haha();
}
}
运行答案：Child Method Invoke
网友评论