内部类

内部类概述

内部类：就是在一个类中定义一个类。

例：在一个类A的内部定义一个类B，类B就被称为内部类

内部类的定义格式

• 格式

  public class 类名 {
      修饰符 class 类名 {
      }
  }
  

• 例：

  public class Outer {
      public class Inner {
      }
  }
  

内部类的访问特点

• 内部类可以直接访问外部类的成员，包括私有
• 外部类要访问内部类的成员，必须创建对象

例：

package com.test;

public class Outer {

    private int num = 10;

    public class Inner {

        public void show() {
//            内部类可以直接访问外部类
            System.out.println(num);
        }
    }

    public void method() {
//        外部类创建对象才能访问内部类
        Inner i = new Inner();
        i.show();
    }
}

成员内部类

按照内部类在类中定义的位置不同，可以分为如下两种形式

• 在类的成员位置：成员内部类
• 在类的局部位置：局部内部类（也就是在方法体中）

成员内部类，外界如果创建对象使用呢？

• 格式：外部类名.内部类名 对象名 = 外部对象.内部对象；

• 例：内部类对象的创建

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

Outer.java

package com.test;

public class Outer {

    private int num = 10;

//    内部类一般不可见，外界不能直接调用
    private class Inner {

        public void show() {
//            内部类可以直接访问外部类
            System.out.println(num);
        }
    }

//    通过方法对内部类进行调用
    public void method() {
//        外部类创建对象才能访问内部类
        Inner i = new Inner();
        i.show();
    }
}

InnerDemo.java

package com.test;

/**
 * 测试类
 */
public class InnerDemo {
    public static void main(String[] args) {

//        Outer.Inner oi = new Outer().new Inner();
//        oi.show();

        Outer o = new Outer();
        o.method();
    }
}

局部内部类

局部内部类是在方法中定义的类，所以外界是无法直接使用，需要在方法内部创建对象并使用

该类可以直接访问外部类的成员，也可以访问方法内的局部变量

Outer.java

package com.test;

public class Outer {

    private int num = 10;

    public void method() {

//        局部内部类
        class Inner {
            public void show() {
                System.out.println(num);
            }
        }

//        局部内部类的使用
        Inner i = new Inner();
        i.show();

    }
}

OuterDemo.java

package com.test;

/**
 * 测试类
 */
public class OuterDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

匿名内部类

前言：匿名内部类是局部内部类的一种特殊形式

前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类

• 格式：

  new 类名或接口名() {
      重写方法;
  };
  

• 例

  new Inner() {
      public void show() {
      }
  }
  

本质：是一个继承了该类或者实现了该接口的子类匿名对象

例：

Outer.java

package com.test;

public class Outer {

    private int num = 10;

    public void method() {
//        本质是一个对象，只不过该对象无名字罢了
        new Inter() {

            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        };

//        对象调方法
        new Inter() {

            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        }.show();

//        同理，采用多态形式
        Inter i = new Inter() {

            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        };
        i.show();

    }
}

OuterDemo.java

package com.test;

/**
 * 测试类
 */
public class OuterDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

匿名内部类在开发中的使用

Jumpping.java

package com.test;

/**
 * 跳高接口
 */
public interface Jumpping {

    void jump();
}

JumppingOpreator.java

package com.test;

/**
 * 接口操作类，里面有一个方法，方法参数是接口名
 * 要的是该接口的实现类对象
 */
public class JumppingOperator {

    public void method(Jumpping j) {
        j.jump();
    }

}

JumppingDemo.java

package com.test;

/**
 * 测试类
 */
public class JumppingDemo {
    public static void main(String[] args) {
//        创建接口操作类的对象，调用method方法
        JumppingOperator jo = new JumppingOperator();
//        匿名内部类的使用
        jo.method(new Jumpping() {
            @Override
            public void jump() {
                System.out.println("猫可以跳高了!");
            }
        });

        jo.method(new Jumpping() {
            @Override
            public void jump() {
                System.out.println("狗可以跳高了！");
            }
        });
    }
}