Java内部类的基本解析

内部类

内部类的基本概念

  所谓的内部类也就是在一个类的内部进行其他类结构的嵌套操作。

为什么要使用内部类?

  这就要引用一句十分著名的一本书叫《Think in java》中的一句名言了——每个内部类都能独立的继承一个(接口的)实现,所以无论外围类是否已经继承了某个(接口的)实现,对于内部类都是没有影响的。

  因为内部类拥着类的一些基本特征,所以在实际问题中我们会遇到一些接口无法解决或者难以解决的问题,此时我们可以使用内部类继承某个具体的或者抽象的类,间接解决类无法多继承引起的一系列问题。

内部类的优点

优点:

  • 内部类与外部类可以方便的访问彼此的私有域(包括私有方法和私有属性)
  • 内部类是另外一种封装,对外部的其他类隐藏(出了外围类,其他类不可访问)
  • 内部类可以实现java的单继承局限
  • 内部类可以使用多个实例,每个实例都有自己的状态信息,并且与其他外围对象的信息相互独立。
  • 创建内部类对象的时刻并不依赖于外围对象的创建。

内部类的分类

从广义上讲,java内部类可以分成四大类:成员内部类,静态内部类,匿名内部类,局部内部类(方法内部类),一个一个来

成员内部类

  • 成员内部类可以无条件访问外部类所有成员属性和成员方法(包括private成员和static成员)
  • 成员内部类内部不允许任何ststic变量或者方法,正如方法中不能有任何的静态属性(成员对象与方法相关,静态属性和类有关),但可以定义常量。
  • 当成员内部类拥有和外部类同名的成员变量或者方法的时,默认情况下访问的是内部类的成员和方法,如果需要访问外部类的同名成员,需要以一下的形式进行访问
    • 外部类.this.成员变量
    • 外部类.this.成员方法
  • 在外部类中如果要访问成员内部类的成员,必须先创建一个成员内部类的对象,再通过这个指向这个对象的引用来访问。
  • 成员内部类是依附外部类的,要创建成员内部类的对象,前提是必须存在一个外部类的对象。
    • 第一种方式:

      Outter outter = new Outter();
      Outter.Inner inner = outter.new Inner();
      //必须通过Outter对象来创建
    • 第二种方式:

      Outter.inner inner = outter.getinnerinstance();
  • 内部类可以拥有private访问权限、protected访问权限、public访问权限、默认访问权限以及包访问权限。如用private修饰,则只能在外部类的内部访问了。
 1 public class Outer {
 2
 3     private int age = 99;
 4     String name = "Coco";
 5     public class Inner{
 6         String name = "Jayden";
 7         public void show() {
 8             System.out.println(Outer.this.name);
 9             System.out.println(name);
10             System.out.println(age);
11         }
12     }
13     public Inner getInnerClass() {
14         return new Inner();
15     }
16     public static void main(String[] args) {
17         Outer o = new Outer();
18         Inner in = o.new Inner();
19         in.show();
20     }
21 }

运行之后的结果是:

需要提醒的是编译上面的程序后,会发现产生了两个class文件

静态内部类

  • 也是定义在另一个类里面的类,只不过在类前面加上一个static。静态内部类是不需要依赖于外部类的,这点和类的静态成员属性有点类似,并且它不能使用外部类的非static成员变量或者方法,但可以通过 new 外部类().成员 的方式访问 。
  • 静态内部类与非静态内部类有些不同,没有保存指向创建它的外部类的引用。这就是说明:
    • 静态内部类的创建不需要依赖外部类可以直接创建,可以直接创建 内部类 对象名 = new 内部类();。
    • .静态内部类不可以使用任何外部类的非static类(包括属性和方法),但可以存在自己的成员变量。
  • 如果外部类的静态成员与内部类的成员名称相同,可通过“类名.静态成员”访问外部类的静态成员;
  • 如果外部类的静态成员与内部类的成员名称不相同,则可通过“成员名”直接调用外部类的静态成员
 1 public class Outer{
 2             private int age = 99;
 3             static String name = "Coco";
 4             public static class Inner{
 5                 String name = "Jayden";
 6                 public void show(){
 7                     System.out.println(Outer.name);
 8                     System.out.println(name);
 9                 }
10             }
11             public static void main(String[] args){
12                 Inner i = new Inner();
13                 i.show();
14             }
15         }

运行结果如下:

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

  • 方法内部类不允许使用访问权限修饰符(public、private、protected)均不允许
  • 方法内部类对外部是完全隐藏的,除了创建这个类的方法可以访问外,其他地方均不能访问(其他方法或者类都不知道有这个类的存在)。
  • 方法内部类如果想要使用方法形参,该形参必须使用final声明(JDK8形参变为隐式final声明)
  • 无法创建静态信息
  • 可以直接访问方法内的局部变量和参数(有限制),但是不能更改
  • 可以随意的访问外部类的任何信息。

     1 public class Outer {
     2
     3     // 属性和方法
     4     private int outerVariable = 1;
     5     // 外部类定义的属性
     6     private int commonVariable = 2;
     7     // 静态的信息
     8     private static int outerStaticVariable = 3;
     9
    10     // 成员外部方法
    11     public void outerMethod() {
    12         System.out.println("我是外部类的outerMethod方法");
    13     }
    14
    15     // 静态外部方法
    16     public static void outerStaticMethod() {
    17         System.out.println("我是外部类的outerStaticMethod静态方法");
    18     }
    19
    20     // 程序的入口
    21     public static void main(String[] args) {
    22         Outer outer = new Outer();
    23         outer.outerCreatMethod(100);
    24     }
    25
    26     // 成员方法,内部定义局部内部类
    27     public void outerCreatMethod(int value) {
    28         // 女性
    29         boolean sex = false;
    30         // 局部内部类,类前不能有访问修饰符
    31         class Inner {
    32             private int innerVariable = 10;
    33             private int commonVariable = 20;
    34
    35             // 局部内部类方法
    36             public void innerShow() {
    37                 System.out.println("innerVariable:" + innerVariable);
    38                 // 局部变量
    39                 System.out.println("是否男性:" + sex);
    40                 System.out.println("参数value:" + value);
    41                 // 调用外部类的信息
    42                 System.out.println("outerVariable:" + outerVariable);
    43                 System.out.println("内部的commonVariable:" + commonVariable);
    44                 System.out.println("外部的commonVariable:" + Outer.this.commonVariable);
    45                 System.out.println("outerStaticVariable:" + outerStaticVariable);
    46                 outerMethod();
    47                 outerStaticMethod();
    48             }
    49         }
    50         // 局部内部类只能在方法内使用
    51         Inner inner = new Inner();
    52         inner.innerShow();
    53     }
    54 }

    运行后的结果是:

匿名内部类

  • 一般使用匿名内部类的方法来编写时间监听代码
  • 匿名内部类也是不能有访问修饰符和static修饰符的
  • 匿名内部类是唯一一种没有构造器的类
  • 是一种没有名字的方法内部类,因此特征和方法和方法内部类是一致的。
  • 匿名内部类必须继承一个抽象类或者一个借口

定义一个借口

public interface IAnimal {

    void speak();
}

匿名内部类的使用

 1 public class Outer {
 2
 3     public static IAnimal getInnerInstance(String speak) {
 4         return new IAnimal() {
 5             @Override
 6             public void speak() {
 7                 // TODO Auto-generated method stub
 8                 System.out.println(speak);
 9             }};
10     }
11     public static void main(String[] args) {
12         Outer.getInnerInstance("小猫喵喵喵").speak();
13     }
14 }

内部类与外部类的关系

  • 对于非静态的内部类,内部类的创建依赖外部类的实例对象,在没有外部类实例之前是无法创建内部类的。
  • 内部类可以直接访问外部类的元素(包括私有域)—外部类在内部类之前创建,创建内部类时会将外部类的对象传入
  • 外部类可以通过内部类的引用间接访问内部类元素 – -要想访问内部类属性,必须先创建内部类对象
  • 内部类是一个相对独立的个体,与外部类没有关系。

内部类的运行原理

。。饿了。。吃饭先。。

原文地址:https://www.cnblogs.com/wudidamowang666/p/11406627.html

时间: 2024-11-06 11:34:11

Java内部类的基本解析的相关文章

【转】Java 内部类种类及使用解析

Java 内部类种类及使用解析 内部类Inner Class 将相关的类组织在一起,从而降低了命名空间的混乱. 一个内部类可以定义在另一个类里,可以定义在函数里,甚至可以作为一个表达式的一部分. Java中的内部类共分为四种: 静态内部类static inner class (also called nested class) 成员内部类member inner class 局部内部类local inner class 匿名内部类anonymous inner class 静态内部类Static

Java 内部类种类及使用解析

为何要内部类?     a.内部类提供了某种进入外围类的窗户. b.也是最吸引人的原因,每个内部类都能独立地继承一个接口,而无论外围类是否已经继承了某个接口. 因此,内部类使多重继承的解决方案变得更加完整. 在项目中,需要多重继承,如果是两个接口,那么好办,接口支持多重继承. 如果是两个类呢?这时只有使用内部类了. 内部类Inner Class 将相关的类组织在一起,从而降低了命名空间的混乱. 一个内部类可以定义在另一个类里,可以定义在函数里,甚至可以作为一个表达式的一部分. Java中的内部类

【转】Java HashMap 源码解析(好文章)

- .fluid-width-video-wrapper { width: 100%; position: relative; padding: 0; } .fluid-width-video-wrapper iframe, .fluid-width-video-wrapper object, .fluid-width-video-wrapper embed { position: absolute; top: 0; left: 0; width: 100%; height: 100%; } [

Java内部类

本文是<Java核心技术 卷1>中第六章接口与内部类中关于内部类的阅读总结. Java中的内部类(inner class)是定义在另一个类内部的类.那么内部类有什么用呢?这里主要由三个内部类存在的原因: 内部类方法可以访问该类定义所在的作用域中的数据,包括私有的数据.即,如果类A中定义了类B,那么类B可以访问类A中的数据,甚至是私有数据,但类A不能访问类B中的私有数据: 内部类可以对同一个包中的其他类隐藏起来.在一个包中,定义一个类时,即使不加上访问权限关键词,这个类也是包内其他类可访问的,不

myBatis中的注解@Param、返回值为Map、JAVA读取Excel并解析文本、Class.getResource()和ClassLoader.getResource()

myBatis中的注解@Param:http://blog.csdn.net/gao36951/article/details/44258217:  http://www.cnblogs.com/thomas12112406/p/6217211.html. myBatis返回值为Map:http://blog.csdn.net/werewr342352321df/article/details/11892755. ====================== JAVA读取Excel并解析文本:h

Java内部类:局部内部类(三)

Java内部类分为4个部分进行阐述,分别为概览.成员内部类.局部内部类和匿名内部类. 在本文中是Java内部类的局部内部类,主要讲局部内部类的概念和在使用局部内部的过程中,需要注意的一个细节. 1.局部内部类的概念 在一个类的方法内部定义另外一个类,那么另外一个类就称作为局部内部类. class OutterClass { void test() { class InnerClass//局部内部类 { } } } 在上述代码中,InnerClass定义在OutterClass的test方法的内部

Java内部类:匿名内部类(四)

Java内部类分为4个部分进行阐述,分别为概览.成员内部类.局部内部类和匿名内部类. 在本文中是Java内部类的匿名内部类,主要讲述匿名内部类的概念.匿名内部类的好处.匿名内部类的使用前提.和匿名内部类的应用场景. 1.匿名内部类的概念 没有类名的类就称作为匿名内部类 2.匿名内部类的好处 简化书写 3.匿名内部类的使用前提 必须存在继承或者实现关系才能使用 4.匿名内部类的应用场景 匿名内部类一般是用于实参 示例代码: package com.rk.innerclass; public cla

转:在java中使用dom4j解析xml

在java中使用dom4j解析xml 虽然Java中已经有了Dom和Sax这两种标准解析方式 但其操作起来并不轻松,对于我这么一个初学者来说,其中部分代码是活生生的恶心 为此,伟大的第三方开发组开发出了Jdom和Dom4j等工具 鉴于目前的趋势,我们这里来讲讲Dom4j的基本用法,不涉及递归等复杂操作 Dom4j的用法很多,官网上的示例有那么点儿晦涩,这里就不写了 首先我们需要出创建一个xml文档,然后才能对其解析 xml文档: <?xml version="1.0" encod

Java内部类小程序(成员内部类,静态内部类,匿名内部类)

1 /** 2 * 测试java内部类(成员内部类,静态内部类,匿名内部类) 3 * 局部内部类不常用,就不写了. 4 * @package :java05 5 * @author shaobn 6 * @Describe : 7 * @Time: 2015-9-6 下午8:32:38 8 */ 9 public class TestInner { 10 11 /** 12 * @author shaobn 13 * @Describe : 14 * @param args 15 * @Time