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() ;
    }
}