Cyh的博客

Email:kissyan4916@163.com
posts - 26, comments - 19, trackbacks - 0, articles - 220
    这几天通过看书,浏览别人博客的方式学习了一下内部类,以前也学过,但是用的比较少所以总是忘记。。
今天把自己现在所了解到的一点点关于内部类的知识记录下来,日后又忘记的时候就看看
    废话少说,首先内部类分为 成员内部类,局部内部类,静态内部类,匿名累不累(累!)
   
    先来看看成员内部类吧:
   
public class RyanTestInner {

    
public int a = 10;
    
    
private String me = "I Love 碧昂斯, very Love";
    String name 
= "碧昂斯";
    
public static void outF1(){
        
    }  
    
class InnerClass01 {
        
// static int mygod = 5; 成员内部类中不能声明静态成员变量和方法
       
int a= 100;
       
public void Innerf1() {
             System.out.println(a); 
//访问内部类自己的成员变量
             System.out.println(RyanTestInner.this.a);//访问外部类的成员变量
             System.out.println(name); //访问外部类的属性
             System.out.println(me); //访问外部类私有属性
        }
    }
    
    
public InnerClass01 returnInnerClass01() {
        
        
return new InnerClass01();
    }
   
  
    
public static void main(String[] args) {
         RyanTestInner rti 
= new RyanTestInner();
         rti.returnInnerClass01().Innerf1();
    }
}

在来看看局部内部类,也就是生命在方法中的内部类:
package com.yan.test;

public class RyanTestInner {

    public void outF2() {
        
int a = 100;
        
final String b = "kiss beauty"
        
class InnerClass1 {
          
        
int a = 1000;    
        
        
public void InnerF1(){
         System.out.println(b); 
//如果在局部内部类中使用外部类的局部变量,该变量必须是final类型
        }    
      }
          
new InnerClass1().InnerF1();
    }
 
    
public static void main(String[] args) {
         RyanTestInner rti 
= new RyanTestInner();
        rti.outF2();

    }
}
接下来静态内部类
public class TestStaticInner {
      
    
static int a = 10 ;
   
      
int b = 100;
      
      
static void outF1() {

          System.out.println(
"outF1() ");
      
      }
      
/*
       * 静态内部类中可以定义非静态的成员变量和方法,但是只能访问外部类
       * 中的静态方法和静态变量
       
*/
     
static class InnerClass  {
          
         
int a = 11;
         
         
static int c = 20;
         
         
public void  innerF2() {
             System.out.println(
"innerF2()");
         }
         
         
public static void innerF1() {
             outF1();
             System.out.println(TestStaticInner.a);
             System.out.println(c);
         }
         
    }  
     
    
public static void main(String[] args) {    
        TestStaticInner tsi 
= new TestStaticInner();
          TestStaticInner.InnerClass.innerF1();
       
//如果想要访问静态内部类中的非静态方法,需要首先 new 外部类.内部类.方法 
          new  TestStaticInner.InnerClass().innerF2();
    }
}
最后匿名内部类,我认为匿名内部类最大的好处就是实现了多继承,连八戒都说java只能单继承,但是通过匿名内部类就可以办到。
首先我列举出两个简单的不能在简单的类,大家一看就了改
首先抽象类
package com.yan.test;

public abstract class ChineseBeauty {
      
public  abstract void sex();
}
接口
package com.yan.test;

public interface JapansBeauty {
  
    
public void sex();
    
}
现在有个类既继承了ChineseBeauty又实现了JapansBeauty 那我们到底是改重写的是哪个方法呢??(方法相同)
package com.yan.test;

public class AnonymousInnerTest extends ChineseBeauty {

    @Override
    
public void sex() {
        System.out.println(
"commonF()  From Demo01");
        
    }
  
    
public void fuckBeauty() {
          
        JapansBeauty  d 
= new JapansBeauty(){

            
public void sex() {
                System.out.println(
"we are so beauty ,so sexy~~~");
            }
             
             
         };
         d.sex();
    }
    
  
public static void main(String[] args) {
      AnonymousInnerTest  ai 
= new AnonymousInnerTest();
     
      ai.sex();
    
      ai.fuckBeauty();
      
}    
    
}
看到这里大家应该有点点明白了吧。。很简单不难。



                                                                                                       --    学海无涯