定义在另一个类中的类，叫做内部类，可以把一些逻辑相关的类组织在一起，并控制位于内部的类的可见性。
public class Outter {
class Inner {
public void print(String s) {
System.out.println(s);
}
}
public Inner buildInner() {
return new Inner();
}
public static void main(String[] args) {
Outter outter = new Outter();
Inner inner = outter.buildInner();
inner.print("输出");
}
}
内部类与外部类联系
内部类可以使用外部类的所有成员，而且不需要任何特殊条件，且拥有其对与外部类所有元素的访问权。
public class Sequence {
private Object[] items;
private int next;
public Sequence(int size) {
items = new Object[size];
}
/**
* 添加元素
*
* @param obj
*/
public void add(Object obj) {
if (next < items.length) {
items[next] = obj;
next++;
}
}
public SequenceSelector selector() {
return new SequenceSelector();
}
public static void main(String[] args) {
Sequence sequence = new Sequence(10);
for (int i = 0; i < 10; i++) {
sequence.add(i);
}
SequenceSelector selector = sequence.selector();
while (!selector.end()) {
System.out.print(selector.current() + " ");
selector.next();
}
}
private class SequenceSelector {
private int current = 0;
public boolean end() {
return current == size();
}
public int size() {
return items.length;
}
public Object current() {
return items[current];
}
public void previous() {
if (current > 0) {
current--;
}
}
public void next() {
if (current < items.length) {
current++;
}
}
}
}
使用.this和.new
在内部类如何生成外部类对象的引用，使用外部类名.this
public class DoThis {
class Inner{
public DoThis outer(){
return DoThis.this;
}
}
public void f(){
System.out.println("DoThis.f()");
}
public Inner inner(){
return new Inner();
}
public static void main(String[] args) {
DoThis doThis = new DoThis();
Inner inner = doThis.inner();
inner.outer().f();
}
}
外部类如何创建内部类的对象，需要使用外部类名.new
public class DoNew {
class Inner {
public void f(){
System.out.println("Inner.f()");
}
}
public static void main(String[] args) {
DoNew doNew = new DoNew();
Inner inner = doNew.new Inner();
inner.f();
}
}
在拥有外部类对象之前是不可能创建内部类对象的，内部类对象会连接到创建它的外部类对象上，静态内部类不需要外部类对象的引用。
对于私有的内部类，外部类是可以访问到它的，其他的类无法访问到，如下
public class DoNew {
private class Inner {
public void f(){
System.out.println("Inner.f()");
}
}
public static void main(String[] args) {
DoNew doNew = new DoNew();
// 外部类中可以访问到
Inner inner = doNew.new Inner();
inner.f();
}
}
public class Test {
public static void main(String[] args) {
DoNew doNew = new DoNew();
// 其他类无法访问
// 'DoNew.Inner' has private access in 'DoNew'
//doNew.new Inner();
}
}
内部类分类
局部内部类
在方法作用域内创建的类，称为局部内部类
public class MethodOuter {
public Destination desc(String s){
// 局部内部类
class Inner implements Destination{
@Override
public void f(){
System.out.println("Inner.f()传入参数"+s);
}
}
return new Inner();
}
public static void main(String[] args) {
MethodOuter methodOuter = new MethodOuter();
methodOuter.desc("test").f();
}
}
Inner是desc()方法的一部分，在方法之外访问不到
匿名内部类
public class Outer1 {
public Contents contents(){
return new Contents(){
@Override
public void f() {
System.out.println("Contents匿名内部类.f()");
}
};
}
public static void main(String[] args) {
Outer1 outer1 = new Outer1();
outer1.contents().f();
}
}
嵌套类
嵌套类就是静态内部类，内部类对象与外部类对象之间没有联系，将内部类声明为static，普通的内部类对象隐式的保存了一个引用，指向创建它的外部类对象，当内部类是static的时候，意味着
-
要创建嵌套类的对象，并不需要其外部类的对象
-
不能从嵌套类的对象中访问非静态的外围对象
普通内部类不能有static数据和static字段，也不能包含嵌套类，但是嵌套类可以。
public class Outer2 { private static class Inner2{ private static int i = 0; private static void f(){ System.out.println("Inner2.f()"); } } public static void main(String[] args) { Inner2.f(); } }接口内部类
嵌套类可以作为接口的一部分，放到接口中任何类都是public static的
由于本身的博客百度没有收录，博客地址http://zhhll.icu
来源：oschina
链接：https://my.oschina.net/u/3839951/blog/4877444