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

原创 2016年08月05日 00:09:44

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
我在群里等你。

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/m366917/article/details/52124604

嵌套类(内部类)

本门课程是主要介绍嵌套类(内部类)概念及语法,介绍各种内部类的语法,变量声明及实例化。为什么要使用嵌套类(内部类)等。
  • 2017年01月30日 17:41

java——多态,内部类

介绍了Java语言的特性——多态、内部类。
  • laomei1
  • laomei1
  • 2015-10-24 10:33:47
  • 218

毕向东Java视频学习笔记【Day10 多态+内部类】

Java_Day10 多态+内部类   .01 .02 多态 猫 x = new 猫(); 动物 x = new 猫(); 一个对象对应着不同类型。 多态在代码中的体现:父类或者接口的引用指向了...
  • qq_24653023
  • qq_24653023
  • 2016-06-24 21:17:09
  • 929

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

JAVA基础再回首(八)——多态、(成员、局部、匿名)内部类 只有一条路不能选择——那就是放弃的路;只有一条路不能拒绝——那就是成长的路。...
  • m366917
  • m366917
  • 2016-08-05 00:09:44
  • 1479

对多态的理解(附经典练习题)

(以下综合了多篇多态的文字,总结而得) 定义:指不同类的对象对同一函数做出不同响应。 实现方式:1.继承父类,方法重写(包括接口实现);2.同一个类中进行方法重载。 存在的三个必...
  • a_long_
  • a_long_
  • 2016-07-28 15:57:56
  • 2758

<em>java</em>进阶<em>练习习题</em>与答案

共九章内容:第 1 章 <em>Java</em>概述 第 2 章 <em>Java</em>语言基础 第 3 章 类的封装、继承和<em>多态</em> 第 4 章 接口、<em>内部类</em>和 <em>Java</em> API 基础 第 5 章 异常处理 第 6 ...
  • 2018年04月17日 00:00

【java基础】——java面向对象(下)—多态、内部类、异常、包

android培训------我的java笔记,期待与您交流! 一、面向对象——多态 1、多态概述 ①什么是多态?某一事物在不同时刻表现出来的不同状态。 如:猫可以是猫的类型。猫 m = new猫()...
  • u010873512
  • u010873512
  • 2015-06-24 15:18:48
  • 714

7、Java多态、内部类、异常、包

一、多态多态可以理解为事物存在的多种体现形态。        例:动物中猫,狗。猫这个对象对应的类型是猫类型,如:猫 x = new猫();同时猫也是动物中的一种,也可以把猫称为动物。动物  y = ...
  • BUKAI123
  • BUKAI123
  • 2015-11-24 09:40:35
  • 150

Java基础(面向对象三——多态、内部类)

一、多态 定义:事物存在的多种表现形式 例如:动物中猫和狗 猫这个对象对应的类型是猫类型      猫 m = new 猫(); 而猫是动物中的一种,所以也可以把猫称为动物,也就是说让父类引用指向...
  • zzamk
  • zzamk
  • 2015-03-11 19:07:15
  • 550

黑马程序员——Java基础---多态、内部类、异常、包

第一讲     多态         多态可以理解为事物存在的多种体现形态。         例:动物中猫,狗。猫这个对象对应的类型是猫类型,如:猫 x = new猫(); 同时猫也是动物...
  • u012564403
  • u012564403
  • 2015-06-26 15:32:51
  • 221
收藏助手
不良信息举报
您举报文章:JAVA基础再回首(八)——多态、(成员、局部、匿名)内部类
举报原因:
原因补充:

(最多只允许输入30个字)