/**
* 父类
*/
public class SuperClass {
public void method1(){
System.out.println("父类的成员方法");
}
public void method2(){
System.out.println("父类特有,子类没有");
}
}
/**
* 子类
*/
public class SubClass extends SuperClass{
@Override
public void method1() {
System.out.println("子类重写的父类的方法");
}
}
/**
* 多态:一种事物多种形态,即父类引用指向子类对象
* 格式:
* 父类名称 对象名 = new 子类名称();
* 接口名称 变量名 = new 实现类名();
*/
public class TestPolymorphic {
public static void main(String[] args) {
//格式:父类类型 变量名称 = new 子类类名();
//多态:父类引用指向子类对象
SuperClass superClass = new SubClass();
//调用方法
superClass.method1();//编译是看左面,运行是看右面,右面没有,向上一级找到
superClass.method2();//先找子类,子类没有,再找父类
}
}
public class Father {
int num = 200;
public void getVariable(){
System.out.println(num);
}
}
public class Son extends Father{
int num = 100;
}
/**
* 多态访问成员变量:编译运行全部看等号左边
* 1、直接通过对象名称访问成员变量
* 2、通过成员方法获取变量
*/
public class TestVariable {
public static void main(String[] args) {
//多态写法
Father father = new Son();
//方式一:直接通过对象访问变量
System.out.println(father.num);//200 访问的是父类的变量
System.out.println("----------------------");
//方式二:通过成员方法访问变量
Father father1 = new Son();
father.getVariable();//200 编译看左边,运行看右边,子类没有,再找父类
}
}
public class Father {
int num = 10;
public void smoking(){
System.out.println("父类特有的方法");
}
public void showNum(){
System.out.println("父类的成员变量是:"+num);
}
}
public class Son extends Father{
int num = 20;
public void code(){
System.out.println("儿子在写代码");
}
@Override
public void showNum(){
System.out.println("儿子的成员变量是:"+num);
}
}
/**
* 多态访问成员方法:编译时看左边,运行时看右边,子类没有,再向上找
*/
public class TestMethod {
public static void main(String[] args) {
//多态:父类引用指向子类对象
Father father = new Son();
//调用成员方法
father.smoking();//父子都有,找子类
father.showNum();//子类没有。看父类,向上找
//father.code();//错误写法,编译不通过,父类中没有此方法
}
}
//父类
public abstract class Animal {
//定义抽象方法
public abstract void eat();
}
//子类
public class Cat extends Animal{
@Override
public void eat() {
System.out.println("猫吃老鼠");
}
//子类特有方法
public void snoring(){
System.out.println("猫睡觉打呼噜");
}
}
/**
* 对象的向上造型:父类引用指向子类对象
* 格式:父类名称 对象名称 = new 子类名称();
* 对象的向下造型:将父类对象还原成本身的子类对象,必须基于向上造型的基础上
* 格式:子类类型 对象名称 = (子类类型) 父类对象名称;
*/
public class TestDemo {
public static void main(String[] args) {
//向上造型
Animal animal = new Cat();
//调用方法
animal.eat();
//调用子类特有方法
//animal.snoring();//编译错误,向上转型无法调用子类特有的方法
//向下造型
Cat cat = (Cat) animal;
//调用特有的方法
cat.snoring();
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-l8YaTOW2-1686205786303)(photo/JavaSE10_面向对象之多态.assest/1664986523114.png)]
public abstract class Animal {
public abstract void eat();
}
public class Cat extends Animal{
@Override
public void eat() {
System.out.println("猫咪爱吃鱼");
}
}
public class Dog extends Animal{
@Override
public void eat() {
System.out.println("大黄狗吃骨头");
}
}
/**
* 判断父类引用指向的子类对象的类型
* 格式:对象名 instanceof 类型
* 注意:结果是一个boolean值,判断等号左边的对象是否可以作为等号右边对象类型的一个实例
*/
public class TestInstanceof {
public static void main(String[] args) {
//向上造型
Animal animal = new Cat();
animal.eat();
System.out.println("-------------------");
//向下造型,先判断
if (animal instanceof Dog){//判断一下父类引用本类是否是Dog
Dog dog = (Dog) animal;
dog.eat();
}
else if (animal instanceof Cat){//判断一下父类引用本类是否是Cat
Cat cat = (Cat) animal;
cat.eat();
}else {
System.out.println("两者都不是");
}
}
}
/**
* 向下造型异常
*/
public class TestEception {
public static void main(String[] args) {
//向上造型
Animal animal = new Cat();
animal.eat();
//向下造型
Dog dog = (Dog) animal;
dog.eat();
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-x1X4dUpu-1686205786304)(photo/JavaSE10_面向对象之多态.assest/1664987535979.png)]