Java - 内部类

Java - 内部类 首页 / Java入门教程 / Java - 内部类

在本章中,无涯教程将讨论Java的内部类。

在Java中,就像方法一样,类的变量也可以将另一个类作为其成员。内部编写的类称为内部类,保存内部类的类称为外部类。

无涯教程网

下面是编写内部类的语法。在这里,类Outer_Demo是外部类,而类Inside_Demo是内部类。

class Outer_Demo {
   class Inner_Demo {
   }
} 
内部类es

内部类有三种类型,具体取决于定义它们的方式和位置。他们是-

  • Inner Class(内部类)
  • Method-local Inner Class (本地方法内部类)
  • Anonymous Inner Class (匿名内部类)

内部类

创建内部类非常简单。您只需要在类中编写一个类,与类不同,内部类可以是私有的,一旦声明内部类私有,就不能从类外部的对象访问它。

下面是创建内部类并访问它的程序。在给定的示例中,无涯教程将内部类设置为私有(private),并通过一个方法访问该类。

class Outer_Demo {
   int num;
   
   //内部类
   private class Inner_Demo {
      public void print() {
         System.out.println("This is an inner class");
      }
   }
   
   //从内部的方法访问他的内部类
   void display_Inner() {
      Inner_Demo inner = new Inner_Demo();
      inner.print();
   }
}
   
public class My_class {

   public static void main(String args[]) {
      //实例化外部类
      Outer_Demo outer = new Outer_Demo();
      
      //访问 display_Inner() 方法。
      outer.display_Inner();
   }
}

在这里您可以观察到Outer_Demo是外部类,Inside_Demo是内部类,Display_Inside()是内部类的方法,并且这个方法是从main方法调用的。

如果编译并执行上述程序,将得到以下输出-

This is an inner class.

访问私有方法

如前所述,内部类也用于访问类的私有成员。在其中编写一个内部类,从内部类中的方法返回私有成员,如getValue(),最后从另一个类调用内部类的getValue()方法。

要化内部类,最初必须化外部类。此后,使用外部类的对象 ,下面是化内部类的方法。

Outer_Demo outer=new Outer_Demo();
Outer_Demo.Inner_Demo inner=outer.new Inner_Demo();

下面的程序显示了如何使用内部类访问类的私有成员。

class Outer_Demo {
   //外部类的私有变量
   private int num = 175;  
   
   //内部类
   public class Inner_Demo {
      public int getNum() {
         System.out.println("This is the getnum method of the inner class");
         return num;
      }
   }
}

public class My_class2 {

   public static void main(String args[]) {
      //实例化外部类
      Outer_Demo outer = new Outer_Demo();
      
      //实例化内部类
      Outer_Demo.Inner_Demo inner = outer.new Inner_Demo();
      System.out.println(inner.getNum());
   }
}

如果编译并执行上述程序,将得到以下输出-

This is the getnum method of the inner class: 175

内部类

在Java中,无涯教程可以在一个方法中编写一个类,这将是一个局部类型。与局部变量一样,内部类的作用域受到方法的限制。

方法本地内部类只能在定义内部类的方法中化。下面的程序显示了如何使用方法局部内部类。

public class Outerclass {
   //外部类的实例方法
   void my_Method() {
      int num = 23;

      //方法局部内部类
      class MethodInner_Demo {
         public void print() {
            System.out.println("This is method inner class "+num);	   
         }   
      } //内部类结束
	   
      //访问内部类
      MethodInner_Demo inner = new MethodInner_Demo();
      inner.print();
   }
   
   public static void main(String args[]) {
      Outerclass outer = new Outerclass();
      outer.my_Method();	   	   
   }
}

如果编译并执行上述程序,将得到以下输出-

This is method inner class 23

匿名内部类

没有类名声明的内部类称为匿名内部类,通常,只要需要重写类或接口的方法,就会使用它们。匿名内部类的语法如下所示:

AnonymousInner an_inner=new AnonymousInner() {
   public void my_method() {
      ........
      ........
   }   
};

下面的程序显示如何使用匿名内部类重写类的方法。

abstract class AnonymousInner {
   public abstract void mymethod();
}

public class Outer_class {

   public static void main(String args[]) {
      AnonymousInner inner = new AnonymousInner() {
         public void mymethod() {
            System.out.println("This is an example of anonymous inner class");
         }
      };
      inner.mymethod();	
   }
}

如果编译并执行上述程序,将得到以下输出-

This is an example of anonymous inner class

以同样的方式,您可以使用匿名内部类覆盖具体类的方法以及接口。

匿名内部类参数

下面是将匿名内部类作为方法参数语法

链接:https://www.learnfk.comhttps://www.learnfk.com/java/java-innerclasses.html

来源:LearnFk无涯教程网

obj.my_Method(new My_Class() {
   public void Do() {
      .....
      .....
   }
});

下面的程序显示如何将匿名内部类作为方法参数传递。

//interface
interface Message {
   String greet();
}

public class My_class {
   //接受接口Message对象的方法
   public void displayMessage(Message m) {
      System.out.println(m.greet() +
         ", This is an example of anonymous inner class as an argument");  
   }

   public static void main(String args[]) {
      //实例化类
      My_class obj = new My_class();

      //将匿名内部类作为参数传递
      obj.displayMessage(new Message() {
         public String greet() {
            return "Hello";
         }
      });
   }
}

如果编译并执行上述程序,它将给出以下输出-

Hello, This is an example of anonymous inner class as an argument

静态内部类

静态内部类是一个内部类,它是外部类的静态成员。可以使用其他静态成员在不化外部类的情况下访问它。

class MyOuter {
   static class Nested_Demo {
   }
}

静态内部类与化内部类有点不同。下面的程序显示了如何使用静态内部类。

public class Outer {
   static class Nested_Demo {
      public void my_method() {
         System.out.println("This is my nested class");
      }
   }
   
   public static void main(String args[]) {
      Outer.Nested_Demo nested = new Outer.Nested_Demo();	 
      nested.my_method();
   }
}

如果编译并执行上述程序,将得到以下输出-

This is my nested class

祝学习愉快!(内容编辑有误?请选中要编辑内容 -> 右键 -> 修改 -> 提交!)

技术教程推荐

Service Mesh实践指南 -〔周晶〕

深入浅出gRPC -〔李林锋〕

后端技术面试 38 讲 -〔李智慧〕

摄影入门课 -〔小麥〕

如何看懂一幅画 -〔罗桂霞〕

实用密码学 -〔范学雷〕

超级访谈:对话玉伯 -〔玉伯〕

手把手带你写一个MiniSpring -〔郭屹〕

结构沟通力 -〔李忠秋〕

好记忆不如烂笔头。留下您的足迹吧 :)