JAVA基础再回首（八）——多态、（成员、局部、匿名）内部类

最新推荐文章于 2023-11-10 08:34:54 发布
最新推荐文章于 2023-11-10 08:34:54 发布
阅读量2.7k 收藏 8
点赞数 4
分类专栏： Java基础再回首 Java基础再回首 文章标签： java 多态 内部类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m366917/article/details/52124604
版权

JAVA基础再回首（八）——多态、（成员、局部、匿名）内部类

只有一条路不能选择——那就是放弃的路;只有一条路不能拒绝——那就是成长的路。
今晚和好朋友一起去吃饭，回来的有点晚了，不知道今天的任务能否按时完成，我会尽力的。

多态

概述：某一个事物，在不同时刻表现出来的不同状态。
我们来举例说明：

  • 猫是猫，狗是狗，猫和狗都是动物。
  • 水在不同环境下的状态不同（液体，固体，气态）

那么使用多态的前提是什么呢？

  • 要有继承关系。

  • 要有方法重写。

     //其实没有也是可以的，但是如果没有这个就没有意义。
     Animal c = new Cat();
            c.show();
     Animal d = new Dog();
            d.show();

  • 要有父类引用指向子类对象。

        父 f =  new 子();

    下面我们用代码来体现

        class Fu {
    public int num = 100;

    public void show() {
        System.out.println("show Fu");
    }

    public static void function() {
        System.out.println("function Fu");
    }
}

class Zi extends Fu {
    public int num = 1000;
    public int num2 = 200;

    public void show() {
        System.out.println("show Zi");
    }

    public void method() {
        System.out.println("method zi");
    }

    public static void function() {
        System.out.println("function Zi");
    }
}

class DuoTaiDemo {
    public static void main(String[] args) {
        //要有父类引用指向子类对象。
        //父 f =  new 子();
        Fu f = new Zi();
        System.out.println(f.num);
        //找不到符号
        //System.out.println(f.num2);

        f.show();
        //找不到符号
        //f.method();
        f.function();
    }
}

我们可以看到多态中的成员访问特点

  • 成员变量
    • 编译看左边，运行看左边
  • 构造方法
    • 子类的构造都会默认访问父类构造
  • 成员方法
    • 编译看左边，运行看右边
  • 静态方法
    • 编译看左边，运行看左边
    • 所以静态方法不能算方法的重写

学了这么多我们应该了解下多态的好处：

  1. 提高了代码的维护性(继承保证)
  2. 提高了代码的扩展性(由多态保证)

多态有好处，当然也有弊端了
不能使用子类的特有功能。
那么我们如何才能访问子类的特有功能呢?
多态中的转型
怎么用呢？

  • 创建子类对象调用方法即可。(可以，但是很多时候不合理。而且，太占内存了)
  • 把父类的引用强制转换为子类的引用。(向下转型)

关于对象间的转型问题：

  • 向上转型
    • 从子到父
    • 父类引用指向子类对象
      • Fu f = new Zi();
  • 向下转型
    • 从父到子
    • 父类引用转为子类对象
      • Zi z = (Zi)f; //要求该f必须是能够转换为Zi的。
        class Fu {
        public void show() {
            System.out.println("show fu");
        }
    }

    class Zi extends Fu {
        public void show() {
            System.out.println("show zi");
        }

    public void method() {
        System.out.println("method zi");
    }

    }

    class DuoTaiDemo3 {
        public static void main(String[] args) {
            //测试
            Fu f = new Zi();
            f.show();
            f.method(); //多态的弊端不能使用子类的特有功能。
        }
    }
    //所以输出结果是：show zi

    //关于向下转型，我们能够把子类的对象赋值给父类，
    //所以我们也可以把父类的引用赋值给子类的引用
    //怎么使用呢，只要在上面例子的基础上稍做修改
        Son z = (Son) f;
            z.show();
            z.method();
//输出结果就变了：show zi
              //method zi

内部类

概述：把类定义在其他类的内部，这个类就被称为内部类。
举例：在类A中定义了一个类B，类B就是内部类。

  • 内部的访问特点：
    • 内部类可以直接访问外部类的成员，包括私有。
    • 外部类要访问内部类的成员，必须创建对象。
  • 内部类位置
    • 成员位置:在成员位置定义的类，被称为成员内部类。
    • 局部位置:在局部位置定义的类，被称为局部内部类。
class Outer {
    private int num = 10;

    //成员位置,成员内部类
    class Inner {

    }
    public void method() {
        //局部位置,局部内部类
        class Inner {

        }
    }
}

我们了解了成员内部类，那么如何直接访问内部类的成员。
外部类名.内部类名 对象名 = 外部类对象.内部类对象;

class Outer {
    private int num = 10;

    class Inner {
        public void show() {
            System.out.println(num);
        }
    }
}

class InnerClassDemo {
    public static void main(String[] args) {
        //需求：我要访问Inner类的show()方法
        //Inner i = new Inner();
        //i.show();   这样访问不到

        //格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
        Outer.Inner oi = new Outer().new Inner();
        oi.show();
    }
}

上面学习了成员内部类的使用，但是一般来说，在实际开发中是不会这样使用的。因为一般内部类就是不让外界直接访问的。

  • 成员内部的常见修饰符
    • private 为了保证数据的安全性
    • static 为了让数据访问更方便
      • 被静态修饰的成员内部类只能访问外部类的静态成员
      • 内部类被静态修饰后的方法
        • 静态方法
        • 非静态方法
class Outer {
    private static int num = 100;

    //内部类用静态修饰是因为内部类可以看出是外部类的成员
    public static class Inner {
        public void show() {
            System.out.println(num);
        }

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

class InnerClassDemo {
    public static void main(String[] args) {
        //成员内部类被静态修饰后的访问方式是:
        Outer.Inner.show2();
    }
}

局部内部类

  • 可以直接访问外部类的成员
  • 在局部位置，可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能
class Outer {
    private int num  = 10;

    public void method() {
        //int num2 = 20;
        final int num2 = 20;
        class Inner {
            public void show() {
                System.out.println(num);
                //从内部类中访问本地变量num2; 需要被声明为最终类型
                System.out.println(num2);//20
            }
        }
        //System.out.println(num2);

        Inner i = new Inner();
        i.show();
    }
}

class InnerClassDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();  //结果是：10  20
    }
}

局部内部类访问局部变量的注意事项：

  • 局部内部类访问局部变量必须用final修饰
  • 原因：局部变量是随着方法的调用而调用，随着调用完毕而消失。而堆内存的内容并不会立即消失。所以，我们加final修饰。加入final修饰后，这个变量就成了常量。既然是常量。你消失了。在内存中存储的是数据20，所以，还是有数据在使用。

最后，我们来学习匿名内部类

  • 匿名内部类就是内部类的简化写法。
  • 前提：存在一个类或者接口
    • 这里的类可以是具体类也可以是抽象类。
  • 格式：
    • new 类名或者接口名() {重写方法;}
  • 本质：
    • 是一个继承了类或者实现了接口的子类匿名对象
interface Inter {
    public abstract void show();
    public abstract void show2();
}

class Outer {
    public void method() {
        //一个方法的时候
        /*
        new Inter() {
            public void show() {
                System.out.println("show");
            }
        }.show();
        */

        //二个方法的时候
        /*
        new Inter() {
            public void show() {
                System.out.println("show");
            }

            public void show2() {
                System.out.println("show2");
            }
        }.show();

        new Inter() {
            public void show() {
                System.out.println("show");
            }

            public void show2() {
                System.out.println("show2");
            }
        }.show2();
        */

        //如果我是很多个方法，就很麻烦了
        //那么，我们有没有改进的方案呢?
        Inter i = new Inter() { //多态
            public void show() {
                System.out.println("show");
            }

            public void show2() {
                System.out.println("show2");
            }
        };

        i.show();
        i.show2();
    }
}

class InnerClassDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
        //输出结果：show   show2
    }
}

关于面向对象部分的知识点，我们已经基本学完了。
这块的知识点比较多，也很重要，大家要多练习，加以巩固。

欢迎有兴趣的同学加我朋友的QQ群：555974449
我在群里等你。

Aduroidpc
关注
专栏目录
黑马程序员-JAVA基础学习日志——通篇大总结及学习方法思想
无码骑兵的博客
09-07 5592
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------   Java基础知识总结          回首是为了更好向前，天空没有翅膀的痕迹，而我已飞过，人总是这样，害怕回首，又时常回首，看看走过的路是直是弯，踩下的脚印是深是浅，回首昨天的风雨，眺望远方的灿烂。几多感慨，几多愁，放下包袱，轻装前行... 写代码： 1，明确需求。我要做什么？
Java基础——多态.pdf
07-22
内含Java基础多态知识点笔记，及部分对应练习题。
Java中的多态、内部类、匿名内部类
jamin-it的专栏
06-20 1396
一、多态
JAVA基础再回首（三十）——JAVA基础再回首完美结束，感概万千！
aduroidpc's Blog
10-02 5250
JAVA基础再回首（三十）——JAVA基础再回首完美结束，感概万千！ 经过了几个月断断续续的回首java基础，终于回首完了，这一路走来体会到了枯燥、乏味、有趣，当然更多是收获，和第一遍学java基础的感觉完全不同了。 在我们人生的道路中，偶尔的回首往事，也会有不同的收获。我们不仅要向前看，也要去总结自己走过的路。 感谢一路以来大家对我的支持和鼓励，让我不断努力的去坚持再回首，有几次，我
JAVA基础再回首（四）——面向对象思想、类与对象、成员/局部变量、匿名对象、封装、private、this、构造方法
aduroidpc's Blog
07-13 3108
面向对象思想、类与对象、成员/局部变量、匿名对象、封装、private、this、构造方法 好久没更了，毕业季的离别总令人伤感，我相信再见是为了我们更好的遇见。好了，来继续学习吧！ 一、面向对象思想 概述： 面向对象是基于面向过程的编程思想 特点： 更符合我们思想习惯的思想 可以将复杂的事情简单化 将我们从执行者变成了指挥者（角色发生了转换） 说了上面的概念，有的人肯定没有明白和理解 那么，我
java基础学习笔记
4年java开发的成长记录
02-28 1286
java基础学习笔记从0到入门
JAVA基础1
qq_37062583的博客
11-13 303
JAVA基础（答案仅供参考，如有不对之处请批评指正） 　　1、HashMap源码，实现原理，JDK8以后对HashMap做了怎样的优化。 　　答：HashMap是基于哈希表的Map接口的非同步实现，提供所有可选的映射操作，并允许使用null值和null键，不保证映射的顺序；HashMap是一个“链表散列”的数据结构，即数组和链表的结合体；它的底层就是一个数组结构，数组中的每一项又是一个链表，每...
Java程序设计开发实战
最新发布
yootk的博客
11-10 181
Java是当前主流的编程语言，有着非常丰富且完善的语法结构，为了帮助读者完整且清晰的掌握Java核心语法以及完整的面向对象设计与分析思想，特编写此书。 本书一共包含有13个章节内容，从基础的Java开发环境搭建以及语法知识进行全面的知识分析，帮助读者深刻的理解程序逻辑、方法、类、对象、抽象类、接口、包、访问权限、模块以及多线程的相关概念，并通过大量的练习案例进行了实现讲解。 本书附有配套视频、源代码、习题、教学课件等资源。为了帮助读者更好地学习本书，作者还提供了在线答疑。
java面试题目前为止全内容收集
月阴荒的博客
07-04 4382
所有java的知识点放在这里，算是一个总的收集
JAVA笔记02
qq_39760343的博客
12-13 161
说来也羞愧，回首过去的这半年，我是真的不知道自己干了什么，唉，最近用了几天的 时间把疯狂JAVA讲义看了一遍，写下一点点感悟，没什么其他意思，就是想祭奠一下挥霍的时光… JAVA语言概述 这个其实真的没什么可说的，不过我还是想简单写点，一开始我是真的反感JAVA的繁琐，从最简单的类，一直到捋不清的多态继承关系，相比之下我Python实现的多好…但是越学越发现，膜拜詹姆斯.高斯林，这真是个神人，看似...
Java——多态
12-21
Java——多态 多态的特性 1.可替换性（substitutability）。多态对已存在代码具有可替换性。 例如，多态对圆Circle类工作，对其他任何圆形几何体，如圆环， 也同样工作。 2.可扩充性（extensibility）。多态对代码...
Java——多态与接口.rar
11-16
在“Java——多态与接口”实验中，你可能需要编写一些示例代码来实践这些概念，例如创建一个基类，然后定义几个子类继承基类并覆盖其方法；再定义一个接口，让部分子类实现这个接口并提供接口方法的实现。通过运行和...
JAVA基础再回首（十）——StringBuffer类概述、添加、删除、替换、反转、截取功能、StringBuilder
热门推荐
aduroidpc's Blog
08-10 1万+
JAVA基础再回首（十）——StringBuffer类概述、添加、删除、替换、反转、截取功能、StringBuilder 我决定了，每篇博客的开始我都会和大家分享一点题外话。每次写完博客我才会到这里写。 真正的情商高，不是虚伪，而是温暖。所谓情商高，确实就是懂得好好说话，要怎么说话呢？ 把你说的“不对”统统改成“对”（先肯定对方，在讲自己的意见，沟通氛围会好很多哦！）
JAVA基础再回首（一）——基本概念、JAVA开发工具、JAVA基本语法
aduroidpc's Blog
06-01 7864
JAVA基础再回首（一）——基本概念、JAVA开发工具、JAVA基本语法 学了java，做了android应用开发，现在回想起来，真的是一路坎坷。。我在上章博客中提到了我以后的几个学习计划和目标就是把以前学的java基础和android基础在学习一遍。我相信我会有不少的收获的，大家也一样，和我一起加油努力吧。话不多说，我们来抓紧学习吧！ ` 一、计算机语言 语言 人类进行沟通交流的各种表达符
JAVA基础再回首（二）——流程控制语句、跳转控制语句
aduroidpc's Blog
06-09 7164
JAVA基础再回首（二）——流程控制语句、跳转控制语句 JAVA基础真的很重要，无论是以后要开发Android还是Web，打好基础都是必须的，加油，为了自己的目标。 一、流程控制语句 在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。也就是说程序的流程对运行结果有直接的影响。所以，我们必须清楚每条语句的执行流程。而且，很多时候我们要通过控制语句的执行顺序来实现我们要完成的
JAVA基础再回首（二十五）——Lock锁的使用、死锁问题、多线程生产者和消费者、线程池、匿名内部类使用多线程、定时器、面试题
aduroidpc's Blog
10-01 6132
JAVA基础再回首（二十五）——Lock锁的使用、死锁问题、多线程生产者和消费者、线程池、匿名内部类使用多线程、定时器、面试题 版权声明：转载必须注明本文转自程序员杜鹏程的博客:http://blog.csdn.net/m366917 我们来继续学习多线程Lock锁的使用 虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达
JAVA基础再回首（六）——父与子的继承、super关键字、方法重写、方法重载
aduroidpc's Blog
08-02 5388
JAVA基础再回首（六）——父与子的继承、super关键字、方法重写、方法重载 不墨迹，才是时间管理的最大利器,学无止境。 继承 首先我们来学习继承的概述多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。 通过extends关键字可以实现类与类的继承 格式：class 子类名 extends 父类名 {} 单独的这个类称
JAVA基础再回首（三）——方法、重载、数组、堆栈内存分配、数组遍历、获取最值、二维数组
aduroidpc's Blog
06-10 4552
JAVA基础再回首（三）——方法、重载、数组（静态和动态初始化）、堆栈内存结构、遍历、最值、二维数组 继续开始学习我们的java基础，这篇主要学习两个知识点——方法、数组。 一、方法 方法：就是完成特定功能的代码块 注意：在很多语言里面有函数的定义，而在Java中函数被称为方法。 方法格式：修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
精通Java编程：多态、接口与内部类解析
"Java编程思想，特别是关于多态、接口和内部类的讲解，是Java开发者和学习者的重要参考资料。本书深入浅出地介绍了Java的核心概念，包括对象引用、程序控制流程、初始化与清理、封装、类的复用、多态性、接口以及...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值