private内部类的作用及举例

私有内部类是指在一个类内部定义的类，只能在该类内部使用，外部无法访问。它的作用有以下几点:

1. 封装性：私有内部类与外部类形成了一个整体，可以访问外部类的私有属性和方法，但不能被外部类访问，同时也可以防止外部类的非法访问。

2. 继承性：私有内部类可以继承外部类，从而可以利用外部类的属性和方法，达到重复使用代码的效果。

3. 多态性：私有内部类可以实现接口，从而实现多态的效果。

举个例子，比如一个汽车类中有一个私有内部类，代表车轮，这个车轮类继承了一个“轮子”类，并且实现了一个“自动打气”接口，这样可以保证车轮具有打气的功能，同时防止外部类的非法访问。

相关问题

成员内部类与局部内部类，代码举例说明

好的，下面是成员内部类和局部内部类的例子：

成员内部类：

public class OuterClass {
  private int x = 10;

  class InnerClass {
    public int getNum() {
      System.out.println("This is the getnum method of the inner class");
      return x;
    }
  }
}

public class Main {
  public static void main(String[] args) {
    OuterClass outer = new OuterClass();
    OuterClass.InnerClass inner = outer.new InnerClass();
    System.out.println(inner.getNum()); // 输出 10
  }
}

局部内部类：

public class OuterClass {
  private int x = 10;

  void doSomething() {
    class InnerClass {
      public void print() {
        System.out.println("This is the print method of the inner class");
      }
    }
    InnerClass inner = new InnerClass();
    inner.print(); // 输出 This is the print method of the inner class
  }
}

public class Main {
  public static void main(String[] args) {
    OuterClass outer = new OuterClass();
    outer.doSomething();
  }
}

希望能帮到你！

什么是内部类，成员内部类，局部内部类，匿名内部类，静态内部类，请用代码举例说明

内部类是指定义在其他类内部的类。根据定义的位置和特点，内部类可以分为成员内部类、局部内部类、匿名内部类和静态内部类。

1. 成员内部类：
成员内部类是定义在另一个类的内部，并且与外部类实例相关联的内部类。它可以访问外部类的成员变量和方法，甚至可以访问外部类的私有成员。

   public class OuterClass {
       private int outerVariable = 10;
       
       public class InnerClass {
           public void display() {
               System.out.println("Outer variable: " + outerVariable);
           }
       }
   }

   // 使用成员内部类
   public class Main {
       public static void main(String[] args) {
           OuterClass outer = new OuterClass();
           OuterClass.InnerClass inner = outer.new InnerClass();
           inner.display();
       }
   }

2. 局部内部类：
局部内部类是定义在方法或作用域内的内部类，只能在定义它的方法或作用域中使用。局部内部类对外部世界是隐藏的，只能在其定义的方法或作用域中创建和使用。

   public class OuterClass {
       public void methodWithLocalInnerClass() {
           int localVar = 5;
           
           class LocalInnerClass {
               public void display() {
                   System.out.println("Local variable: " + localVar);
               }
           }
           
           LocalInnerClass inner = new LocalInnerClass();
           inner.display();
       }
   }

   // 使用局部内部类
   public class Main {
       public static void main(String[] args) {
           OuterClass outer = new OuterClass();
           outer.methodWithLocalInnerClass();
       }
   }

3. 匿名内部类：
匿名内部类是没有名字的内部类，用于实现一个接口或继承一个类，并且在创建对象时进行定义和实例化。通常在需要临时实现某个接口或继承某个类的情况下使用。

   public interface MyInterface {
       void display();
   }

   // 使用匿名内部类
   public class Main {
       public static void main(String[] args) {
           MyInterface obj = new MyInterface() {
               @Override
               public void display() {
                   System.out.println("Anonymous inner class");
               }
           };
           obj.display();
       }
   }

4. 静态内部类：
静态内部类是定义在另一个类内部，并且被声明为静态的内部类。它与外部类实例无关，可以直接访问外部类的静态成员，但不能访问外部类的实例成员。

   public class OuterClass {
       private static int outerStaticVariable = 5;
       
       public static class StaticInnerClass {
           public void display() {
               System.out.println("Outer static variable: " + outerStaticVariable);
           }
       }
   }

   // 使用静态内部类
   public class Main {
       public static void main(String[] args) {
           OuterClass.StaticInnerClass inner = new OuterClass.StaticInnerClass();
           inner.display();
       }
   }

以上是对不同类型的内部类的简单示例。每种内部类都有其特定的应用场景和用途，可以根据实际需求选择合适的内部类类型来实现代码的设计和功能。