Java 内部类--定义在一个类中的类

文章类别 in java

看完就会明白:

  1. 1.java内部类是什么?

  2. 2.java成员内部类是什么?

  3. 3.java静态内部类是什么?

  4. 4.java内部类的封装是什么?

  5. 5.java局部内部类是什么?

  6. 6.java匿名内部类是什么?

  7. 7.java内部类的特点是什么?

java内部类就是在一个类里面定义类!

像这样:

public class OuterClass {

    class InnerClass
    {

    }

}

java成员内部类:

public class OuterClass {

    class InnerClass
    {

    }

}

成员内部类的使用:

 class OuterClass {

     class InnerClass
     {
         public void method()
         {
             System.out.println("innerclass's method....");
         }
     }

}

//测试类:
public class MainDemo {
    public static void main(String[] args) {
        OuterClass.InnerClass innerdemo 
        = new OuterClass().new InnerClass();
        innerdemo.method();
    }
}

//输出结果:innerclass's method....

所以:成员内部类的实例化特点就是:

外部类名.内部类名 对象名 = new 外部类.new 内部类

java内部类的特点:

  1. 内部类可以访问外部类的成员,包括私有
–java虚拟机给内部类定义了指向外部类的引用!
  1. 外部类想要访问内部类的成员,必须实例化内部类!
–类中的成员想要调用类,就得实例化!

代码体现:

public class OuterClass {

     private String name = "外部类的成员变量";

     public class InnerClass
     {

         void method()
         {
            //内部类可以访问外部类的成员
             System.out.println(name);
             OuterClass.this.hahaha();
         }

     }

     public void function()
     {
        //调用内部类需要实例化
         InnerClass inner = new InnerClass();
         inner.method();
     }

   public void hahaha()
     {
         System.out.println("hahah");
     }


}


//测试类
public class MainDemo {
    public static void main(String[] args) {
        OuterClass.InnerClass innerdemo 
        = new OuterClass().new InnerClass();
        innerdemo.method();
    }
}
//输出结果:外部类的成员变量
           hahah

java静态内部类

成员内部类可以被static、private、protected声明,而普通的类是不可以的,普通的类只能被public或者默认,为什么呢?因为成员内部类要注意到成员二字,就像成员变量成员方法一样! so,当成员内部类被static修饰后就成了静态内部类!

如:

 class OuterClass {

    static class InnerClass
    {

    }

} 

静态内部类的使用: 静态是当类创建的时候就存在了的,所以在静态内部类想用调用外部类的成员,就只能调用外部类的静态成员,因为普通成员还没有被实例化出来!

代码体现:

 public class OuterClass {

     private static String name = "外部类的成员变量";

     static class InnerClass
     {
         void method()
         {
             System.out.println(name);
         }
     }

}

//测试类:
public class MainDemo {
    public static void main(String[] args) {
        OuterClass.InnerClass innerdemo
         = new OuterClass.InnerClass();
        innerdemo.method();
    }
}

//输出结果:外部类的成员变量

静态内部类的实例化:

new 外部类.内部类();

java内部类的封装

当成员内部类被private修饰时:

 public class OuterClass {


    private class InnerClass{
        void method()
        {
            System.out.println("我是被私有了的内部类");
        }
    }


    public void function()
    {

        new InnerClass().method();
    }

}


//测试类:
public class MainDemo {
    public static void main(String[] args) {
            OuterClass out = new OuterClass();
            out.function();
    }
}

//输出结果:我是被私有了的内部类

可以看到,你在调用OuterClass的function方法的时候,它会去调用内部类的方法,而不像之前我们直接去调用InnerClass,因为InnerClass被private了,所以无法new!也就是说:成员内部类被private修饰后就具有封装性!只能通过实例化外部类来实现!

java局部内部类

类定义在方法内:

public class OuterClass {

    public void mathod()
    {
        class InnerClass
        {

        }
    }

}

需要注意的是: 局部内部类访问局部变量必须用final修饰! 局部变量是放在栈里的,当方法用完之后,它就消失了 而对象是在堆内存里的,方法运行完之后,它还没消失 这时候类用的变量不能消失,所以就要加final,加 final之后局部的变量变成常量,常量放在静态区,这时候常量不会消失!

代码体现:

 public class OuterClass {

     public void method()
     {
         final String name = "我是一个局部的成员变量!";
         //此时name就变成常量了!!

         class InnerClass{
             void innerfunction()
             {
                 System.out.println(name);
             }
         }

         InnerClass inner = new InnerClass();
         inner.innerfunction();
     }

}


//测试类:
public class MainDemo {
    public static void main(String[] args) {
        OuterClass out = new OuterClass();
        out.method();

    }
}

//输出结果:我是一个局部的成员变量!

java匿名内部类

匿名内部类的前提是:

  • 有类(可以使抽象类也可以使普通类)或者接口

格式:

  • new 类名或者接口名(){重写方法};

代码体现:

//定义一个接口,接口里面有一个抽象方法onClik
interface OnClickListner {

    public void onClik();

}

//这是一个普通类,setOnClikListner方法传入接口,调用onClik抽象方法。
public class Hand {

        public void setOnClikListner(OnClickListner listner)
        {
            listner.onClik();
        }

}

//测试:
    public class MainDemo {
    public static void main(String[] args) {
        Hand hand = new Hand();
		//匿名内部类的使用
        hand.setOnClikListner(new OnClickListner() {

            @Override
            public void Onclik() {
                // TODO Auto-generated method stub
                System.out.println("hahaha");
            }
        });
    }
}

//输出结果:hahaha

从中可以看到匿名内部类的: 本质:

  • 是一个已经实现了类或者接口的子类对象!

好处:

  • 用完就被垃圾回收机制回收!栈内存不指向它了!

我的相关文章

相关资料