java学习之旅51--面向对象_24_内部类详解

原创 2015年07月10日 17:04:58

  1. 内部类(InnerClass)
    • 一般情况下,我们把类定义成独立的单元。有些情况下,我们把类放在另一个类的内部定义,称为内部类。
    • 内部类的作用:
      • 内部类提供更好的封装。只能让外部类直接访问,不允许同一个包中的其他类直接访问。
      • 内部类可以直接访问外部类的私有属性,内部类被当成其外部类的成员。但外部类不能访问内部类的内部属性。
    • 内部类的使用场合
      • 由于内部类提供了更好的封装特性,并且可以很方便的访问外部类的属性。所以,通常内部类在只为所在外部类提供服务的情况下优先使用。
  2. 内部类的分类
    • 成员内部类(可以使用private、protected、public任意进行修饰。类文件:外部类$内部类.class)
      • 非静态内部类(外部类里使用非静态内部类和使用其他类没什么不同)
        • ①非静态内部类必须寄存在一个外部类对象里。因此,如果有一个非静态内部类对象那么一定存在对应的外部类对象
        • ②非静态内部类可以使用外部类的成员,但是外部类不能直接访问非静态内部类的成员
        • ③非静态内部类不能有静态方法、静态属性、静态初始化块
        • ④静态成员不能访问非静态成员:外部类的静态方法、静态代码块不能访问非静态内部类,包括不能使用非静态内部类定义变量、创建实例。
        • ⑤成员变量访问要点:
          • 1)内部类里方法的局部变量:变量名
          • 2)内部类属性:this.变量名
          • 3)外部类属性:外部类名.this.变量名
        • ⑥内部类的访问
          • 1)外部类中定义内部类:new Inner()
          • 2)其他类中定义内部类:Outer.Inner in = new Outer().new Inner();
          • class Outer {
            	private int x=20;
            	class Inner{
            		private int y;
            		public void print(){
            			System.out.println(Outer.this.x);
            		}
            	}
            }
            public class TestInnerClass{
            	public static void main(String[] args) {
            		Outer.Inner in = new Outer().new Inner();
            		in.print();
            	}
            }
      • 静态内部类
          • ①定义方式(略)
          • ②使用要点
            • 1)当一个静态内部类对象存在,并不一定存在对应的外部类对象。因此,静态内部类的实例方法不能直接访问外部类的实例方法。
            • 2)静态内部类可以看做外部类的一个静态成员。因此,外部类的方法可以通过  静态内部类.名字  访问静态内部类的静态成员。通过new  静态内部类()访问静态内部类的实例
            • 3)在其他类中创建静态内部类:Outer.Inner in = new Outer.Inner();
    • 匿名内部类 

      • 匿名内部类也就是没有名字的内部类

        正因为没有名字,所以匿名内部类只能使用一次,它通常用来简化代码编写

        但使用匿名内部类还有个前提条件:必须继承一个父类或实现一个接口

         

        实例1:不使用匿名内部类来实现抽象方法

        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        abstract class Person {
            public abstract void eat();
        }
         
        class Child extends Person {
            public void eat() {
                System.out.println("eat something");
            }
        }
         
        public class Demo {
            public static void main(String[] args) {
                Person p = new Child();
                p.eat();
            }
        }

        运行结果:eat something

        可以看到,我们用Child继承了Person类,然后实现了Child的一个实例,将其向上转型为Person类的引用

        但是,如果此处的Child类只使用一次,那么将其编写为独立的一个类岂不是很麻烦?

        这个时候就引入了匿名内部类

         

        实例2:匿名内部类的基本实现

        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        abstract class Person {
            public abstract void eat();
        }
         
        public class Demo {
            public static void main(String[] args) {
                Person p = new Person() {
                    public void eat() {
                        System.out.println("eat something");
                    }
                };
                p.eat();
            }
        }

        运行结果:eat something

        可以看到,我们直接将抽象类Person中的方法在大括号中实现了

        这样便可以省略一个类的书写

        并且,匿名内部类还能用于接口上

         

        实例3:在接口上使用匿名内部类

        interface Person {
            public void eat();
        }
         
        public class Demo {
            public static void main(String[] args) {
                Person p = new Person() {
                    public void eat() {
                        System.out.println("eat something");
                    }
                };
                p.eat();
            }
        }

        运行结果:eat something

         

        由上面的例子可以看出,只要一个类是抽象的或是一个接口,那么其子类中的方法都可以使用匿名内部类来实现

        最常用的情况就是在多线程的实现上,因为要实现多线程必须继承Thread类或是继承Runnable接口

         

        实例4:Thread类的匿名内部类实现

        public class Demo {
            public static void main(String[] args) {
                Thread t = new Thread() {
                    public void run() {
                        for (int i = 1; i <= 5; i++) {
                            System.out.print(i + " ");
                        }
                    }
                };
                t.start();
            }
        }

        运行结果:1 2 3 4 5

         

        实例5:Runnable接口的匿名内部类实现

        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        public class Demo {
            public static void main(String[] args) {
                Runnable r = new Runnable() {
                    public void run() {
                        for (int i = 1; i <= 5; i++) {
                            System.out.print(i + " ");
                        }
                    }
                };
                Thread t = new Thread(r);
                t.start();
            }
        }

        运行结果:1 2 3 4 5

    • 局部内部类(很少用)

相关文章推荐

51_面向对象_24_内部类详解

内部类(innerclasses) 一般情况,我们把类定义成独立的单元。有些情况下,我们把一个类放在另一个类的内部定义,称为内部类。 1.内部类的作用: 内部类提供了更好的封装。只能让外...

Java学习系列(五)Java面向对象之抽象类、接口、内部类、枚举类详解

抽象类、接口常常与设计模式紧密相连。掌握抽象类、接口等其实很简单。下面以说明+实例的方式来讲,这样更容易理解。 抽象类 先看一个关键字“abstract”,我们知道它是抽象的意思。所谓抽象,说的直白一...

Java学习系列(五)Java面向对象之抽象类、接口、内部类、枚举类详解

抽象类、接口常常与设计模式紧密相连。掌握抽象类、接口等其实很简单。下面以说明+实例的方式来讲,这样更容易理解。 抽象类 先看一个关键字“abstract”,我们知道它是抽象的意思。所谓抽象...

(14)Java学习笔记——面向对象07——内部类

内部类 将一个类定义在另外一个类的里面,对里面那个类就称为内部类(内置类,嵌套类) 内部类的访问特点: 1/内部类可以直接访问外部类中的成员 2/外部类要访问内部类,必须建立内部类的对象。 一...

java基础学习面向对象之匿名内部类 五-13

内部类 一个类定义在另一个类的里面,对立面那个类就叫做内部类,或者嵌套类。 特点,内部类可以直接访问外部类中的成员。包括私有成员。而外部类要访问内部类中的成员必须要建立内部类对象。 代码 pack...
  • onceing
  • onceing
  • 2017年02月15日 18:32
  • 170

黑马程序员--Java学习日记之面向对象(多态和匿名内部类)

继承,总结: 一.代码块:    1.代码块的种类:  1).局部代码块:定义在某个方法中;  2).成员(构造)代码块:定义在类体中,每次实例化此类对象时被调用;  3).静态代码块:定义在类体中,...
  • Memor_
  • Memor_
  • 2015年06月22日 17:27
  • 456

Java面向对象之抽象类、接口、内部类、枚举类详解

抽象类、接口常常与设计模式紧密相连。抽象类先看一个关键字“abstract”,我们知道它是抽象的意思。所谓抽象,说的直白一点就是同一件事情,有不同的实现。 比如呼吸这个动作,人需要肺呼吸,而鱼需要鳃...

黑马程序员---java学习笔记之面向对象:静态内部类

1、内部类在外部类的成员位置上时,就可以用修饰类成员的修饰符修饰该内部类         a):private修饰内部类,该类就被封装,不能被外部其他类直接访问;         b):static修...

3.java面向对象语法学习(部分2-抽象类,接口,内部类)

Java基础09天 学习笔记_面向对象(内部类,异常,RuntimeException, 自定义异常)

内部类 静态内部类 内部类: 将一个类定义在另一个类的里面,对里面那个类就成为内部类 内部类 , 可以被私有修饰。相当于成员变量   Outer.this.x ,  outer.thi...
  • fafrifa
  • fafrifa
  • 2014年09月03日 08:11
  • 249
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:java学习之旅51--面向对象_24_内部类详解
举报原因:
原因补充:

(最多只允许输入30个字)