面向对象-内部类

简介

定义:将一个类定义在另一个类的里面,里面那个类就是内部类,又称为嵌套类或者内置类。
内部类生成的字节码文件名格式为:OuterClass$InnerClass.class
内部类可以分成成员内部类、局部内部类以及匿名内部类。
在一个类中使用内部类,可以在内部类中直接存取其所在类的私有成员变量,尽管这些类成员被修饰为private。外部类不可以直接访问内部类成员变量,但是可以通过get方法来获得。
内部类的实例一定要绑定在外部类的实例上。如果从外部类中初始化一个内部类对象,那么内部类就会绑定在外部类对象上。内部类的对象实例化必须在外部类或外部类的非静态方法中实现。如果在外部类和非静态方法之外实例化内部类,需要使用外部类。

成员内部类

即内部类作为外部类的一个成员:

public class OuterClass{//外部类
    private class InnnerClass{//内部类
    }
}

示例:

class Outer{
    Inner in =new Inner();//在外部类实例化内部类对象的引用
    void ouf(){
        in.inf();//在外部类方法中调用内部类方法
    }
    class Inner{
        Inner(){//内部类构造方法
        }
        void inf(){//内部类成员方法
        }
        int y=0;//定义内部类成员变量
    }
    Inner fuc(){//外部类成员方法
        in.y=4;//外部类不可以直接访问内部类成员变量:y=4是错的
        return new Inner();//返回内部类引用
    }
    public static void main(String[] args){
        Outer out=new Outer();
        //内部类的对象实例化操作必须在外部类或外部类的非静态方法中
        Outer.Inner in =out.fuc();
        Outer.Inner in2=out.new Inner()//实例化内部类时,new之前提供外部类的引用
    }
}

局部内部类

内部类不仅可以在类中进行定义,也可以在类的局部位置定义,如类的方法里:

class Outer
{
    int num=3;
    //void method()
    Object method()
    {
        final int x=9;
        class Inner
        {
            void show()
            {
                System.out.println("show..."+num);
                System.out.println("show..."+x);//从内部类中访问局部变量x,需要被声明为最终类型(final)
            }
        }
        //Inner in =new Innner();
        //in.show();
        Object in =new Inner();
        return in;
    }
}

class InnerClassDemo1
{
    public static void main(String[] args)
    {
        //new Outer().method();

        Outer out =new Outer();
        Object obj=out.method();//method方法调用后把结果传递给obj这个引用后,就出栈了,x消失了,但是对象还在堆里,因此x不能访问
    }

注意:在方法中定义的内部类只能访问方法中final类型的局部变量。

匿名内部类

匿名内部类即内部类的简写格式。
存在的前提:内部类必须继承或者实现一个外部类或者接口

就是一个匿名子类对象
格式:new 父类or接口名(){子类内容}

示例1:

abstract class Demo
{
    abstract void show();
}

class Outer
{
    int num=4;
    /*class Inner extends Demo
    {
        void show()
        {
            System.out.println("show..."+num);
        }
    }
    */
    public void method()
    {
        //new Inner().show();
        new Demo()//匿名内部类  Demo的子类
        {
            void show()
            {
                System.out.println("show..."+num);
            }
        }.show();//匿名内部类对象调用方法
    }
}

class InnerClassDemo2
{
    public static void main(String[] args)
    {
        new Outer().method();
    }
}

示例2:

class Outer
{
    void method()
    {
        Object obj=new Object()//匿名内部类+多态
        {
            public void show()
            {
                System.out.println("show run");
            }
        }
        obj.show();//编译错误  因为匿名内部类这个子类对象被向上转型为了Object类型
                    //这样就不能再使用子类特有的方法(show)了
    }
}

class InnerClassDemo3
{
    public static void main(String[] args)
    {
        new Outer().method();

    }
}

对象初始化过程

1、堆内创建对象空间,分配地址。成员变量默认初始化。
2、构造函数压栈,初始化父类的构造函数。(super();)
3、成员变量显式初始化
4、执行构造代码块
5、执行构造函数内本类具体的初始化。

示例:

class Parent    
{
    int num=9;
    {//构造代码块
        System.out.println("Parent block");//1:Parent block
    }
    Parent(){
        super();//Object
        //显式初始化
        //构造代码块初始化
        show();
    }
    void show(){
        System.out.println("parent show..."+num);//被覆盖,运行子类的
    }
}

class Son extends Parent{
    int num =8;
    {//构造代码块
        System.out.println("son block");//3:son block
    }
    Son(){
        super();
        //显式初始化
        //构造代码块初始化
        show();
    }
    void show(){
        System.out.println("son show..."+num);//2:son show...0 4:son show...8
    }
}
public class Demo{
    public static void main(String[] args){
        new Son();
    }
}

/*输出结果:
Parent block
son show...0
son block
son show...8
*/
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值