内部类

概述

内部类，即为在一个类中定义的类

语法格式

  1. class A{
  2.     classB{
  3.     B即为内部类
  4.     }
  5. }

特点

  1. 内部类可以直接访问外部类中的成员，包括私有成员

  2. 外部类要访问内部类的成员，必须要建立内部类的对象

  3. 在成员位置的内部类是成员内部类

  4. 在局部位置的内部类是局部内部类

内部类代码示例

  1. package cn.tedu.innerclass;
  3. /**
  4.  * 内部类案例
  5.  */
  7. public class TestInner1 {
  8.     public static void main(String[] args) {
  9.         Outer.Inner oi = new Outer().new Inner();
  10.         oi.delete();
  11.         System.out.println(oi.sum);
  12.         //直接创建外部类匿名对象调用外部类方法
  13.         new Outer().find();
  14.     }
  15. }
  17. class Outer{
  18.     String name;
  19.     private int age;
  21.     public void find(){
  22.         System.out.println("马钊要起飞了！");
  23.         /*
  24.         System.out.println(sum);
  25.         delete();
  26.         内部类无法直接使用外部类的资源
  27.         需要创建内部类对象后才可使用
  28.          */
  29.         Inner in = new Inner();
  30.         System.out.println(in.sum);
  31.         in.delete();
  33.     }
  35.     class Inner{
  36.         int sum = 100;
  38.         public void delete(){
  39.             System.out.println("马钊起飞成功");
  40.             System.out.println(name);
  41.             System.out.println(age);
  42.             //只能单向调用，不能循环调用，会导致栈溢出异常
  43.             //find();
  44.         }
  45.     }
  46. }

私有内部类

成员内部类被Private修饰以后,无法被外界直接创建创建对象使用

所以可以创建外部类对象,通过外部类对象间接访问内部类的资源

  1. package cn.tedu.innerclass;
  3. /**
  4.  * 测试成员内部类被private修饰
  5.  */
  7. public class TestInner2 {
  8.     public static void main(String[] args) {
  9.        /*
  10.        Outer2.Inner2 oi = new Outer2().new Inner2();
  11.         oi.eat();
  12.         报错
  13.         */
  15.         Outer2 o2 = new Outer2();
  16.         o2.getInner2Eat();
  17.     }
  18. }
  20. class Outer2{
  21.     /*
  22.     成员内部类
  23.     位置:类里方法外
  24.      */
  25.      private class Inner2{
  26.         public void eat(){
  27.             System.out.println("明天,马钊,吃的,起飞！");
  28.         }
  29.     }
  31.     public void getInner2Eat(){
  32.          Inner2 in = new Inner2();
  33.          in.eat();
  34.     }
  35. }

静态内部类

静态资源访问时不需要创建对象,可以通过类名直接访问

访问静态类中的静态资源可以通过”. . . ”链式加载的方式访问

  1. package cn.tedu.innerclass;
  3. /**
  4.  * 测试静态内部类
  5.  */
  7. public class TestInner3 {
  8.     public static void main(String[] args) {
  9.        /*
  10.        Outer3.Inner3 oi = new Outer3().new Inner3();
  11.         oi.watermelon();
  12.         new Outer3().new Inner3().watermelon();
  13.         内部类被static修饰后，报错
  14.         */
  15.         Outer3.Inner3 oi = new Outer3.Inner3();//静态内部类普通对象
  16.         oi.watermelon();
  17.         new Outer3.Inner3().watermelon();//静态内部类匿名对象
  19.         //访问静态内部类的静态资源---链式加载
  20.         Outer3.Inner3.eat();
  21.     }
  22. }
  24. class Outer3{
  25.     static class Inner3{
  26.         public void watermelon(){
  27.             System.out.println("吃瓜大赛");
  28.         }
  30.         public static void eat(){
  31.             System.out.println("吃瓜吃到吐");
  32.         }
  33.     }
  34. }

局部内部类

调用局部内部类功能 在外部类中创建局部类的对象并且调用其功能

  1. package cn.tedu.innerclass;
  3. /**
  4.  * 测试局部内部类
  5.  */
  7. public class TestInner4 {
  8.     public static void main(String[] args) {
  9.         Outer4 o = new Outer4();
  10.         o.show();
  12.     }
  13. }
  15. class Outer4{
  17.     public void show(){
  19.         System.out.println("Other4-----show()");
  21.         //局部内部类--方法里
  22.         class Inner4{
  23.             String name;
  24.             int age;
  26.             public void eat(){
  27.                 System.out.println("show-----eat()");
  28.             }
  29.         }
  30.         /*
  31.         在外部类中创建局部类的对象并且调用其功能
  32.          */
  33.         Inner4 in = new Inner4();
  34.         in.eat();
  35.         System.out.println(in.age);
  36.         System.out.println(in.name);
  37.     }
  38. }

匿名内部类

匿名内部类属于局部内部类,而且是没有名字的局部内部类,通常和匿名对象一起使用

  1. package cn.tedu.innerclass;
  3. /**
  4.  * 匿名内部类
  5.  */
  7. public class TestInner5 {
  8.     public static void main(String[] args) {
  9.         /*
  10.         创建接口实现类的对象才能调用方法===创建接口实现类+重写接口中的抽象方法+调用方法
  11.         匿名内部类没有名字，通常与匿名对象结合使用，用于调用一次&一个方法
  12.          */
  14.         new Inner1() {
  15.             @Override
  16.             public void save() {
  17.                 System.out.println("保存");
  18.             }
  20.             @Override
  21.             public void get() {
  22.                 System.out.println("获取");
  23.             }
  24.         }.save();
  26.         new Inner11() {
  27.             @Override
  28.             public void play() {
  29.                 System.out.println("大赛");
  30.             }
  31.         }.play();
  33.         new Inner3().get();
  34.     }
  35. }
  37. interface Inner1{
  38.     void save();
  39.     void get();
  41.     class Inner4{
  43.     }
  44. }
  46. abstract class Inner11{
  47.     public void eat(){
  48.         System.out.println("吃瓜");
  49.     }
  51.     abstract public void play();
  52. }
  54. class Inner3{
  55.     public void eat(){
  56.         System.out.println("吃土");
  57.     }
  59.     public void get(){
  60.         System.out.println("获取");
  61.     }
  62. }