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

    • 局部内部类(很少用)

Java面向对象程序设计--自己写的课后答案--

开启答案之旅第一章Ps:这些都是我自己写的,有些与题目要求的方法不一致,但基本上都能实现!第一题package A; import java.util.Scanner; public class ...
  • firstbloodz
  • firstbloodz
  • 2016年08月30日 17:44
  • 2495

5本最佳的Java面向对象理论和设计模式的书籍

对于Java程序员来说,掌握面向对象的设计理论和一些设计模式是必备技能。就像我在另一篇博客Java程序员应该知道的10个面向对象理论中提到的,不学理论就开始编程,就类似于学习一种语言而不学习字母表。市...
  • wuzhoudao
  • wuzhoudao
  • 2015年12月26日 09:47
  • 1398

JAVA面向对象之内部类

内部类在一个类的内部声明的类,称为内部类(也叫内嵌类)。内部类只能在包含它的类中使用,同时它可以看作是该包含类的一段特殊代码,可以直接使用该包含类的变量和方法。 内部类编译后也会形成一个单独的cla...
  • jianggujin
  • jianggujin
  • 2015年12月26日 17:54
  • 1848

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

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

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

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

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

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

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

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

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

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

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

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

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

抽象类、接口常常与设计模式紧密相连。抽象类先看一个关键字“abstract”,我们知道它是抽象的意思。所谓抽象,说的直白一点就是同一件事情,有不同的实现。 比如呼吸这个动作,人需要肺呼吸,而鱼需要鳃...
  • u012234419
  • u012234419
  • 2015年11月02日 14:19
  • 430
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:java学习之旅51--面向对象_24_内部类详解
举报原因:
原因补充:

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