Hi, 请登录     我要注册     找回密码
当前位置：国外主机测评 - 国外VPS，国外服务器，国外云服务器，测评及优惠码 Java教程 正文

Java 嵌套类

2024-04-01 分类：Java教程

Java教程 – Java嵌套类

在任何类外部声明的类是顶级类。嵌套类是声明为其他类或作用域的成员的类。

有四种嵌套类:

  • 静态成员类
  • 非静态成员类
  • 匿名类
  • 局部类

Java匿名类

匿名类是没有名称并同时声明的类。您可以实例化一个匿名类，在其中指定一个表达式是合法的。

一个匿名类实例只能访问局部最终变量和最终参数。

如何定义一个匿名类？

abstract class People {
  abstract void speak();
}

public class Main {
  public static void main(final String[] args) {
    new People() {
      String msg = "test";

      @Override
      void speak() {
        System.out.println(msg);
      }
    }.speak();
  }
}

上面的代码生成以下结果。


例子

下面的代码声明和实例化一个实现接口的匿名类。

interface People {
  abstract void speak();
}

public class Main {
  public static void main(final String[] args) {
    new People() {
      String msg = (args.length == 1) ? args[0] : "nothing to say";

      @Override
      public void speak() {
        System.out.println(msg);
      }
    }.speak();
  }
}

上面的代码生成以下结果。

Java局部类

本地类是在声明局部变量的任何地方声明的类。局部类与局部变量具有相同的范围。

一个本地类有一个名称，可以重复使用。本地类实例可以访问周围范围的本地最终变量和最终参数。

Java局部类

class MyClass {
  void myMethod(final int x) {
    final int y = x;

    class LocalClass {
      int a = x;
      int b = y;
    }

    LocalClass lc = new LocalClass();
    System.out.println(lc.a);
    System.out.println(lc.b);
  }
}

public class Main {
  public static void main(String[] args) {
    MyClass ec = new MyClass();
    ec.myMethod(10);
  }
}

上面的代码生成以下结果。

例2

下面的代码声明了一个Iterator接口和Iter内部类。

class Item{
  private String name;
  private String value;

  public Item(String n, String v){
    name = n;
    value = v;
  }
  public String toString(){
    return name + value;
  }
}

interface Iterator {
  boolean hasMoreElements();

  Object nextElement();
}

class ItemManager {
  private Item[] itemArray;
  private int index = 0;

  ItemManager(int size) {
    itemArray = new Item[size];
  }

  Iterator iterator() {
    class Iter implements Iterator {
      int index = 0;

      @Override
      public boolean hasMoreElements() {
        return index < itemArray.length;
      }

      @Override
      public Object nextElement() {
        return itemArray[index++];
      }
    }
    return new Iter();
  }

  void add(Item item) {
    itemArray[index++] = item;
  }
}

public class Main {
  public static void main(String[] args) {
    ItemManager itemManager = new ItemManager(5);
    itemManager.add(new Item("#1", "A"));
    itemManager.add(new Item("#2", "B"));
    itemManager.add(new Item("#3", "C"));
    Iterator iter = itemManager.iterator();
    while (iter.hasMoreElements()){
      System.out.println(iter.nextElement());
    }

  }
}

输出:

Java成员类

成员类是封闭类的成员。成员类的每个实例都与封闭类的实例相关联。

成员类的实例方法可以调用实例方法封闭类和访问封闭类实例的非静态字段。

以下代码具有一个名为 EnclosingClass 的外部类和非静态成员类命名为 EnclosedClass 。

class EnclosingClass {
  private int outerVariable;

  private void privateOuterMethod() {
    System.out.println(outerVariable);
  }

  class EnclosedClass {
    void accessEnclosingClass() {
      outerVariable = 1;
      privateOuterMethod();
    }
  }
}

public class Main {
  public static void main(String[] args) {
    EnclosingClass ec = new EnclosingClass();
    ec.new EnclosedClass().accessEnclosingClass(); // Output: 1
  }
}

上面的代码生成以下结果。

例3

下面的代码使用内部类ItemList来存储项目。

class Item {
  private String name;
  private String desc;

  Item(String name, String desc) {
    this.name = name;
    this.desc = desc;
  }

  String getName() {
    return name;
  }

  String getDesc() {
    return desc;
  }

  @Override
  public String toString() {
    return "Name = " + getName() + ", Desc = " + getDesc();
  }
}

class ItemManager {
  private ItemList itemList;
  private int index = 0;

  ItemManager() {
    itemList = new ItemList(2);
  }

  boolean hasMoreElements() {
    return index < itemList.size();
  }

  Item nextElement() {
    return itemList.get(index++);
  }

  void add(Item item) {
    itemList.add(item);
  }

  private class ItemList {
    private Item[] itemArray;
    private int index = 0;

    ItemList(int initSize) {
      itemArray = new Item[initSize];
    }

    void add(Item item) {
      if (index >= itemArray.length) {
        Item[] temp = new Item[itemArray.length * 2];
        for (int i = 0; i < itemArray.length; i++)
          temp[i] = itemArray[i];
        itemArray = temp;
      }
      itemArray[index++] = item;
    }

    Item get(int i) {
      return itemArray[i];
    }

    int size() {
      return index;
    }
  }
}

public class Main {
  public static void main(String[] args) {
    ItemManager itemManager = new ItemManager();
    itemManager.add(new Item("1", "A"));
    itemManager.add(new Item("2", "B"));
    itemManager.add(new Item("3", "C"));
    while (itemManager.hasMoreElements())
      System.out.println(itemManager.nextElement());
  }
}

上面的代码生成以下结果。

例4

以下程序说明如何定义和使用内部类。

 
class Outer {
  int outer_x = 100;
  void test() {
    Inner inner = new Inner();
    inner.display();
  }
  class Inner {
    void display() {
      System.out.println("display: outer_x = " + outer_x);
    }
  }
}
public class Main {
  public static void main(String args[]) {
    Outer outer = new Outer();
    outer.test();
  }
}

此应用程序的输出如下所示:

例5

内部类成员只能在内部类中访问，并且可能不被外部类使用。如果您尝试编译以下代码，您将收到错误消息。

 
public class Main {
  int outer_x = 100;
  // this is an inner class
  class Inner {
    int y = 10; // y is local to Inner

    void display() {
      System.out.println("display: outer_x = " + outer_x);
    }
  }

  void showy() {
    System.out.println(y); 
  }
}

当编译上面的代码:

Java静态成员类

静态成员类是封闭类的静态成员。静态成员类不能访问包含类的实例字段并调用其实例方法。

静态成员可以访问包含类的静态字段并调用其静态方法，包括私有字段和方法。

下面的代码有一个静态成员类声明。

class Demo {
  public static void main(String[] args) {
    Main.EnclosedClass.accessEnclosingClass(); 
    Main.EnclosedClass ec = new Main.EnclosedClass();
    ec.accessEnclosingClass2(); 
  }
}

class Main {
  private static int outerVariable;

  private static void privateStaticOuterMethod() {
    System.out.println(outerVariable);
  }

  static void staticOuterMethod() {
    EnclosedClass.accessEnclosingClass();
  }

  static class EnclosedClass {
    static void accessEnclosingClass() {
      outerVariable = 1;
      privateStaticOuterMethod();
    }

    void accessEnclosingClass2() {
      staticOuterMethod();
    }
  }
}

静态成员类可以声明其封闭类的多个实现。

例6

下面的代码声明一个 Rectangle 类，它使用静态成员类为不同的数据类型提供 Rectangle 实现，一个是 double 类型另一个是 float 类型。

abstract class Rectangle {
  abstract double getX();

  abstract double getY();

  abstract double getWidth();

  abstract double getHeight();

  static class Double extends Rectangle {
    private double x, y, width, height;

    Double(double x, double y, double width, double height) {
      this.x = x;
      this.y = y;
      this.width = width;
      this.height = height;
    }

    double getX() {
      return x;
    }

    double getY() {
      return y;
    }

    double getWidth() {
      return width;
    }

    double getHeight() {
      return height;
    }
  }

  static class Float extends Rectangle {
    private float x, y, width, height;

    Float(float x, float y, float width, float height) {
      this.x = x;
      this.y = y;
      this.width = width;
      this.height = height;
    }

    double getX() {
      return x;
    }

    double getY() {
      return y;
    }

    double getWidth() {
      return width;
    }

    double getHeight() {
      return height;
    }
  }

  private Rectangle() {
  }

  boolean contains(double x, double y) {
    return (x >= getX() && x < getX() + getWidth()) && (y >= getY() && y < getY() + getHeight());
  }
}

public class Main {
  public static void main(String[] args) {
    Rectangle r = new Rectangle.Double(10.0, 10.0, 20.0, 30.0);
    r = new Rectangle.Float(10.0f, 10.0f, 20.0f, 30.0f);
  }
}
版权声明：本文采用知识共享 署名4.0国际许可协议 [BY-NC-SA] 进行授权
文章名称：《Java 嵌套类》
文章链接：https://zhuji.vsping.com/293194.html
本站资源仅供个人学习交流，请于下载后24小时内删除，不允许用于商业用途，否则法律问题自行承担。
分享到

相关推荐

热门文章