JAVA基础之内部类

JAVA基础之内部类

2017-01-13

1、java中的内部类都有什么？！

　　　　成员内部类

　　　　局部内部类

　　　　匿名内部类

　　　　静态内部类

2、内部类详解

　　　　•成员内部类

　　　　　　在一个类的内部再创建一个类，成为内部类

　　　　　　1）在一个类中使用内部类，可以在内部类中直接存取所在类的私有属性或方法

 class Outer{
     //外部类Outer
     private int i = 111 ;//外部类私有变量
     class Inner{
         //内部类Inner
         private int j = 222 ;//内部类私有变量
         public void print(){
             System.out.println("外部类的私有属性"+ i);
             System.out.println("内部类的私有属性"+ j);
         }
     }
 }
 public class ClassDemo5 {
     public static void main(String[] args) {
         Outer o = new Outer() ;
         Outer.Inner i = o.new Inner() ;
         i.print() ;
     }
 }

　　　　　  2）内部类的实例化方法

import 面向对象基础.Outer.Inner;　　
//第一种方式:导入import 面向对象基础.Outer.Inner;包

Outer.Inner i = o.new Inner() ;
 //第二种方式：外部类.内部类 对象名 = 外部类对象.new 内部类

　　　　     3）外部类访问内部类

 class Fatch{
     //外部类Fatch
     public class Student{
         //内部类Student
         public void show(){
             //内部类show（）方法
             System.out.println("内部类Student的show（）方法");
         }
     }
     public void print(){
         /**
          * 外部类不可以直接访问内部类的属性或方法,
          * 必须创建内部类对象才可以访问
          */
         new Student().show() ;    //使用匿名对象实例化调用内部类的类成员
         System.out.println("外部类Fatch的print（）方法");
     }
 }
 public class ClassDemo4 {
     public static void main(String[] args) {
         Fatch f = new Fatch() ;    //实例化外部类对象
         f.print() ;    //调用外部类的print（）方法
     }
 }

　　　　　　4）如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字。

 class Outer1 {
     //外部类
     private int i = 10 ;//外部类私有变量
     class Inner1{
         //内部类
         private int i = 20 ;//内部类私有变量
         public void show(){
             //内部类方法
             System.out.println("内部类的变量"+ this.i );//使用this关键字访问内部类成员
             System.out.println("外部类的变量"+ Outer1.this.i);//使用外部类名.this.变量名 来访问外部类成员
         }
     }
     public void print(){
         new Inner1().show() ;    //调用内部类方法
     }
 }
 public class ClassDemo6 {
     public static void main(String[] args) {
         new Outer1().print() ;　　
     }

 }

　　　

　　　　    •注意点：

　　　　　　　　　　»实例化内部类之前必须实例化外部类

　　　　　　　　　　»内部类可以随意访问他的外部类成员，但外部类不可以直接访问内部类的类成员

　　　　　　　　　　»内部类可以被声明为private 或 protected 权限的访问

　　　　　　　　　　»内部类对象会依赖于外部类对象，除非已经存在一个外部类对象，否则类中不会出现内部类对象

　　　　•局部内部类(方法内部类)

　　　　　　内部类不仅可以在类中进行定义，也可以在类的局部位置进行定义，例如在类的方法或者任意的作用域中都可以定义内部类

　　　　     1）在外部类的方法中定义一个方法内部类

 class Demo1{
     //外部类Demo
      final int I = 10 ;//外部类定义的常量
      public void show(){    //外部类的show（）方法
          class Inne{        //方法内部类
              int j = 20 ;    //方法内部类变量
              private void inshow() {    //方法内部类中的inshow（）方法
                  System.out.println("外部类常量"+ I );
                  System.out.println("方法内部类变量"+ j );
             }
          }
          Inne in = new Inne()  ;    //实例化内部类对象
          in.inshow() ;    //调用内部类方法
      }
 }
 public class ClassDemo7 {
     public static void main(String[] args) {
         Demo1 d = new Demo1() ;
         d.show() ;
     }
 }

　　　　注意：如果方法中的参数需要被传递进去，就必须把参数声明成final类型

　　　　  •静态内部类

　　　　　　如果一个内部类被声明为static,此内部类就称为外部类　

　　　　　  1）静态内部类可以通过（new 外部类名.内部类.内部类方法名） ，来调用静态内部类方法

 class Outer2{
     //外部类
     private static String str = "张博杰" ;//外部类的静态变量
     static class Inner2{
         //使用static声明 的静态内部类
         public void fun() {
             //静态内部类方法
             System.out.println("外部类的静态变量"+" "+ str);
         }
     }
 }
 public class ClassDemo8 {
     public static void main(String[] args) {
         new Outer2.Inner2().fun() ;
         //静态内部类可以使用new 外部类名.内部类.内部类方法名 ，来调用静态内部类方法
     }
 }

　　　　　　

　　　　　　　　•匿名内部类

　　　　　　　　　　匿名内部类也就是没有名字的内部类,正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写.使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口

　　　　　　　  1)匿名内部类的实现

 abstract class A2 {    //抽象类A2
     public abstract void eat() ;
 }
 public class ClassDemo9 {
     public static void main(String[] args) {
         /**
          * 如果A2这个抽象类只用一次，那么就可一使用匿名内部类来实现
          */
         A2 a = new A2(){
             public void eat(){
                 System.out.println("我要吃饭");
             }
         } ;
         a.eat() ;
     }
 }