zoukankan      html  css  js  c++  java
  • Java内部类、静态嵌套类、局部内部类、匿名内部类

    Nested classes are further divided into two types:

    1. static nested classes: If the nested class is static, then it’s called static nested class. Static nested classes can access only static members of the outer class. Static nested class is same as any other top-level class and is nested for only packaging convenience.

      Static class object can be created with following statement:

      1
      2
      OuterClass.StaticNestedClass nestedObject =
           new OuterClass.StaticNestedClass();

      静态嵌套类:如果嵌套类是静态的,则称作静态嵌套类。静态嵌套类只能访问外部类的静态成员。

    2. java inner class: Any non-static nested class is known as inner class. Inner classes are associated with the object of the class and they can access all the variables and methods of the outer class. Since inner classes are associated with instance, we can’t have any static variables in them. Object of inner class are part of the outer class object and to create an instance of inner class, we first need to create instance of outer class.

      Inner classes can be instantiated like this:

      1
      2
      OuterClass outerObject = new OuterClass();
      OuterClass.InnerClass innerObject = outerObject.new InnerClass();

    There are two special kinds of java inner classes.

    1. local inner class: If a class is defined in a method body, it’s known as local inner class. Since local inner class is not associated with Object, we can’t use private, public or protected access modifiers with it. The only allowed modifiers are abstract or final. A local inner class can access all the members of the enclosing class and local final variables in the scope it’s defined.

      Local inner class can be defined as:

      1
      2
      3
      4
      5
      6
      7
      public void print() {
              //local inner class inside the method
              class Logger {
                  String name;
              }
              //instantiate local inner class in the method to use
              Logger logger = new Logger();
    2. anonymous inner class: A local inner class without name is known as anonymous inner class. An anonymous class is defined and instantiated in a single statement. Anonymous inner class always extend a class or implement an interface. Since an anonymous class has no name, it is not possible to define a constructor for an anonymous class. Anonymous inner classes are accessible only at the point where it is defined.
      It’s a bit hard to define how to create anonymous inner class, we will see it’s real time usage in test program below.

    Here is a java class showing how to define java inner class, static nested class, local inner class and anonymous inner class.

     
    OuterClass.java
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    package com.journaldev.nested;
     
     
    import java.io.File;
    import java.io.FilenameFilter;
     
     
    public class OuterClass {
         
        private static String name = "OuterClass";
        private int i;
        protected int j;
        int k;
        public int l;
     
        //OuterClass constructor
        public OuterClass(int i, int j, int k, int l) {
            this.i = i;
            this.j = j;
            this.k = k;
            this.l = l;
        }
     
     
        public int getI() {
            return this.i;
        }
     
     
        //static nested class, can access OuterClass static variables/methods
        static class StaticNestedClass {
            private int a;
            protected int b;
            int c;
            public int d;
     
     
            public int getA() {
                return this.a;
            }
     
     
            public String getName() {
                return name;
            }
        }
     
     
        //inner class, non static and can access all the variables/methods of outer class
        class InnerClass {
            private int w;
            protected int x;
            int y;
            public int z;
     
     
            public int getW() {
                return this.w;
            }
     
     
            public void setValues() {
                this.w = i;
                this.x = j;
                this.y = k;
                this.z = l;
            }
     
     
            @Override
            public String toString() {
                return "w=" + w + ":x=" + x + ":y=" + y + ":z=" + z;
            }
     
     
            public String getName() {
                return name;
            }
        }
     
     
        //local inner class
        public void print(String initial) {
            //local inner class inside the method
            class Logger {
                String name;
     
     
                public Logger(String name) {
                    this.name = name;
                }
     
     
                public void log(String str) {
                    System.out.println(this.name + ": " + str);
                }
            }
     
            Logger logger = new Logger(initial);
            logger.log(name);
            logger.log("" + this.i);
            logger.log("" + this.j);
            logger.log("" + this.k);
            logger.log("" + this.l);
        }
     
     
        //anonymous inner class
        public String[] getFilesInDir(String dir, final String ext) {
            File file = new File(dir);
            //anonymous inner class implementing FilenameFilter interface
            String[] filesList = file.list(new FilenameFilter() {
     
                @Override
                public boolean accept(File dir, String name) {
                    return name.endsWith(ext);
                }
     
            });
            return filesList;
        }
    }

    Here is the test program showing how to instantiate and use nested class in java.

    NestedClassTest.java
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    package com.journaldev.nested;
     
    import java.util.Arrays;
    //nested classes can be used in import for easy instantiation
    import com.journaldev.nested.OuterClass.InnerClass;
    import com.journaldev.nested.OuterClass.StaticNestedClass;
     
    public class NestedClassTest {
     
        public static void main(String[] args) {
            OuterClass outer = new OuterClass(1,2,3,4);
             
            //static nested classes example
            StaticNestedClass staticNestedClass = new StaticNestedClass();
            StaticNestedClass staticNestedClass1 = new StaticNestedClass();
             
            System.out.println(staticNestedClass.getName());
            staticNestedClass.d=10;
            System.out.println(staticNestedClass.d);
            System.out.println(staticNestedClass1.d);
             
            //inner class example
            InnerClass innerClass = outer.new InnerClass();
            System.out.println(innerClass.getName());
            System.out.println(innerClass);
            innerClass.setValues();
            System.out.println(innerClass);
             
            //calling method using local inner class
            outer.print("Outer");
             
            //calling method using anonymous inner class
            System.out.println(Arrays.toString(outer.getFilesInDir("src/com/journaldev/nested", ".java")));
             
            System.out.println(Arrays.toString(outer.getFilesInDir("bin/com/journaldev/nested", ".class")));
        }
     
    }

    Here is the output of above program:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    OuterClass
    10
    0
    OuterClass
    w=0:x=0:y=0:z=0
    w=1:x=2:y=3:z=4
    Outer: OuterClass
    Outer: 1
    Outer: 2
    Outer: 3
    Outer: 4
    [NestedClassTest.java, OuterClass.java]
    [NestedClassTest.class, OuterClass$1.class, OuterClass$1Logger.class, OuterClass$InnerClass.class, OuterClass$StaticNestedClass.class, OuterClass.class]

    Notice that when OuterClass is compiled, separate class files are created for inner class, local inner class and static nested class.

    Benefits of Java Nested Class

    1. If a class is useful to only one class, it makes sense to keep it nested and together. It helps in packaging of the classes.
    2. Nested classes increases encapsulation. Note that inner classes can access outer class private members and at the same time we can hide inner class from outer world.
    3. Nesting small classes within top-level classes places the code closer to where it is used and makes code more readable and maintainable.
  • 相关阅读:
    语言:障碍与桥梁(探索语言的本质、如何避免语言上的误解)
    知觉:看到什么就是什么(怎么避免误解别人的行为)
    沟通和认同:自我的塑造与展现(如何认识自我,如何袒露自我,如何回应尴尬问题)
    人际沟通入门(认清沟通高手的特质)
    人际沟通与社交媒体(媒介沟通的优缺点)
    javascript中的this值
    Javascript 模块化编程 --RequireJs
    datetime与int 转换通用函数
    c# 读写cookie 通用函数
    分类组件
  • 原文地址:https://www.cnblogs.com/CoolRandy/p/3675987.html
Copyright © 2011-2022 走看看