关闭

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

标签: java编程语言
293人阅读 评论(0) 收藏 举报
分类:

  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

    • 局部内部类(很少用)

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:17392次
    • 积分:776
    • 等级:
    • 排名:千里之外
    • 原创:63篇
    • 转载:0篇
    • 译文:0篇
    • 评论:0条
    文章分类
    文章存档