当前位置： 首页 > news >正文

面向对象之多态

news 来源：原创 2024/5/3 14:30:17

   多态：可以理解为事物存在的多种体现形态。

   例如：人：男人，女人；

           动物：猫，狗

           猫 x = new 猫();

           动物 x = new 猫();

   从以下几个方面介绍多态：

  1. 多态的体现——父类的引用指向了自己的子类对象。父类的引用也可以接收自己的子类对象
  2. 多态的前提——必须是类与类之间有关系，要么继承，要么实现。通常还有一个前提：存在覆盖
  3. 多态的好处——多态的出现大大的提高了程序的扩展性
  4. 多态的弊端——提高了扩展性，但是只能使用父类的引用访问父类中的成员，不能预先使用子类，因为那时子类还没存在
  5. 多态的应用
  6. 多态的出现在代码中的特点（多态使用的注意事项）

   以动物：猫，狗，猪为例说之

abstract class Animal {
    public abstract void eat();
}
class Cat extends Animal {
    public void eat() {
        System.out.println("吃鱼");
    }
    public void catchMouse() {
        System.out.println("抓老鼠");
    }
}
class Dog extends Animal {
    public void eat() {
        System.out.println("吃骨头");
    }
    public void KanJia() {
        System.out.println("看家");
    }
}
class Pig extends Animal {
    public void eat() {
        System.out.println("饲料");
    }
    public void gongDi() {
        System.out.println("拱地");
    }
}
//-----------------------------------------------------------
public class PolDemo {

    public static void main(String[] args) {
//        Cat c = new Cat();
//        c.eat();
//        
//        Dog d = new Dog();
//        d.eat();
//        Cat c = new Cat();
//        function(c);
//        
//        function(new Dog());
//        
//        function(new Pig());
        
//        Animal c = new Cat();
//        c.eat();
        
        Animal a = new Cat();//类型提升。向上转型
        a.eat();
        
        //如果想要调用猫的特有方法时，如何操作？
        //强制将父类的引用转成子类类型，向下转型
        Cat c = (Cat)a;
        c.catchMouse();
        
        /*
         * 千万不要出现这样的操作，就是将父类对象转成子类类型
         * 我们能转换的是父类引用指向了自己的子类对象时，该引用可以被提升，也可以被强制转换
         * 多态自始至终都是子类对象在做着变化
         * Animal a = new Animal();
         * Cat c = (Cat)a;
         * 
         */
//        function(new Cat());
//        function(new Dog());
//        function(new Pig());
        
    }
    
    public static void function(Animal a) { //Animal a = new Cat();
        a.eat();
//        a.catchMouse();
        /*if(a instanceof Animal) {
            System.out.println("hello");
        } else*/ if(a instanceof Cat) {
            Cat c = (Cat)a;
            c.catchMouse();
        } else if(a instanceof Dog) {
            Dog d = (Dog)a;
            d.KanJia();
        }
        
    }
    /*
    public static void function(Cat c) { //Cat c = new Cat();
        c.eat();
    }
    
    public static void function(Dog d) {
        d.eat();
    }
    
    public static void function(Pig p) {
        p.eat();
    }
    */
}

   以下例说明多态的应用：

   基础班学生：学习，睡觉

   高级班学生：学习，睡觉

   可以将这两类事物进行抽取。

   代码如下：

abstract class Student {
    public abstract void study();
    public void sleep() {
        System.out.println("躺着睡");
    }
}
//工具类
class DoStudent {
    public void doSomething(Student s) {
        s.study();
        s.sleep();
    }
}
//--------------------------------------------------------------
class BaseStudent extends Student {
    public void study() {
        System.out.println("base study");
    }
    public void sleep() {
        System.out.println("坐着睡");
    }
}
class AdvStudent extends Student {
    public void study() {
        System.out.println("adv study");
    }
}

public class DuoTaiDemo {

    public static void main(String[] args) {
        DoStudent ds = new DoStudent();
        ds.doSomething(new BaseStudent());
        ds.doSomething(new AdvStudent());
//        BaseStudent bs = new BaseStudent();
//        bs.study();
//        bs.sleep();
//        AdvStudent as = new AdvStudent();
//        as.study();
//        as.sleep();
    }
    
}

   以下例说明多态的出现在代码中的特点（多态使用的注意事项）

   在多态中成员函数(非静态)的特点：

  • 在编译时期：参阅引用型变量所属的类中是否有调用的方法，如果有，编译通过，如果没有编译失败。
  • 在运行时期：参阅对象所属的类中是否有调用的方法。

   简单总结就是：

  • 成员函数(非静态)在多态调用时，编译看左边，运行看右边。
  • 在多态中，成员变量的特点：无论编译和运行，都参考左边（引用型变量所属的类）
  • 在多态中，静态成员函数的特点：无论编译和运行，都参考左边。

   示例代码如下：

class Fu {
    
    int num = 5;
    
    void method1() {
        System.out.println("fu method_1");
    }
    void method2() {
        System.out.println("fu method_2");
    }
    static void method4() {
        System.out.println("fu method_4");
    }
}
class Zi extends Fu {
    
    int num = 8;
    
    void method1() {
        System.out.println("zi method_1");
    }
    void method3() {
        System.out.println("zi method_3");
    }
    static void method4() {
        System.out.println("zi method_4");
    }
    
}
public class DuoTaiDemo1 {

    public static void main(String[] args) {
/*
 * 在多态中，成员变量的特点：无论编译和运行，都参考左边（引用型变量所属 的类）
 */
//        Fu f = new Zi();
//        System.out.println(f.num);
//        
//        Zi z = new Zi();
//        System.out.println(z.num);
        
/*
 * 在多态中，静态成员函数的特点：无论编译和运行，都参考左边。     
 */
        Fu f = new Zi();
        f.method4();
        Zi z = new Zi();
        z.method4();
        
/*
 * 在多态中成员函数(非静态)的 特点：在编译时期：参阅引用型变量所属的类中是否有调用的方法，如果有，编译通过，如果没有编译失败
 *                在运行时期：参阅对象所属的类中是否有调用的方法             
 * 简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。     
 */
//        Fu f = new Zi();
//        f.method1();
//        f.method2();
//        f.method3();
        
    }
}

   

   多态的应用：

   1、电脑运行示例，电脑运行基于主板

   代码示例如下：

//接口定义规则
interface PCI {
    public void open();
    public void close();
}
class MainBoard {
    public void run() {
        System.out.println("mainboard run");
    }
    public void usePCI(PCI p) {// PCI p = new NetCard(); 接口型引用指向自己的子类对象
        if(p != null) {
            p.open();
            p.close();
        }
    }
}
class NetCard implements PCI {
    public void open() {
        System.out.println("netcard open");
    }
    public void close() {
        System.out.println("netcard close");
    }
}
class SoundCard implements PCI {
    public void open() {
        System.out.println("SoundCard open");
    }
    public void close() {
        System.out.println("SoundCard close");
    }
}

public class DuoTaiDemo2 {

    public static void main(String[] args) {
        MainBoard mb = new MainBoard();
        mb.run();
        mb.usePCI(null);
        mb.usePCI(new NetCard());
        mb.usePCI(new SoundCard());
    }

}

   2、数据库的操作。数据是：用户信息。

  1. 连接数据库(JDBC Hibernate)
  2. 操作数据库(CRUD)——C creat R read U update D delete
  3. 关闭数据库连接

   代码示例如下：

interface UserInfoDao { //dao: d(data) a(access) o(object)——数据访问对象
    public void add(User user);
    public void delete(User user);
}
class UserInfoByJDBC implements UserInfoDao {
    public void add(User user) {
        1、JDBC连接数据库
        2、使用sql添加语句添加数据
        3、关闭连接
    }
    public void delete(User user) {
        1、JDBC连接数据库
        2、使用sql删除语句删除数据
        3、关闭连接
    }
}
class UserInfoByHibernate implements UserInfoDao {
    public void add(User user) {
        1、Hibernate连接数据库
        2、使用sql添加语句添加数据
        3、关闭连接
    }
    public void delete(User user) {
        1、Hibernate连接数据库
        2、使用sql删除语句删除数据
        3、关闭连接
    }
}
public class DBOperate {

    public static void main(String[] args) {
//        UserInfoByJDBC ui = new UserInfoByJDBC();
//        UserInfoByHibernate ui = new UserInfoByHibernate();
        UserInfoDao ui = new UserInfoByJDBC(); //多态
        ui.add(user);
        ui.delete(user);
    }

}

 

   Object类

   Object：是所有对象的直接或者间接父类，传说中的上帝。该类中定义的肯定是所有对象都具备的功能。

   Object类中已经提供了对对象是否相同的比较方法，如果自定义类中也有比较相同的功能，没有必要重新定义。只要沿袭父类中的功能，建立自己特有比较内容即可，这就是覆盖。

 

   内部类

   内部类的访问规则：

  • 内部类可以直接访问外部类中的成员，包括私有。之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类中的引用，格式--外部类名.this
  • 外部类要访问内部类，必须建立内部类对象

   访问格式：

   1、当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中，可以直接建立内部类对象。

       格式：外部类名.内部类名   变量名  =  外部类对象.内部类对象

               Outer.Inner in = new Outer().new Inner();

   2、当内部类在成员位置上，就可以被成员修饰符修饰，比如，private将内部类在外部类中进行封装，static内部类就具备static的特性。当内部类被static修饰后，只能直接访问外部类中的static成员，出现了访问局限。

       在外部其他类中，如何直接访问静态内部类非静态成员呢？

       new Outer.Inner().function();

       在外部其他类中，如何直接访问静态内部类静态成员呢？

       Outer.Inner.function();

   注意：当内部类中定义了静态成员，该内部类必须是static的。当外部类中的静态方法访问内部类时，内部类也必须是static的。

   示例代码如下：

class Outer {
    private static int x = 3;
    
    static class Inner {//内部类可以被私有修饰(静态内部类)
//        int x = 4;
        static void function() {
//            int x = 6;
            System.out.println("inner:"+x);
        }
    }
    
    static class Inner2 {
        void show() {
            System.out.println("inner2 show");
        }
    }
    
    public static void method() {
//        Inner in = new Inner();
//        in.function();
        
//        Inner.function();
        new Inner2().show();
    }
}

public class InnerClassDemo {

    public static void main(String[] args) {
        
        Outer.method();
//        Outer.Inner.function();
//        Outer out = new Outer();
//        out.method();
        
        //直接访问内部类中的成员
//        Outer.Inner in = new Outer().new Inner();
//        in.function();
    }

}

   内部类什么时候使用呢？

   当描述事物时，事物的内部还有事物，该事物用内部类来描述，因为内部事物在使用外部事物的内容。以人体和心脏为例进行说明之（示例代码如下）

//人体（外部类）
class Body {
     //心脏（内部类）
     private class XinZang { //心脏得封装起来
 
     }
     public void show() {
            new XinZang().tiaoDong();
     }
}

   内部类定义在局部时

  1. 不可以被成员修饰符修饰，因为private、static不能修饰局部成员
  2. 可以直接访问外部类中的成员，因为还持有外部类中的引用。但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量，java8好像没这个区别了

   示例代码如下：

class Outer_P {
    
    int x = 3;
    
    void method(final int a) {
        final int y = 4;
        class Inner { //private、static不能修饰局部成员
            void function() {
//                System.out.println(Outer_P.this.x);
//                System.out.println(y);
                System.out.println(a);
            }
        }
        new Inner().function();
    }
}
public class InnerClassDemo1 {

    public static void main(String[] args) {
        Outer_P out = new Outer_P();
        out.method(7);
        out.method(8);
    }

}

   匿名内部类

  1. 匿名内部类其实就是内部类的简写格式
  2. 定义匿名内部类的前提：内部类必须是继承一个类或者实现接口
  3. 匿名内部类的格式：new 父类或者接口() {定义子类的内容}
  4. 匿名内部类其实就是一个匿名子类对象，而且这个对象有点胖。可以理解为带内容的对象
  5. 匿名内部类中定义的方法最后不要超过3个。

   示例代码如下：

abstract class AbsDemo {
    abstract void show();
}
class Outer_I {
    int x  =3;
    /*
    class Inner extends AbsDemo {
        int num = 90;
        void show() {
            System.out.println("show:"+num);
        }
        void abc() {
            System.out.println("haha");
        }
    }
    */
    
    public void function() {
//        new Inner().show();
        
//        Inner in = new Inner();
//        in.show();
//        in.abc();
        
        //AbsDemo a = new Inner();
        //new AbsDemo(){}是一个AbsDemo的匿名子类对象
        AbsDemo d = new AbsDemo() {
            int num = 9;
            void show() {
                System.out.println("num==="+num);
            }
            //子类特有方法
            void abc() {
                System.out.println("haha");
            }
        };
        d.show();
//        d.abc();//编译失败
        new AbsDemo() {
            void show() {
                System.out.println("x="+x);
            }
            //子类特有方法
            void abc() {
                System.out.println("haha");
            }
        }.abc();
        
    }
}
public class InnerClassDemo2 {

    public static void main(String[] args) {
        new Outer_I().function();
    }

}

   练习：补全代码。通过匿名内部类

   示例代码：

interface Inter {
    void method();
}
class Test {
    /*
    static class Inner implements Inter {
        public void method() {
            System.out.println("method run");
        }
    }
    static Inter function() {
        return new Inner();
    }
    */
    //补足代码。通过匿名内部类
    static Inter function() {
        return new Inter() {
            public void method() {
                System.out.println("haha");
            }
        };
    }
}

public class InnerClassTest {

    public static void main(String[] args) {
        //Test.function()：Test类中有一个静态的方法function
        //.method()：function这个方法运算后的结果是一个对象，而且是一个Inter类型的对象，因为只有是Inter类型的对象，才可以调用method().
        Test.function().method();
        
//        Inter in = Test.function();
//        in.method();
        show(new Inter() {
            public void method() {
                System.out.println("main run");
            }
        });
    }
    
    public static void show(Inter in) {
        in.method();
    }

}

   面试时可能遇到的一个小问题（有关匿名内部类），如果没有一个类继承或一个抽象类实现，还能使用匿名内部类吗？答案是可以的。示例代码如下：

class InnerTest {
    
    public static void main(String[] args) {
        new Object() {// new Object() {}是Object类的子类对象
            public void function() {
                System.out.println("hello");
            }
        }.function();
    }
}

 

转载于:https://www.cnblogs.com/yerenyuan/p/5205131.html

相关文章：

  • 老板突然走了-被诏安
  • 免费的在线Web文件管理器:Net2FTP,Pydio,eXtplorer,KodExplorer–功能强大
  • 常用笔记本规格表
  • 《构建之法》阅读梳理篇读后感
  • 如何下载一些网站本身不希望你下载的文件呢
  • 如何查看PC和Windows Mobile下蓝牙(Bluetooth)的Stack
  • 单页面应用SPA架构
  • 从Windows到Android开发
  • 使用 libssh 编写 client
  • QTP的那些事--判定页面是否存在某个文本内容
  • mac 安装maven 和改动java环境变量
  • AspNetPager实现真分页+多种样式
  • Linux使用技巧9--用dpkg管理你的软件
  • c# 操作xml题目
  • ANSYS17.0详细安装图文教程
  • PHP的类修饰符与访问修饰符
  • Promise初体验
  • React-Native - 收藏集 - 掘金
  • SpriteKit 技巧之添加背景图片
  • 工作踩坑系列——https访问遇到“已阻止载入混合活动内容”
  • 使用Gradle第一次构建Java程序
  • 微信如何实现自动跳转到用其他浏览器打开指定页面下载APP
  • 吴恩达Deep Learning课程练习题参考答案——R语言版
  • 小程序button引导用户授权
  • scrapy中间件源码分析及常用中间件大全
  • # 深度解析 Socket 与 WebSocket：原理、区别与应用
  • #HarmonyOS:软件安装window和mac预览Hello World
  • （4.10~4.16）
  • （翻译）Quartz官方教程——第一课：Quartz入门
  • (三分钟)速览传统边缘检测算子
  • (四)库存超卖案例实战——优化redis分布式锁
  • (转)h264中avc和flv数据的解析
  • （转）全文检索技术学习(三)——Lucene支持中文分词
  • .NET导入Excel数据
  • .net利用SQLBulkCopy进行数据库之间的大批量数据传递
  • /dev/VolGroup00/LogVol00:unexpected inconsistency;run fsck manually
  • /usr/lib/mysql/plugin权限_给数据库增加密码策略遇到的权限问题
  • @RequestMapping 的作用是什么？
  • @德人合科技——天锐绿盾 | 图纸加密软件有哪些功能呢?
  • [ MSF使用实例 ] 利用永恒之蓝(MS17-010)漏洞导致windows靶机蓝屏并获取靶机权限
  • [ 隧道技术 ] cpolar 工具详解之将内网端口映射到公网
  • [AIR] NativeExtension在IOS下的开发实例 --- IOS项目的创建 (一)
  • [boost]使用boost::function和boost::bind产生的down机一例
  • [BT]BUUCTF刷题第8天（3.26）
  • [BZOJ1053][HAOI2007]反素数ant
  • [Contest20180313]灵大会议
  • [daily][archlinux][game] 几个linux下还不错的游戏
  • [IE编程] 如何在IE8 下调试BHO控件/工具栏(调试Tab进程)
  • [Linux] 一文理解HTTPS协议:什么是HTTPS协议、HTTPS协议如何加密数据、什么是CA证书(数字证书)...
  • [MYSQL]mysql将两个表结果合并到一起
  • [Python]装饰器
  • [SDOI2010]大陆争霸
  • [Swift]LeetCode856. 括号的分数 | Score of Parentheses
  • [UE4]动画蓝图的编辑全流程(Animation Blueprint)
  • [UI5 常用控件] 01.Text