Java初学—多态的理解

最新推荐文章于 2022-04-16 16:26:21 发布
最新推荐文章于 2022-04-16 16:26:21 发布
阅读量126 收藏
点赞数
分类专栏： java学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JYB150740115/article/details/107730676
版权

面向对象三大概述: 封装性、继承性、多态性

extends继承或者implements实现，是多态的前提
1.多态的格式和使用

/**
 * 代码当中体现多态性，其实就是一句话，父类引用指向子类对象
 * 格式:
 * 父类名称 对象名 = new 子类名称();
 * 或者:
 * 接口名称 对象名 = new 实现类名称();
 */

案例:

public class Fu {
    public void method(){
        System.out.println("父类方法");
    }

    public void methodFu(){
        System.out.println("父类特有");
    }
}
public class Zi extends Fu{
    @Override
    public void method() {
        System.out.println("子类方法");
    }
}

public class Demo01Multi {
    public static void main(String[] args) {
        Fu obj = new Zi();

        obj.method();
        obj.methodFu();

    }
}

2.多态中成员变量的使用特点
访问成员变量的方式:
1.直接通过对象名称访问成员变量,看等号左边是谁，优先用谁，没有则向上找
2.间接通过成员方法访问成员变量,看方法属于谁，优先用谁，没有则向上找
案例:

public class Demo01MultiField {
    public static void main(String[] args) {
        Fu obj = new Zi();
        System.out.println(obj.num); //10;
        //System.out.println(obj.age); //错误写法
        System.out.println("========");
        //子类没有覆盖重写，就是父，10
        //子类如果覆盖重写，就是子,20
        obj.showNum();
    }
}

public class Zi extends Fu{
    int num = 20;

    int age = 16;

    @Override
    public void showNum(){
        System.out.println(num);
    }
}

public class Fu {
    int num = 10;

    public void showNum(){
        System.out.println(num);
    }
}

3.多态中成员方法的使用特点
在多态代码中，成员方法的访问规则是:
看new 的是谁，就使用谁，没有则向上找

成员变量:编译运行看左
成员方法:编译看左边，运行看右边

案例:

public class Demo02MultiMethod {
    public static void main(String[] args) {
        Fu obj = new Zi();//多态
        obj.method();//父子都有，优先用子
        obj.methodFu();//子类没有，父类有，向上找到父类

        //obj.methodZi();//错误写法
    }
}

public class Zi extends Fu{
    int num = 20;

    int age = 16;

    @Override
    public void showNum(){
        System.out.println(num);
    }

    @Override
    public void method(){
        System.out.println("子类方法");
    }

    public void methodZi(){
        System.out.println("子类特有");
    }
}

public class Fu {
    int num = 10;

    public void showNum(){
        System.out.println(num);
    }

    public void method(){
        System.out.println("父类方法");
    }

    public void methodFu(){
        System.out.println("父类特有");
    }
}

4.对象的向上转型
对象的向上转型:(其实就是多态的写法)

格式:

父类名称 对象名 = new 子类名称();
含义:左侧创建一个子类对象，把它当做父类来看待和使用。

注意事项: 向上转型一定是安全的，从小范围转向大范围。

案例:

public abstract class Animal {
    public abstract void eat();
}

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

public class Demo01Main {
    public static void main(String[] args) {
        Animal animal = new Cat();
        animal.eat();
    }
}

5.对象的向下转型
对象的向下转型，其实是一个还原的动作.

格式:

子类名称 对象名 = （子类对象）父类对象
含义:将父类对象，还原成本来的子类对象

案例:

public abstract class Animal {
    public abstract void eat();
}

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}

public class Dog extends Animal{
    @Override
    public void eat(){
        System.out.println("狗吃shit");
    }

    public void watchHouse(){
        System.out.println("狗看家");
    }
}

public class Demo01Main {
    public static void main(String[] args) {
        Animal animal = new Cat();
        animal.eat();
        //animal.catchMouse();

        Cat cat = (Cat) animal;
        cat.catchMouse();

        //错误的向下转型---java.lang.ClassCastException类装换异常
        //Dog dog = (Dog) animal;


    }
}

public class Demo01Main {
    public static void main(String[] args) {
        Animal animal = new Cat();
        animal.eat();
        //animal.catchMouse();

        Cat cat = (Cat) animal;
        cat.catchMouse();

        //错误的向下转型---java.lang.ClassCastException类装换异常
        //Dog dog = (Dog) animal;


    }
}

6.用instanceof关键字进行类型判断
如何才能知道一个父类引用的对象，本来是什么子类？

格式

对象 instanceof 类名称
这将会得到一个boolean值的结果，也就是判断前面对象能不能当成后面类型的实例

案例:

public abstract class Animal {
    public abstract void eat();
}

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}

public class Dog extends Animal{
    @Override
    public void eat(){
        System.out.println("狗吃shit");
    }

    public void watchHouse(){
        System.out.println("狗看家");
    }
}

public class Demo01Main {
    public static void main(String[] args) {
        Animal animal = new Cat();
        animal.eat();
        //animal.catchMouse();


//        Cat cat = (Cat) animal;
//        cat.catchMouse();

        //错误的向下转型---java.lang.ClassCastException类装换异常
        //Dog dog = (Dog) animal;

        if(animal instanceof Dog){
            Dog dog = (Dog) animal;
            dog.watchHouse();
        }

        if(animal instanceof Cat){
            Cat cat = (Cat) animal;
            cat.catchMouse();
        }

        giveMeAnimal(new Dog());

    }

    public static void giveMeAnimal(Animal animal){
        if(animal instanceof Dog){
            Dog dog = (Dog) animal;
            dog.watchHouse();
        }

        if(animal instanceof Cat){
            Cat cat = (Cat) animal;
            cat.catchMouse();
        }
    }
}

7.多态练习

public interface USB {
    public abstract  void open(); //打开设备
    public abstract  void close();//关闭设备
}

public class Mouse implements USB{
    @Override
    public void open() {
        System.out.println("打开鼠标");
    }

    @Override
    public void close() {
        System.out.println("关闭鼠标");
    }

    public void click(){
        System.out.println("键盘点击");
    }
}

public class Keyboard implements USB{
    @Override
    public void open() {
        System.out.println("打开键盘");
    }

    @Override
    public void close() {
        System.out.println("关闭键盘");
    }

    public void type(){
        System.out.println("键盘输入");
    }
}

public class Computer {
    public void powerOn(){
        System.out.println("笔记本电脑开机");
    }

    public void powerOff(){
        System.out.println("笔记本电脑关机");
    }


    public void useDevice(USB usb){
        usb.open();//打开设备
        if(usb instanceof Mouse){
            Mouse mouse  = (Mouse) usb;
            mouse.click();
        }else if(usb instanceof Keyboard){
            Keyboard keyboard = (Keyboard) usb;
            keyboard.type();
        }
        usb.close();//关闭设备
    }


}

public class DemoMain {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.powerOn();

        USB mouse = new Mouse();
        computer.useDevice(mouse);

       Keyboard keyboard = new Keyboard();
       computer.useDevice(keyboard);//正确写法


        computer.powerOff();
    }
}
贝贝小菜鸟
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第8章 面向对象编程
今天的你也辛苦啦！
11-22 595
1. 包 包 (package) 是组织类的一种方式； 使用包的主要目的是保证类的 唯一性； 例如，你在代码中写了一个 Test 类，然后你的同事也可能写一个 Test 类，如果出现两个同名的类，就会冲突，导致代码不能编译通过。 1.1 导入包中的类 Java 中已经提供了很多现成的类供我们使用，例如 public class Test { public static void main(String[] args) { java.util.Date date = new jav
Java中内部类的使用方法
m0_37134868的博客
09-01 1238
首先创建两个类，Animal、Demo类： Animal： public class Animal { private int num=9; public class Inner{ //内部类 public void show(){ //内部中show方法 System.out.println(num); } } public void method(){ //Animal类调用show()方法
JAVA学习之面向对象
m0_55202345的博客
04-16 613
Java面向对象
java方向每日一题（错题）1
mawenzhe96的博客
04-28 969
1.有以下类定义： abstract class Animal{ abstract void say(); } public class Cat extends Animal{ public Cat(){ System.out.printf("I am a cat"); } public static void main(String[] args) { Cat cat=new Cat(); } } A. Animal不能编
Java关于多态，抽象和接口的几道题目
weixin_45523449的博客
04-14 437
1…如下代码,编译能通过吗,为什么? class Foo { int value; public void f() { } } class Goo extends Foo { int num; public Goo(int value, int num) { this.value = value; this.num = num; } public void g() { } } public class TestFoo { public static void main(Str
Java初学者实例源码
05-30
"Java初学者实例源码"是一个集合，旨在帮助初学者逐步理解并实践Java的各种功能和编程技巧。这个压缩包文件包含了一系列的Java源代码示例，涵盖了基础到进阶的多个主题。 1. **基础语法**：Java的基础语法包括变量...
java_program_111.rar_J2EE_java 初学者
09-24
对于Java初学者，建议从基础语法开始学习，如变量、控制流、类和对象等。理解面向对象编程的基本概念，如封装、继承和多态，是掌握Java的关键。之后，可以深入学习J2EE相关技术，例如Servlets和JSP，通过实际项目...
理解java中的多态
10-23
对多态做了详细的介绍，比较深入浅出，容易理解，适合初学者阅读
Java语言初学者教程集锦
最新发布
06-23
3. **类与对象**：深入理解面向对象编程（OOP）的概念，包括类的定义、对象的创建、封装、继承和多态。 4. **数组与集合**：学习如何使用一维和多维数组，以及ArrayList、LinkedList、HashSet、HashMap等集合框架的...
JAVA初学者教程.zip
10-31
本教程“JAVA初学者教程.zip”旨在帮助新接触Java的人快速入门，了解并掌握这个强大而灵活的语言。 Java工具包（Java Development Kit, JDK）是学习和开发Java程序的基础。它包含了Java编译器（javac）、解释器...
Java基础之多态
IDYS'BLOG
04-15 269
文章目录多态多态的格式与使用演示多态当中成员变量的使用特点演示成员方法使用特点演示向上转型与向下转型演示instanceof 关键字演示例题写在最后的话： 这里是一段防爬虫文本，请读者忽略。 本文原创首发于CSDN，作者IDYS 博客首页：https://blog.csdn.net/weixin_41633902/ 本文链接：https://blog.csdn.net/weixin_41633902/article/details/115741531 未经授权，禁止转载！恶意转载，后果自负！尊重原创，远离
猫和狗类（继承、多态、抽象、接口）
meini32的博客
01-12 2315
//需求：采用继承的思想实现猫和狗的案例 1.猫： 成员变量：姓名，年龄 构造方法：无参，带参 成员方法：get/set方法，抓老鼠 2.狗： 成员变量：姓名，年龄 构造方法：无参，带参 成员方法：get/set方法，看门 3.共性： 成员变量：姓名，年龄 构造方法：无参，带参 成员方法：get/set方法 具体代码： 猫类： package Animal; public class Cat extends Common{ //猫类 public Cat() {
面向对象编程
weixin_45409986的博客
11-15 211
包 组织类的一种方式（就是一个文件夹） · 在DOWS框里编译运行包里的TestDemo1 编译程序目录分割用\（如：javac com\bit\TestDemo1.java） 运行程序目录分割用.（如：java com.bit.TestDemo1.java） · 我的TestDemo1在E:\decode\com\bit\TestDemo1里 要在decode目录下编译运行TestDemo1 ...
Java中的接口实现
柯基的博客
09-15 376
接口最能体现面向对象精髓->对对象的抽象，接口是一种规范，定义的是一组规则。 实例： 接口中的所有方法都是抽象的： public interface UserService { void add(); void delete(); void update(); void query(); } 实现接口的类用implements，实现了接口的类就必须重写接口中的方法： public class UserServiceImp implements UserServ
day11-多态&抽象类&接口
at10090的博客
06-24 285
1.多态 1.1多态的概述（记忆） 什么是多态 ​ 同一个对象，在不同时刻表现出来的不同形态 多态的前提 要有继承或实现关系 要有方法的重写 要有父类引用指向子类对象 1.2多态中的成员访问特点（记忆） 成员访问特点 成员变量 ​ 编译看父类，运行看父类 成员方法 ​ 编译看父类，运行看子类 代码演示 动物类 public class Animal { ...
JAVA学习第二阶段Day2
alexone51223的博客
12-11 174
JAVA学习第二阶段 day2 1.多态 同一个对象，在不同时刻表现出来的不同形态 范例：animal = new Cat(); 多态的前提：有继承/实现关系 有方法重写 有父类引用指向子类对象 public class Animal { public void eat() { System.out.println("动物吃东西") } } public class Cat extends Animal { @Override public void e
java public main_JAVA：public static void main(String args[]) 详解
weixin_36216860的博客
02-12 5752
JAVA中的主函数，所有java程序的运行起点就是这个方法，除了args这个名字可以不一样外，其他必须是这样。主函数的一般写法如下：public static void main(String[] args){…}(1)public关键字，这个好理解，声明主函数为public就是告诉其他的类可以访问这个函数。(2)static关键字，告知编译器main函数是一个静态函数。也就是说main函数中的代...
匿名内部类
全村的希望的博客
12-04 327
匿名内部类一般用于比较简单，且仅在声明处使用一次的次，使用匿名类可以使代码更加简洁，又可以避免类名冲突。在你阅读Android代码中经常遇到，匿名类是基础中的基础，因此，很有必要掌握它。 形式为： new 实现方式： 1、继承一个类，重写其方法。 2、实现一个或者多个接口。 实例1:不使用匿名内部类来实现抽象方法 abstract class Anima

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值