1. 全栈程序员必看首页

java 静态内部类的使用「建议收藏」

全栈程序员-用户IM • • 未分类

java 静态内部类的使用「建议收藏」java静态内部类的使用

大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE稳定放心使用

分享一下我老师大神的人工智能教程！零基础，通俗易懂！http://blog.csdn.net/jiangjunshow

也欢迎大家转载本篇文章。分享知识，造福人民，实现我们中华民族伟大复兴！

               

Java基础第十二讲：面向对象基础（六）[内部类]

http://android.yaohuiji.com/archives/3247

本讲内容：内部类

Java语言允许在类中再定义类，这种在其它类内部定义的类就叫内部类。内部类又分为：常规内部类、局部内部类、匿名内部类和静态嵌套类四种。我们内部类的知识在Android手机开发中经常用到。

一、常规内部类

所谓常规内部类，或者说内部类，指的就是除去后面三种之外的内部类（这算什么解释。。。）

先写一个最简单的内部类的例子，大家感觉一下：

1 public classOuter {
2     publicclass Inner{
3     }
4 }

编译一下，我们看到目录中出现了两个class文件，其中有一个文件名叫做Outer$Inner.class，带了一个$符号，这个特点让我们很容易的认出来这是内部类编译后的class文件。

K6DP_~XUH}@$_Y$ZEYMFE@T

再写一个稍微复杂一点的内部类：

01 public classOuter {   
02  
03     privateint x=1;
04  
05     publicOuter(){
06         System.out.println("Outer initial");
07     }
08  
09     publicclass Inner{
10  
11         publicInner(){
12             System.out.println("Inner initial");
13         }
14  
15         privateint x=2;
16  
17         public void add(){
18             intx=3;
19             System.out.println(x);
20             System.out.println(this.x);
21             System.out.println(Outer.this.x);
22         }
23  
24     }
25  
26     publicstatic void main(String[] args){
27         Inner inner =new Outer().newInner();
28         inner.add();
29     }
30 }

我们编译以后，运行一下看看：

 image

在上面的例子里我们可以清晰的看到：

  1. 内部类就像一个实例成员一样存在于外部类中。
  2. 内部类可以访问外部类的所有成员就想访问自己的成员一样没有限制。
  3. 内部类中的this指的是内部类的实例对象本身，如果要用外部类的实例对象就可以用类名.this的方式获得。
  4. 内部类对象中不能有静态成员，原因很简单，内部类的实例对象是外部类实例对象的一个成员。

下面我们再小结一下内部类的创建方法：

  1. 在外部类的内部，可以用 Inner inner = new Inner(); 方法直接创建
  2. 在外部类外部，必须先创建外部类实例，然后再创建内部类实例，除了上面 Inner inner = new Outer().new Inner()的写法以外，还有 Outer outer = new Outer(); Inner inner = outer.new Inner();的写法

 

二、局部内部类

我们也可以把类定义在方法内部，这时候我们称这个类叫局部内部类。

我们再看一个例子：

01 public classOuter {
02  
03     intx =1;
04     publicvoid doSomething(){
05         finalint y=2;
06         classInner{
07             intx =3;
08             voidprint(){
09                 intx=4;
10                 System.out.println(x);
11                 System.out.println(this.x);
12                 System.out.println(Outer.this.x);
13                 System.out.println(y);
14             }
15         }
16         Inner inner =new Inner();
17         inner.print();
18     }
19  
20     publicstatic void main(String[] args){
21         Outer outer =new Outer();
22         outer.doSomething();
23     }
24 }

运行程序，查看结果：

image

我们通过上面这里例子也可以看到下面几点：

  1. 局部内部类的地位和方法内的局部变量的位置类似，因此不能修饰局部变量的修饰符也不能修饰局部内部类，譬如public、private、protected、static、transient等
  2. 局部内部类只能在声明的方法内是可见的，因此定义局部内部类之后，想用的话就要在方法内直接实例化，记住这里顺序不能反了，一定是要先声明后使用，否则编译器会说找不到。
  3. 局部内部类不能访问定义它的方法内的局部变量，除非这个变量被定义为final 。

是不是有点不好理解？关于为什么用final修饰以后就可以用了，我打算专门在番外篇里专门写一篇博客给你讲清楚，先记住吧。

三、匿名内部类

当我们把内部类的定义和声明写到一起时，就不用给这个类起个类名而是直接使用了，这种形式的内部类根本就没有类名，因此我们叫它匿名内部类。

我们再看一个有趣的例子：

01 public classDog {
02  
03     publicinterface Pet {
04  
05         publicvoid beFriendly();
06         publicvoid play();
07  
08     }
09  
10     publicstatic void main(String[] args){
11  
12         Pet dog =new Pet(){
13             @Override
14             publicvoid beFriendly() {
15                 System.out.println("蹭蹭你^_^");
16             }
17             @Override
18             publicvoid play() {
19                 System.out.println("把飞盘叼给你，逼你把飞盘丢出去，然后它再捡回来让你继续扔，连续500次^_^");
20             }
21         };
22  
23         dog.beFriendly();
24         dog.play();
25  
26     }
27 }

编译和运行程序，查看结果：

image

竟然编译和运行都很正常，我们知道抽象类和接口肯定无法实例化的，因此刚才的例子肯定有点意思：

  1. 第一匿名内部类可以是个接口，这个没什么好奇怪的哈。
  2. 第12行到第21行是一个语句，就是定义了一个对象，因此21行大括号后面有个分号。
  3. 匿名内部类用 new Pet(){ … } 的方式把声明类的过程和创建类的实例的过程合二为一。
  4. 匿名内部类可以是某个类的继承子类也可以是某个接口的实现类。

好吧我们再看一个例子，方法参数内的匿名内部类：

01 public classDog {
02  
03     staticabstract class Ball {
04         abstractString getName();
05     }
06  
07     voidplay(Ball b){
08         System.out.println(b.getName());
09     }
10  
11     publicstatic void main(String[] args){
12         Dog dog =new Dog();
13  
14         dog.play(newBall(){
15             @Override
16             String getName() {
17                 return"qiu qiu";
18             }});
19     }
20 }

编译和运行以后的截图我就不给你了，返回值就是“qiu qiu”。

从第14行到第18行是一句话，就是执行一个play方法，而这个方法的参数就由一个匿名内部类的实例来提供。

四、静态嵌套类

为了让你感觉舒服一些，我们也把最简单的内部类放在最后讲。

当一个内部类前面用static修饰时，我们称之为静态嵌套类或者说静态内部类。

上面的例子里其实我们已经看到过静态嵌套类了，下面我们再举一个例子：

01 public classOuter {
02  
03     staticint x =1;
04  
05     staticclass Nest {
06  
07         voidprint(){
08             System.out.println("Nest "+x);
09         }
10     }
11  
12     publicstatic void main(String[] args){
13         Outer.Nest nest =new Outer.Nest();
14         nest.print();
15     }
16 }

因为静态嵌套类和其他静态方法一样只能访问其它静态的成员，而不能访问实例成员。因此静态嵌套类和外部类（封装类）之间的联系就很少了，他们之间可能也就是命名空间上的一些关联。上面例子中你需要注意的就是静态嵌套类的声明方法 new Outer.Nest() 连续写了两个类名，以至于我们都怀疑前面的Outer是个包名了，好在包名一般都小写的，要不还真分不清……

再强调一遍，内部类在Android中应用的非常多，理解和使用好显得蛮重要。好了，本讲就到这里。

如何应用Java的静态内部类

http://java.chinaitlab.com/oop/787330.html

在上一小节我们讨论了内部类，即在一个类中包含有另外一个或者多个类（见本书12.3.3小节）。与内部类相似，静态内部类指在一个类的内部包含有另外一个或者多个静态类。例如：
 
public class OuterClass {
    …
    static class StaticInnerClass1 {            //内部静态类
        //只可以访问OuterClass的静态成员
        …
    }                                           //StaticInnerClass结束
    …                            
    static class StaticInnerClassN {            //更多静态内部类
       //只可以访问OuterClass的静态成员
       …
    }                                           //StaticInnerClassN结束
}  //OuterClass结束
 
       与一般内部类不同，在静态代码中不能够使用this操作，所以在静态内部类中只可以访问外部类的静态变量和静态方法。使用静态内部类的目的和使用内部类相同。如果一个内部类不依赖于其外部类的实例变量，或与实例变量无关，则选择应用静态内部类。
如下例子演示怎样使用静态内部类：
 
///完整程序存在本书配套资源目录Ch12名为StaticInnerClassTest.java
public class StaticInnerClassTest {
    public static void main( String args[] ) {
        OuterClass2 outer = new OuterClass2();
        OuterClass2.StaticInnerClass.innerMethod();   

                                                //调用静态内部类的静态方法
        OuterClass2.outerMethod();
        //创建静态内部类对象
        OuterClass2.StaticInnerClass staticInner = new OuterClass2.StaticInnerClass();
        int num = staticInner.innerMethod2();   //调用静态内部类实例方法
    }
}
class OuterClass2 {                             //外部类
    private double x = 0.0;                     //内部静态类不可以访问外部类实                                              例变量
    static private int n = 10;                  //外部类静态变量
    static void outerMethod() {                 //外部类静态方法
        System.out.println(“from OuterClass…”);
    }
    void outerMethod2() {
        System.out.println(“from OuterClass’ instance method2()…”);
    }
    static class StaticInnerClass {             //静态内部类
        static private int m = 5;               //静态内部类静态变量
        static void innerMethod() {             //静态内部类静态方法
            int sum;
            n = 20;                             //只可以访问外部类静态变量
            sum = n + m;
            System.out.println(“from InnerClass sum = ” + sum);
            outerMethod();                      //只可以调用外部类静态方法
       }
        int innerMethod2() {
            n = 100;
            outerMethod();
            System.out.println(“from InnerMethod2() n = ” + n);
            return n;
        }
   }       //静态内部类结束
}           //外部类结束
 
如同不用创建对象就可调用静态方法一样，上例静态内部类中的静态方法利用：
 
OuterClass2.StaticInnerClass.innerMethod(); //静态内部类调用其静态方法
 
来调用。注意，可以在静态内部类的方法中，直接访问外部类的静态变量n和调用静态方法outerMethod()。但不允许访问外部类的实例变量x以及实例方法outerMethod2()。
       静态内部类中也可以提供实例方法，如：
 
    static class StaticInnerClass {
        int innerMethod2() {
            n = 100;                        //只可访问外部类静态变量
            outerMethod();                  //只可调用外部类静态方法
            System.out.println(“from InnerMethod2() n = ” + n);
            return n;
        }
    }       //静态内部类结束
 
       静态内部类的实例方法中亦只允许访问外部类的静态成员。
可以使用下列语法格式创建一个静态内部类对象并且调用其实例方法，以及静态方法：
 
OuterClass2.StaticInnerClass staticInner = new OuterClass2.StaticInner Class();                                 //创建静态内部类对象
int num = staticInner.innerMethod2();       //调用实例方法
staticInner.innerMethod();                  //调用其静态方法

 

java 静态内部类的使用

http://blog.csdn.net/xys_777/article/details/6755836

package Chapter10;public class StaticInternal {    private static String name = "\"聂庆亮\"";    public static void setStatic(String n) {        // 外部类的非静态方法        System.out.println("[现在访问的是外部类的静态方法!]");        name = n;    }    static class InnerClass_2 {            // 静态内部类开始        String address, mail;        // 声明String类型变量        long phoneNum;        // 声明long类型变量        int qq;                // 声明int类型变量        static void getStatic() {    // 静态内部类的静态方法            System.out.println("[访问外部类的静态变量] name = " + name);            setStatic("尹继平");     // 访问外部类的静态方法        }        // 静态内部类的非静态方法        public void setString(String address, String mail) {            System.out.println("1.静态内部类的带String型参数的非静态主法");            this.address = address;            this.mail = mail;        }        public void setInt(long phoneNum, int qq) {            System.out.println("2.静态内部类的带int型参数的非静态主法!");            this.phoneNum = phoneNum;            this.qq = qq;        }    }                            // 静态内部类结束    public void setValue() {             // 外部类访问静态内部类的静态成员：内部类.静态成员        InnerClass_2.getStatic();         // 访问静态内部类的静态方法        InnerClass_2 inner = n
给我老师的人工智能教程打call！http://blog.csdn.net/jiangjunshow

  
  
  

   
   
   这里写图片描述
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/183138.html原文链接：https://javaforall.cn

【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛

【官方授权 正版激活】： 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

赞 (0)
全栈程序员-用户IM全栈程序员-用户IM
0 0
blank

相关推荐

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号