「java中内部类详解」java中内部类和外部类

今天给各位分享java中内部类详解的知识，其中也会对java中内部类和外部类进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、java中内部类的概念？
• 2、在Java中什么是内部类？
• 3、Java里什么叫内部类什么叫外部类
• 4、Java的内部类有什么特点 作用和注意

java中内部类的概念？

简单的说，内部（inner）类指那些类定义代码被置于其它类定义中的类；而对于一般的、类定义代码不嵌套在其它类定义中的类，称为顶层（top-level）类。对于一个内部类，包含其定义代码的类称为它的外部（outer）类。 1 Static member class（静态成员类） 类声明中包含“static”关键字的内部类。如以下示例代码， Inner1/Inner2/Inner3/Inner4就是Outer的四个静态成员类。静态成员类的使用方式与一般顶层类的使用方式基本相同。

1内部类的嵌套可以理解成类的链关系，在构造一个内部类(非static)的实例的时候，会将直接外层类的实例

作为参数传进构造函数，而外层类的实例也是用其外层类的实例构造，所以是一种链状关系，内部的类可以使用所有

外层的类的实例，而外层的类不能使用内层的类， 应用a.this(最外层类实例) ，a.b.c.this(链中某个外层的实例)。

class TheOuter{

class kk {

class gg {

int tt = 100;

}

}

class aa {

class bb {

int jj = 10;

class cc {

{ int ff = TheOuter.aa.bb.this.jj;

// 无法直接访问到gg不在链关系内

System.out.println(ff);

}

}

}

}

}

2 创建一个内部类 new aa().new bb().new()cc 实际上是调用 外层类实例.new 本层构造函数()

如果内部类是static的不需要外层类的实例 多个static嵌套的内部类的实例 aa.bb.cc test = new aa.bb.cc();

3

class a0 {

class b0 {

}

}

class vvv{

class ff extends a0.b0 {// ff这里不是内部类也行

ff(a0 kk){

kk.super();

}

}

}

继承自内部类要调用父类的外层类的super()

4

class dd {

void print(){

System.out.println("dd.println is there");

}

class kk {

kk(int i){}

class cc {

void pp() {

System.out.println("****");

}

void ddpp() {

dd.this.print();

}

}

}

}

class aa {

public static void main (String agrs[]) {

dd.kk.cc test = new dd().new kk(10).new cc();

test.ddpp();

}

}

在类内部可以是使用外层类，但是如果生成一个实例的句柄就没有提供访问上层类的功能。

5 this 是指本类的实例

6 缺省的new

class cc {

{

new test();

}

class kk {

{

System.out.println("there kk");

}

}

class test {

{

new kk();

}

class kk {

{

System.out.println("there test_kk");

}

}

}

}

可以直接使用new,new的范围可以是 之际外层.this.new 和this.new 但是如果内层与外层出现同名类以内部优先

7

//当有链关系的时候要注意类不要重名

class vv {

class bb {} //!

class kk {

//class vv{} 这样就会出错

class bb {} //!这样就不会出错

}

}

8

class a0 {

class b0 {

}

}

class vvv{

class ff extends a0.b0 {// 不是内部类也行

ff(a0 kk){

kk.super();

}

}

}

继承自内部类要调用父类的外层类的super()

9 匿名内部类

interface oo {

//oo(int g) {}

int k = 10;

void pt();

}

class pp {

pp(int g) {

}

int get() {

return 100;

}

}

class me {

/*

interface oo {

void pt();

}

*/

class kk{

oo testmed() {

final int i = 10;

int g = 100;

return new oo() {

int kk;

{

// 使用外面的东西要声名成final

// 继承接口内部优先

// 匿名内部类没有构造函数，只能使用块，初始化

kk = i + k ;

}

public void pt() {

System.out.println(kk);

}

};

}

pp testmed0() {

return new pp(10){ // 继承自类

public int get() {

return super.get() * 10;

}

};

}

}

}

匿名内部类可以继承自接口也可以继承自类，继承自类的构造函数中 可以有参数。

10

class bf {

interface kk {}

class aa {

// 接口能嵌套在接口中（不受限制），或者嵌套在顶层，下面就不行

//interface gg {}

}

}

在Java中什么是内部类？

内部类就是写在类中或方法中的类，它还是一个类，与其他类的不同就是他只为这个外部类（包含内部类的类）类所用

Java里什么叫内部类什么叫外部类

对普通类（没有内部类的类）来说，内部类和外部类都与他无关；对有内部类的类来说，它们就是其内部类的外部类，外部类是个相对的说法，其实就是有内部类的类。

所以，要回答这个问题，只需要讲解内部类是什么：

Java中的内部类共分为四种：

静态内部类static inner class (also called nested class)

成员内部类member inner class

局部内部类local inner class

匿名内部类anonymous inner class

静态内部类Static Inner Class

最简单的内部类形式。

类定义时加上static关键字。

不能和外部类有相同的名字。

被编译成一个完全独立的.class文件，名称为OuterClass$InnerClass.class的形式。

只可以访问外部类的静态成员和静态方法，包括了私有的静态成员和方法。

生成静态内部类对象的方式为：

OuterClass.InnerClass inner = new OuterClass.InnerClass();

示例代码：

package com.learnjava.innerclass;

class StaticInner

{

private static int a = 4;

// 静态内部类

public static class Inner

{

public void test()

{

// 静态内部类可以访问外部类的静态成员

// 并且它只能访问静态的

System.out.println(a);

}

}

}

public class StaticInnerClassTest

{

public static void main(String[] args)

{

StaticInner.Inner inner = new StaticInner.Inner();

inner.test();

}

}

成员内部类Member Inner Class

成员内部类也是定义在另一个类中，但是定义时不用static修饰。

成员内部类和静态内部类可以类比为非静态的成员变量和静态的成员变量。

成员内部类就像一个实例变量。

它可以访问它的外部类的所有成员变量和方法，不管是静态的还是非静态的都可以。

在外部类里面创建成员内部类的实例：

this.new Innerclass();

在外部类之外创建内部类的实例：

(new Outerclass()).new Innerclass();

在内部类里访问外部类的成员：

Outerclass.this.member

示例代码：

package com.learnjava.innerclass;

class MemberInner

{

private int d = 1;

private int a = 2;

// 定义一个成员内部类

public class Inner2

{

private int a = 8;

public void doSomething()

{

// 直接访问外部类对象

System.out.println(d);

System.out.println(a);// 直接访问a，则访问的是内部类里的a

// 如何访问到外部类里的a呢？

System.out.println(MemberInner.this.a);

}

}

}

public class MemberInnerClassTest

{

public static void main(String[] args)

{

// 创建成员内部类的对象

// 需要先创建外部类的实例

MemberInner.Inner2 inner = new MemberInner().new Inner2();

inner.doSomething();

}

}

局部内部类Local Inner Class

局部内部类定义在方法中，比方法的范围还小。是内部类中最少用到的一种类型。

像局部变量一样，不能被public, protected, private和static修饰。

只能访问方法中定义的final类型的局部变量。

局部内部类在方法中定义，所以只能在方法中使用，即只能在方法当中生成局部内部类的实例并且调用其方法。

示例代码：

package com.learnjava.innerclass;

class LocalInner

{

int a = 1;

public void doSomething()

{

int b = 2;

final int c = 3;

// 定义一个局部内部类

class Inner3

{

public void test()

{

System.out.println("Hello World");

System.out.println(a);

// 不可以访问非final的局部变量

// error: Cannot refer to a non-final variable b inside an inner

// class defined in a different method

// System.out.println(b);

// 可以访问final变量

System.out.println(c);

}

}

// 创建局部内部类的实例并调用方法

new Inner3().test();

}

}

public class LocalInnerClassTest

{

public static void main(String[] args)

{

// 创建外部类对象

LocalInner inner = new LocalInner();

// 调用外部类的方法

inner.doSomething();

}

}

匿名内部类Anonymous Inner Class

匿名内部类就是没有名字的局部内部类，不使用关键字class, extends, implements, 没有构造方法。

匿名内部类隐式地继承了一个父类或者实现了一个接口。

匿名内部类使用得比较多，通常是作为一个方法参数。

生成的.class文件中，匿名类会生成OuterClass$1.class文件，数字根据是第几个匿名类而类推。

示例代码：

package com.learnjava.innerclass;

import java.util.Date;

public class AnonymouseInnerClass

{

@SuppressWarnings("deprecation")

public String getDate(Date date)

{

return date.toLocaleString();

}

public static void main(String[] args)

{

AnonymouseInnerClass test = new AnonymouseInnerClass();

// 打印日期：

String str = test.getDate(new Date());

System.out.println(str);

System.out.println("----------------");

// 使用匿名内部类

String str2 = test.getDate(new Date()

{

});// 使用了花括号，但是不填入内容，执行结果和上面的完全一致

// 生成了一个继承了Date类的子类的对象

System.out.println(str2);

System.out.println("----------------");

// 使用匿名内部类，并且重写父类中的方法

String str3 = test.getDate(new Date()

{

// 重写父类中的方法

@Override

@Deprecated

public String toLocaleString()

{

return "Hello: " + super.toLocaleString();

}

});

System.out.println(str3);

}

}

Java的内部类有什么特点 作用和注意

1)根据位置的不同，Java中的内部类分为四种：

 静态内部类

 使用static修饰，声明在类体中

 静态内部类中可以访问外部类的静态成员

 成员内部类

 声明在类体中，不使用static，具有类的成员特征，也就是，必须有类的实例才能创建内部类实例

 内部类实例可以访问共享外部类的成员变量（很常用）

 如：链表的节点就可以定义为内部类

 局部内部类 把类声明在方法中，就是局部内部类，作用域

 类似局部变量（很少见）

 匿名内部类

 匿名类，非常常见，可以写在任何地方,就像一般的语句

 语法更象是创建对象：Date d = new Date(){//...};

 匿名类是对原类的一个继承，同时创建了实例，{} 就是继承以后的类体

类体中可使用所有类的语法

 匿名类不能写构造器

 匿名类可以从抽象类或者接口继承，必须提供抽象方法的实现

2) 任何内部类都编译成独立的class文件

3) 最大的作用：封装！

 匿名类可以封装内部概念：情侣间的“土豆”和菜市场的“土豆”是不一样的

java中内部类详解的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java中内部类和外部类、java中内部类详解的信息别忘了在本站进行查找喔。