Java面向对象_内部类

概念:内部类就是类的内部定义的类

成员内部类格式如下:class Outer{

                                  class Inner{}

                            }

编译上述代码会产生两个文件:Outer.class和Outer$Inner.class

在外部创建内部类对象

内部类除了可以在外部类中产生实例化对象,也可以在外部类的外部来实例化。所以内部类的访问:通过"外部类.内部类"的形式表示

Outer out=new Outer();//产生外部类实例

Outer.Inner in=null;//声明内部类对象

in=out.new Inner();//实例化内部类对象

public class Practice14 {
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Outer o=new Outer();
        o.print();
        
        //直接在外部使用内部类,不推荐使用
        Outer.Inner in=o.new Inner("在外部使用内部类");
        in.print();
    }
}


class Outer{
    public void print(){
        //在外部类实例化内部类,并调用方法
        Inner i=new Inner("成员内部类");
        i.print();
    }
    class Inner{
        private String name;
        public Inner(String name){
            this.name=name;
        }
        public void print(){
            System.out.println(name);
        }
    }
}

 

方法内部类格式如下:class Outer{

             public void doSomething(){

                class Inner{

                  public void seeOuter(){}

               }

              }

             }

      注意:1.方法内部类只能在定义该内部类的方法内实例化,不可以在此方法外对其实例化

      2.方法内部类对象不能使用该内部类所在方法的非final局部变量

 

 1 public class Practice14 {
 2     
 3     public static void main(String[] args) {
 4         // TODO Auto-generated method stub
 5         Outer o=new Outer(); 
 6         o.print1();
 7        
 8     }
 9 }
10 
11 
12 class Outer{
13     
14     public void print1(){
15         final int x=10;//方法内部类对象不能使用该内部类所在方法的非final局部变量
16         //在方法内创建内部类
17         class Inner1{
18             public void print(){
19                 System.out.println("我是方法内部类"+x);
20             }
21         }
22         Inner1 i=new Inner1();//只能在定义该内部类的方法内实例化
23         i.print();
24     }
25     
26 }

 

静态内部类:在一个类内部定义一个静态内部类:静态的含义是该内部类可以像其他静态成员一样,没有外部类对象时,也能够访问它。静态嵌套类仅能访问外部类的静态成员和方法。

      class Outer{

        static class Inner{}

      class Test{

        public static void main(String[] args){

          Outer.Inner n=new Outer.Inner();

      }

      }

 1 public class Practice14 {
 2     
 3     public static void main(String[] args) {
 4         // TODO Auto-generated method stub
 5        //在外部直接使用静态内部类(创建静态内部类对象不需要依赖外部类的对象)
 6         //静态内部类在之后的安卓编程中经常使用(重点)
 7        Outer.Inner o=new Outer.Inner();
 8        o.print();
 9     }
10 }
11 
12 
13 class Outer{
14     static class Inner{
15         public void print(){
16             System.out.println("静态");
17         }
18     }    
19     
20 }

匿名内部类:匿名内部类就是没有名字的内部类。有三种情况:继承式的匿名内部类;接口市的匿名内部类;参数式的匿名内部类;

在使用匿名内部类时,记住以下原则:

1.不能有构造方法,只能有一个实例

2.不能定义任何静态成员、静态方法

3.不能是public,protected,private,static

4.一定是在new的后面,用其隐含实现一个接口或实现一个类

5.匿名内部类为局部的,所以局部内部类的所有限制都对其生效

 1 public class Practice14 {
 2     
 3     public static void main(String[] args) {
 4         // TODO Auto-generated method stub
 5        Boy b=new Boy();
 6        b.print();
 7        
 8        b.print2(new Child(){
 9           public void desc(){
10               System.out.println("参数式的匿名内部类");
11           }
12        });
13     }
14 }
15 
16 interface Child{
17     public void desc();
18 }
19 
20 class Boy{
21     public void print(){
22         Child C=new Child(){
23             public void desc(){
24                 System.out.println("接口市的匿名内部类");
25             }
26         };
27         C.desc();
28     }
29     public void print2(Child ch){
30         ch.desc();
31     }
32 }

定义内部类时优先考虑静态内部类,可以防止内存溢出。

 

posted on 2015-12-24 16:42  深海溺心  阅读(192)  评论(0编辑  收藏  举报

导航