程序博客网 > 战网传输数据

Java内部类、本地类、匿名类、文件类解读

来源：互联网 发布：战网传输数据 编辑：程序博客网 时间：2024/05/22 07:07
[java] view plain copy
  1. 1. 文件类  
[java] view plain copy
  1. package com.wy.jdkclass;  
  2.   
  3. public class ClassTest {  
  4.   
  5.       
  6.     /** 
  7.      * @param args 
  8.      */  
  9.     public static void main(String[] args) {  
  10.         // TODO Auto-generated method stub  
  11.         ClassTest classTest = new ClassTest();  
  12.           
  13.         // 使用文件类，这种在实际应用中比较常见作用域为全局的,在其他的类中一般都可以创建该对象  
  14.         Dog dog = new Dog();  
  15.         dog.say();  
  16.         // 输出结果为：汪汪~~  
  17.           
  18.     }  
  19. }  
  20. /** 
  21.  * 文件类 
  22.  * @author wangyang 
  23.  */  
  24. class Dog {  
  25.     void say()  
  26.     {  
  27.         System.out.println("汪汪~~");  
  28.     }  
  29. }  

这种形式的文件类，是我们平时使用最为广泛的类，这样在其他的类中调用的时候，直接用new Object()就可以了，包括调用函数等等的操作也不再赘述。

[java] view plain copy
  1. 2. 内部类  
[java] view plain copy
  1. package com.wy.jdkclass;  
  2.   
  3. public class ClassTest {  
  4.   
  5.     private static String word = "说了句话！";  
  6.     class Cat {  
  7.         public void say()  
  8.         {  
  9.             System.out.println("喵喵~~");  
  10.         }  
  11.         public void saySth()  
  12.         {  
  13.             System.out.println("喵喵~~" + word);  
  14.         }  
  15.     }  
  16.     /** 
  17.      * @param args 
  18.      */  
  19.     public static void main(String[] args) {  
  20.         // TODO Auto-generated method stub  
  21.         ClassTest classTest = new ClassTest();  
  22.           
  23.         // 使用文件类，这种在实际应用中比较常见作用域为全局的,在其他的类中一般都可以创建该对象  
  24.         Dog dog = new Dog();  
  25.         dog.say();  
  26.         // 输出结果为：汪汪~~  
  27.           
  28.           
  29.         // 使用内部类  
  30.         /** 
  31.          * 内部类，面向对象程序设计中，可以在一个类的内部定义另一个类， 
  32.          * 静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为内部类(inner)。内部类是JAVA语言的主要附加部分。 
  33.          * 内部类几乎可以处于一个类内部任何位置，可以与实例变量处于同一级，或处于方法之内，甚至是一个表达式的一部分。 
  34.          *  
  35.          * 在调用的时候内部类要通过外面这层类进行调用才行 
  36.          */  
  37.         ClassTest.Cat cat = classTest.new Cat();  
  38.         cat.say();  
  39.         // 输出结果为： 喵喵~~  
  40.           
  41.           
  42.         /** 
  43.          *  下面这段代码说明在内部类中可以直接访问内部的成员变量 
  44.          *  那么，它是如何实现的呢？  
  45.          *  是这样的，用外围类创建内部类对象时，此内部类对象会秘密的捕获一个指向外围类的引用， 
  46.          *  于是，可以通过这个引用来访问外围类的成员。  
  47.          *  通常，这些都是编译器来处理，我们看不到 
  48.          */  
  49.         ClassTest.Cat cat2 = classTest.new Cat();  
  50.         cat2.saySth();  
  51.         // 输出结果为：喵喵~~说了句话！  
  52.           
  53.           
  54.           
  55.     }  
  56.   
  57. }  
  58. /** 
  59.  * 文件类 
  60.  * @author wangyang 
  61.  */  
  62. class Dog {  
  63.     void say()  
  64.     {  
  65.         System.out.println("汪汪~~");  
  66.     }  
  67. }  
1. 内部类，面向对象程序设计中，可以在一个类的内部定义另一个类，
静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为内部类(inner)。内部类是JAVA语言的主要附加部分。
内部类几乎可以处于一个类内部任何位置，可以与实例变量处于同一级，或处于方法之内，甚至是一个表达式的一部分。


2. 内部类中可以直接访问内部的成员变量
那么，它是如何实现的呢？ 
是这样的，用外围类创建内部类对象时，此内部类对象会秘密的捕获一个指向外围类的引用，于是，可以通过这个引用来访问外围类的成员。 
通常，这些都是编译器来处理，我们看不到.


[java] view plain copy
  1. 3. 匿名内部类  
[java] view plain copy
  1. package com.wy.jdkclass;  
  2.   
  3. public class ClassTest {  
  4.   
  5.     private static String word = "说了句话！";  
  6.     class Cat {  
  7.         public void say()  
  8.         {  
  9.             System.out.println("喵喵~~");  
  10.         }  
  11.         public void saySth()  
  12.         {  
  13.             System.out.println("喵喵~~" + word);  
  14.         }  
  15.     }  
  16.     /** 
  17.      * @param args 
  18.      */  
  19.     public static void main(String[] args) {  
  20.         // TODO Auto-generated method stub  
  21.         ClassTest classTest = new ClassTest();  
  22.           
  23.         // 使用文件类，这种在实际应用中比较常见作用域为全局的,在其他的类中一般都可以创建该对象  
  24.         Dog dog = new Dog();  
  25.         dog.say();  
  26.         // 输出结果为：汪汪~~  
  27.           
  28.           
  29.         // 使用内部类  
  30.         /** 
  31.          * 内部类，面向对象程序设计中，可以在一个类的内部定义另一个类， 
  32.          * 静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为内部类(inner)。内部类是JAVA语言的主要附加部分。 
  33.          * 内部类几乎可以处于一个类内部任何位置，可以与实例变量处于同一级，或处于方法之内，甚至是一个表达式的一部分。 
  34.          *  
  35.          * 在调用的时候内部类要通过外面这层类进行调用才行 
  36.          */  
  37.         ClassTest.Cat cat = classTest.new Cat();  
  38.         cat.say();  
  39.         // 输出结果为： 喵喵~~  
  40.           
  41.           
  42.         /** 
  43.          *  下面这段代码说明在内部类中可以直接访问内部的成员变量 
  44.          *  那么，它是如何实现的呢？  
  45.          *  是这样的，用外围类创建内部类对象时，此内部类对象会秘密的捕获一个指向外围类的引用， 
  46.          *  于是，可以通过这个引用来访问外围类的成员。  
  47.          *  通常，这些都是编译器来处理，我们看不到 
  48.          */  
  49.         ClassTest.Cat cat2 = classTest.new Cat();  
  50.         cat2.saySth();  
  51.         // 输出结果为：喵喵~~说了句话！  
  52.           
  53.         // 匿名类  
  54.         /** 
  55.          * 匿名类 
  56.          * 匿名类是不能有名字的类，它们不能被引用，只能在创建时用New语句来声明它们。 
  57.          * 匿名类的声明是在编译时进行的，实例化在运行时进行，这意味着for循环中的一个new语句会创建相同匿名类的几个实例， 
  58.          * 而不是创建几个不同匿名类的一个实例。 
  59.          * 匿名类的目的是在某个地方需要特殊的实现，因此在该处编写其实现，并获取它的实例，调用它的方法。 
  60.          * 不要在匿名内部类编写其他的方法，是不可见的。 
  61.          * 形式为：new <类或接口> <类的主体> 
  62.          */  
  63.         new Object(){  
  64.             public void Say()  
  65.             {  
  66.                 System.out.println("匿名类输出");  
  67.             }  
  68.         }.Say();  
  69.         // 输出结果：匿名类输出  
  70.           
  71.         //匿名内部类重写Dog类的say()方法  
  72.         new Dog(){  
  73.             void say()  
  74.             {  
  75.                 System.out.println("<<汪汪>>");  
  76.             }  
  77.         }.say();  
  78.         // 输出结果：<<汪汪>>  
  79.           
  80.           
  81.           
  82.     }  
  83.   
  84.       
  85.       
  86.     public void testForName()  
  87.     {  
  88.         try {  
  89.             System.out.println(Class.forName("java.lang.Object"));  
  90.             System.out.println(Class.class.toString());  
  91.         } catch (ClassNotFoundException e) {  
  92.             // TODO Auto-generated catch block  
  93.             e.printStackTrace();  
  94.         }  
  95.     }  
  96. }  
  97. /** 
  98.  * 文件类 
  99.  * @author wangyang 
  100.  */  
  101. class Dog {  
  102.     void say()  
  103.     {  
  104.         System.out.println("汪汪~~");  
  105.     }  
  106. }  

匿名类是不能有名字的类，它们不能被引用，只能在创建时用New语句来声明它们。匿名类的声明是在编译时进行的，
实例化在运行时进行，这意味着for循环中的一个new语句会创建相同匿名类的几个实例，而不是创建几个不同匿名类的一个实例。
匿名类的目的是在某个地方需要特殊的实现，因此在该处编写其实现，并获取它的实例，调用它的方法。
不要在匿名内部类编写其他的方法，是不可见的。形式为：new <类或接口> <类的主体>
[java] view plain copy
  1. 本质上：匿名类是内部类的一种而已，相互之间可以进行嵌套的，可以自己尝试下效果，下面的例子中给出了部分的嵌套效果：  
[java] view plain copy
  1. package com.wy.jdkclass;  
  2.   
  3. public class ClassTest {  
  4.   
  5.     private static String word = "说了句话！";  
  6.     class Cat {  
  7.         public void say()  
  8.         {  
  9.             System.out.println("喵喵~~");  
  10.         }  
  11.         public void saySth()  
  12.         {  
  13.             System.out.println("喵喵~~" + word);  
  14.         }  
  15.     }  
  16.       
  17.     /** 
  18.      * @param args 
  19.      */  
  20.     public static void main(String[] args) {  
  21.         // TODO Auto-generated method stub  
  22.         ClassTest classTest = new ClassTest();  
  23.           
  24.         // 使用文件类，这种在实际应用中比较常见作用域为全局的,在其他的类中一般都可以创建该对象  
  25.         Dog dog = new Dog();  
  26.         dog.say();  
  27.         // 输出结果为：汪汪~~  
  28.           
  29.           
  30.         // 使用内部类  
  31.         /** 
  32.          * 内部类，面向对象程序设计中，可以在一个类的内部定义另一个类， 
  33.          * 静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为内部类(inner)。内部类是JAVA语言的主要附加部分。 
  34.          * 内部类几乎可以处于一个类内部任何位置，可以与实例变量处于同一级，或处于方法之内，甚至是一个表达式的一部分。 
  35.          *  
  36.          * 在调用的时候内部类要通过外面这层类进行调用才行 
  37.          */  
  38.         ClassTest.Cat cat = classTest.new Cat();  
  39.         cat.say();  
  40.         // 输出结果为： 喵喵~~  
  41.           
  42.           
  43.         /** 
  44.          *  下面这段代码说明在内部类中可以直接访问内部的成员变量 
  45.          *  那么，它是如何实现的呢？  
  46.          *  是这样的，用外围类创建内部类对象时，此内部类对象会秘密的捕获一个指向外围类的引用， 
  47.          *  于是，可以通过这个引用来访问外围类的成员。  
  48.          *  通常，这些都是编译器来处理，我们看不到 
  49.          */  
  50.         ClassTest.Cat cat2 = classTest.new Cat();  
  51.         cat2.saySth();  
  52.         // 输出结果为：喵喵~~说了句话！  
  53.           
  54.         // 匿名类  
  55.         /** 
  56.          * 匿名类 
  57.          * 匿名类是不能有名字的类，它们不能被引用，只能在创建时用New语句来声明它们。 
  58.          * 匿名类的声明是在编译时进行的，实例化在运行时进行，这意味着for循环中的一个new语句会创建相同匿名类的几个实例， 
  59.          * 而不是创建几个不同匿名类的一个实例。 
  60.          * 匿名类的目的是在某个地方需要特殊的实现，因此在该处编写其实现，并获取它的实例，调用它的方法。 
  61.          * 不要在匿名内部类编写其他的方法，是不可见的。 
  62.          * 形式为：new <类或接口> <类的主体> 
  63.          */  
  64.         new Object(){  
  65.             public void Say()  
  66.             {  
  67.                 System.out.println("匿名类输出");  
  68.             }  
  69.         }.Say();  
  70.         // 输出结果：匿名类输出  
  71.           
  72.         //匿名内部类重写Dog类的say()方法  
  73.         new Dog(){  
  74.             void say()  
  75.             {  
  76.                 System.out.println("<<汪汪>>");  
  77.             }  
  78.         }.say();  
  79.         // 输出结果：<<汪汪>>  
  80.           
  81.         // 在方法中也可以使用匿名内部类  
  82.         test();  
  83.           
  84.     }  
  85.   
  86.     public static void test()  
  87.     {  
  88.         // 方法中的匿名内部类  
  89.         new Object()  
  90.         {  
  91.             void say()  
  92.             {  
  93.                 System.out.println("test---say");  
  94.             }  
  95.         }.say();  
  96.           
  97.         // 方法中的内部类,只是这个内部类只能在内部调用但是不能在外层的类中进行调用  
  98.         class Person  
  99.         {  
  100.             public void say()  
  101.             {  
  102.                 // 在内部类的方法中在创建一个内部类那么看看是不是可以进行输出呢  
  103.                 System.out.println("Person say something!");  
  104.                 class PersonSon  
  105.                 {  
  106.                     public void say()  
  107.                     {  
  108.                         System.out.println("i am her son");  
  109.                     }  
  110.                 }  
  111.                 PersonSon persernSon = new PersonSon();  
  112.                 persernSon.say();  
  113.                 //照样输出  
  114.             }  
  115.         }  
  116.         Person person = new Person();  
  117.         person.say();  
  118.           
  119.     }  
  120.       
  121.       
  122.     public void testForName()  
  123.     {  
  124.         try {  
  125.             System.out.println(Class.forName("java.lang.Object"));  
  126.             System.out.println(Class.class.toString());  
  127.         } catch (ClassNotFoundException e) {  
  128.             // TODO Auto-generated catch block  
  129.             e.printStackTrace();  
  130.         }  
  131.     }  
  132. }  
  133. /** 
  134.  * 文件类 
  135.  * @author wangyang 
  136.  */  
  137. class Dog {  
  138.     void say()  
  139.     {  
  140.         System.out.println("汪汪~~");  
  141.     }  
  142. }  

0 0
战网传输数据 战网传输数据
原创粉丝点击
热门IT博客
mac连不到app storemac连不到app store
上瘾网络剧在线播放上瘾网络剧在线播放
天盾数据恢复软件
hydra软件免费下载
查看端口是否被禁用
dw软件怎么用
mac如何添加字体到ps
大推力火箭 知乎
aecc软件下载
取消地级市 知乎
李羊羊seo
usbtrace的数据写狗
php 五子棋源代码
数据库作图软件
空气净化器买哪个知乎
街机模拟器mac版
php源码加密
cocostudio mac
mac网络恢复系统 dns
数据上报系统
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 五行缺木水怎么办 八字克母 怎么办 小孩八字弱怎么办 八字好大运不好怎么办 身弱走财运怎么办 婚姻不如意怎么办 老婆花钱大手大脚怎么办 猫在汽车底盘怎么办 机动车撞伤行人怎么办 刮胡子刮出血怎么办 微博图床挂了怎么办 手机卡顿怎么办 吃鸡重复名怎么办 文件名无效怎么办 八字大怎么办 龅牙矫正暴牙怎么办 智齿牙齿烂个洞怎么办 没生意怎么办 在家遇到蛇怎么办 小学生遇蛇怎么办 遇到蛇应该怎么办 孙子喜欢奶奶怎么办 澳门蓝卡丢了怎么办 商标异议不成功怎么办 营业执照加名称怎么办 肇事者不接电话怎么办 车险全责方不赔怎么办 亚马逊跟卖怎么办 大学生没钱恋爱怎么办 苔藓变黄怎么办 户口黑户怎么办 公司注销欠税怎么办 个体怎么办核名 手机更新不了怎么办 手机无法更新怎么办 打拳被打死怎么办 剪辑画面跳怎么办 没劳动合同辞退怎么办 打架对面要叫人怎么办 狗打架怎么办? 狗喜欢打架怎么办

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里