java允许在类的内部定义一个类,如果该内部定义的类没有用static修饰,该类就是一个内部类(用static修饰也可以认为是一种内部类,静态内部类)。内部类可以被认为是外部类的一个成员。

内部类的使用方法:

一、外部类内部定义一个内部类

二、外部类定义一个内部类类型的数据成员

三、外部类的构造器(或者其他方法)new一个内部类对象并赋给第二步的数据成员(也可以在外部类的对象方法中,创建一个内部类实例,并调用内部类方法)

四、外部类定义其他方法,使用第二步的数据成员调用内部类的方法。如果调用的内部类方法有参数的话,该外部类方法的参数种类、数量、顺序需与内部类对应方法相同

注:这是内部类被private修饰时的用法。如果没有修饰,可以通过外部类对象直接创建内部类对象。内部类对象可以调用外部类的成员。

eg:

class Person{

//定义一个内部类

private class Cup{

public void useCup(double w){

this.water=water-w;

}

public double getWater(){

return water;

}

 

private double water;

}

//通过构造器创建一个内部类对象并赋给myCup

public Person(String n){

myCup=new Cup();

this.name=n;

}

//创建drinkWater()方法,使用内部类对象调用useCup()、getWater()方法

public void drinkWater(double w){

myCup.useCup(w);

myCup.getWater();

}

//创建一个外部类类型的属性

private Cup myCup;

private String name;

//main方法使用上面的外部类

public Test{

public static void main(String[] args){

Person p=new Person("zhang");

p.drinkWater(0.9);

}

}

上面的例子中,内部类用private修饰,所以该内部类只能在外部类内部使用。当内部类没有用private修饰时,该类也可以从外部访问。

eg:

class Person{

//不用private修饰的内部类,此处类为默认访问权限(包访问权限)

class Cup{

代码块省略

}

。。。

代码块省略

}

public Test{

public static void main(String[] args){

Person p=new Person("zhang");

p.drinkWater(0.9);

Person.Cup cup=p.new Cup();//在外部创建内部类对象的方法。需要依托外部类对象创建。

}

}

闭包:

内部类对象直接创建时,必须基于外部类对象。也就是说创建时必须依附于一个外部类对象。内部类对象可以访问所依附的外部类对象的成员。从另一个角度说,内部类对象附带有所依附的外部类对象的环境信息。这就叫闭包。

eg:

class Person{

class Cup{

public String whoseCup(){

return name;//访问外包对象

}

}

public Person(String n){

this.name=n;

}

private String name;

}

public Test{

public static void main(String[] args){

Person me=new Person("张三");

Person him=new Person("李四");

Person.Cup firstCup=me.new Cup();

Person.Cup secondCup=him.new Cup();

 System.out.println(firstCup.whoseCup());

System.out.println(secondCup.whoseCup());

}

}

static嵌套类

内部类也可以用static修饰,叫做static嵌套类。嵌套类可以直接创建,而不依托于外部类对象,同时,嵌套类对象不可访问外部类对象的成员。嵌套类也可以用private/public/protected修饰。

eg:

class Person{

static class Cup{

代码块

}

}

public class Test{

public static void main(String[] args){

Person.Cup cup=new Person.Cup();

cup.function(args);

}

}

从效果上看,嵌套static类拓展了类的命名空间(name space).

局部内部类

局部内部类类似局部变量,使用在外部类的方法中。

eg:

class Outter{

private int age;

public void method(){

class Inner{//外部类方法中定义一个内部类

private String name;

}

public void method1(){

方法体

}

Inner inner=new Inner();//实例化内部类

inner.method1();//内部类对象调动内部类方法

}

局部内部类的应用,在于通过创建一个外部类的实例化,然后用外部对象调用相应方法,该方法创建内部类对象,内部类对象调用内部类方法。

匿名内部类

讲述匿名内部类之前,先要弄清楚什么是匿名类。

匿名类是一种无类名的类,匿名类借助接口实现,并通常直接new一个对象。

eg:

interface Myint{

public void method();

}

class AnoClass{

public static void main(String[] args){

//借助接口创建一个匿名类的同事,new一个匿名类对象,并调用匿名类的方法

new Myint(){

private int age;

public void method(){

方法体

}

}.method();

//借助接口创建一个匿名类的同事,new一个匿名类对象,并用接口的应用指向该匿名类对象

Myint mi=new Myint(){

private int age;

public void method(){

方法体

}

}

}

}

下面再讲述一下匿名内部类,匿名内部类和局部内部类一样,也创建在外部类的方法中。

eg:

nterface Myint{

public void method();

}

class Outter{

private int age;

public void method(){

//在外部类的方法内部,借助接口创建一个匿名内部类的同时,实例化一个匿名内部类对象,并调用该对象的方法

new Myint(){

private int age;

public void method(){

方法体

}.method();

}

}