static关键字修饰类

可以将一个类的定义放在另一个类的内部定义，这样的类就被称为嵌套类，包含嵌套类的类被称为外部类(outer class)，也可以叫做封闭类。

嵌套类可以分为两种：

静态嵌套类(Static Nested Classes)：使用static声明，一般称为嵌套类(Nested Classes)；
非静态嵌套类(Non-static Nested Classes)：非static声明，一般称为内部类(Inner Classes)；

嵌套类是它的外部类的成员。非静态嵌套类（内部类）可以访问外部类的其他成员，即使该成员是私有的，而静态嵌套类只能访问外部类的静态成员。

嵌套类作为外部类的一个成员，可以被声明为：private，包访问，protected,public（注意：外部类只能被声明为public或者包范围）。

使用嵌套类的主要优点有以下几个方面：

嵌套类可以访问外部类的数据成员和方法，即使它是私有的；
提高可读性和可维护性：因为如果一个类只对另外一个类可用，那么将它们放在一起，这更便于理解和维护；
提高封装性：给定两个类A和B，如果需要访问A类中的私有成员，则可以将B类封装在A类中，这样不仅可以使得B类可以访问A类中的私有成员，并且可以在外部隐藏B类本身；
减少代码的编写量；

静态嵌套类可以使用外部类的名称来访问它。例如：

OuterClass.StaticNestedClass

如果要为静态嵌套类创建对象，则使用以下语法:

OuterClass.StaticNestedClass nestedObject =
        new OuterClass.StaticNestedClass();

非静态嵌套类包含三种：

成员内部类(Member inner clss);
局部内部类(Local inner class)；
匿名内部类(Anonymous inner class);

Nested Classes

	描述
成员内部类	在类中和方法外部创建的类
匿名内部类	为实现接口或扩展类而创建的类，它的名称由编译器决定
局部内部类	在方法内部创建的类
静态嵌套类	在类中创建的静态类
嵌套接口	在类中或接口中创建的接口

一非静态嵌套类(内部类)

非静态嵌套类也就是内部类，它有以下几个特点：

实例化内部类必须先实例化一个外部类；
内部类实例与外部类实例相关联(内部类可以访问外部类的成员)，所有不能在内部类中定义任何静态成员；
内部类是非静态的；

1、成员内部类

示例一

在外部类中并且在外部类的方法外创建的非静态嵌套类，称为成员内部类。说白了成员内部类就是外部类的一个非静态成员而已。如下：

public class Parcel1 {
	class Contents{
		private int i = 11;
		public int value() {return i;}
	}
	class  Destination{
		private String label;
		Destination(String whereTo){
			label = whereTo;
		}		
		String readLable() {return label;}
	}	
	public void ship(String dest) {
		Contents c = new Contents();
		Destination d = new Destination(dest);
		System.out.println(d.readLable());
	}	
	public static void main(String[] args) {
		Parcell p = new Parcel1();
		p.ship("Zhengy");
	}
}

在ship()方法中使用成员内部类，与使用普通类没有什么区别，在这里，实际的区别就是内部成员类的定义是嵌套在Parcel1中。

示例二

下面我们尝试在外部类中定义一个方法，该方法返回一个指向成员内部类的引用。

public class Parcel2 {
	class Contents{
		private int i = 11;
		public int value() {return i;}
	}	
	class  Destination{
		private String label;
		Destination(String whereTo){
			label = whereTo;
		}		
		String readLable() {return label;}
	}		
	public Destination to(String s) {
		return new Destination(s);
	}	
	public Contents contents() {
		return new Contents();
	}		
	public void ship(String dest) {
		Contents c = new Contents();
		Destination d = new Destination(dest);
		System.out.println(d.readLable());
	}	
	public static void main(String[] args) {
		Parcel2 p = new Parcel2();
		p.ship("南京");		
		Parcel2 q = new Parcel2();
		Parcel2.Destination d = q.to("北京");
		Parcel2.Contents c = q.contents();
	}
}

如果想在类外创建某个成员内部类的对象，必须像main()方法那样，具体指明这个对象的类型：OuterClassName.InnerClassName。

示例三

当创建一个成员内部类的对象时，此对象与创建它的外部类对象之间就有了一种联系，所以它能够访问其外部类对象的所有成员，而不需要任何特殊条件。下面的例子说明了这一点：

//类似迭代器
interface Selector{
	boolean end();    //判断序列是否迭代结束
	Object current();  //获取当前元素
	void next();       //下一个元素
}
//序列类(外部类)
public class Sequence {
	//数组用于保存元素
	private Object[] items;	
	//当前追加索引
	private int next = 0;
	public Sequence(int size) {items = new Object[size];}	
	//向数组追加元素
	public void add(Object x) {
		if(next < items.length)
			items[next++] = x;
	}		
	//成员内部类：迭代器(可以访问外部类对象的所有成员），这里用来迭代序列中所有元素
	private class SequenceSelector implements Selector{
		private int  i = 0;
		public boolean end() {return i == items.length;}
		public Object current() {return items[i];}
		public void next() {
			if(i < items.length)
				i++;
		}
	}	
	//创建迭代器对象
	public Selector selector() {
		return new SequenceSelector();
	}	
	public static void main(String[] args) {
		Sequence sequence = new Sequence(10);
		for(int i=0;i<10;i++) {
			sequence.add(Integer.toString(i));
		}
		
		Selector selector = sequence.selector();
		while(!selector.end()) {
			System.out.print(selector.current() + "  ");
			selector.next();
		}		
	}
}

输出结果如下：

0  1  2  3  4  5  6  7  8  9

上面演示了一个:"迭代器"设计模式的例子。

示例四

在成员内部类中如果需要创建对外部类对象的引用，可以使用外部类的名字后面跟着.this。下面演示如何使用.this：

///使用.this
public class DotThis {
	void f() {
		System.out.println("DotThis.f()");
	}	
	//成员内部类
	public class Inner{
		public DotThis outer() {
			return DotThis.this;
		}
	}	
	public Inner inner() {
		return new Inner();
	}	
	public static void main(String[] args) {
		DotThis dt = new DotThis();
		DotThis.Inner dti = dt.inner();
		dti.outer().f();
	}
}

输出如下：

DotThis.f()

示例五

想要直接创建成员内部类的对象，不可以直接引用外部类的名字，而是必须使用外部类的对象来创建该成员内部类对象。在拥有外部类对象之前是不可能创建成员内部类对象的，这是因为成员内部类对象会暗暗地连接到创建它的外部类对象上。

但是，如果创建的是静态内部类，那么它就不需要对外部类对象的引用。

///.new
public class DotNew {
	public class Inner{
		public void f(){
			System.out.print("test");
		}
	}
	public static void main(String[] args) {
		DotNew dn = new DotNew();
		DotNew.Inner dni = dn.new Inner();	
		dni.f();
	}
}

示例六

当将成员内部类(private修饰)向上转型为其基类，尤其是转为一个接口(public或者"包访问")时，由于成员内部类使用private修饰，因此可以隐藏其内部的具体实现，但是由于把成员内部类声明为private，因此不能访问该成员内部类任何新增的原本不属于公共接口的方法，所以扩展接口是没有意义的。下面演示一个例子：

interface Destination{
	String readLabel();
}
interface Contents{
	int value();
}
class Parcel4{
	//私有类，隐藏其具体实现
	private class PContents implements Contents{
		private int i = 11;
		public int value() {return i;}		
	}		
	protected class PDestination implements Destination{
		private String label;
		private PDestination(String whereTo) {
			label = whereTo;
		}		
		public String readLabel(){
			return label;
		}				
	}
	public Destination destination(String s) {
		return new PDestination(s);
	}	
	public Contents contents(){
		return new PContents();
	}
}
public class TestParcel {
	public static void main(String[] args) {
		Parcel4 p = new Parcel4();
		Contents c = p.contents();
		Destination d = p.destination("北京");
	}
}

示例七

一个成员内部类被嵌套多少层并不重要，它能透明的访问所有它所嵌入的外部类的所有成员，如下所示：

class MNA{
	private void f() {}
	//第一个内部类
	class A{
		private void g() {}
		//第二个内部类
		public class B{
			void h() {
				g();
				f();
			}
		}
	}
}
public class MultiNestingAccess {
	public static void main(String[] args) {
		MNA mna = new MNA();
		MNA.A mnaa = mna.new A();
		MNA.A.B mnab = mnaa.new B();
	}
}

成员内部类的工作方式：

Java每个类都会产生一个.class文件，所以Java 编译器还会创建一个成员内部类OuterClass$MemberInnerClass.class，成员内部类文件名格式为外部类名$成员内部类名。

2 、局部内部类

局部内部类（Local inner class）通常定义在一个块中。所以通常你会在一个方法块中找到局部内部类。

正如局部变量那样，局部内部类的作用域受到方法的限制。它可以访问外部类的所有成员，和它所在的局部方法中所有局部变量。

如果你想调用局部内部类中的方法，你必须先在局部方法中实例化局部内部类。

局部内部类的一些规则：

无法从方法外部调用局部内部类；
局部内部类不能被声明为private, public, protected；
在JDK1.7之前局部内部类不能访问非final的局部变量，但是在JDK1.8及之后是可以访问非final的局部变量的；

示例一

在一个方法中定义一个局部内部类：

public class Parcel5 {
	public Destination destination(String s) {
		class PDestination implements Destination{
			private String label;
			private PDestination(String whereTo) {
				label = whereTo;
			}			
			public String readLabel(){
				return label;
			}
		}
		return new PDestination(s);
	} 	
	public static void main(String[] args) {
		Parcel5 p = new Parcel5();
		Destination d = p.destination("北京");
	} 
}

示例二

下面我们尝试在一个作用域内定义一个局部内部类：

public class Parcel6 {
	private void internalTracking(boolean b) {
		if(b) {
			class TrackingSlip{
				private String id;
				TrackingSlip(String s){
					id = s;
				}
				String getSlip() {
					return id;
				}
			}
			TrackingSlip ts = new TrackingSlip("slip");
			String s = ts.getSlip();
		}
	}	
	public void track() {
		internalTracking(true);
	}	
	public static void main(String[] args) {
		Parcel6 p = new Parcel6();
		p.track();
	}
}

TrackingSlip类被嵌入在if语句的作用域中，这并不是说该类的创建是有条件的，它其实与别的类一起编译过了。然而，在定义TrackingSlip的作用域之外，它是不可用的，除此之外，它和普通的类一样。

局部内部类的工作方式：

Java每个类都会产生一个.class文件，所以Java 编译器还会创建一个名为localInner$Local.class的文件。

3、匿名内部类

在 Java 中没有命名的内部类称为匿名内部类，当我们需要重写类或接口中的方法时，都会使用到它。匿名内部类在使用的时候将同时声明和实例化。

匿名类可以通过以下两种方式进行创建：

类（可能是抽象类或者其他类）；
接口；

实例一

下面将会创建一个匿名类，该匿名类是接口Contents的实现类：

///匿名内部类

public class Parcel7 {
	//
	public Contents contents() {
		//返回一个匿名类对象，该类是Contents接口的实现
		return new Contents() {
			private int i = 11;
			public int value() {
				return i;
			}
		};		
	}
	
	public static void main(String[] args) {
		Parcel7 p = new Parcel7();
		Contents c = p.contents();
	}

}

上述代码中通过new表达式返回的引用被自动向上转为对Contents类型的引用。上述匿名内部类的语法是下述代码的简化形式：

///匿名内部类

public class Parcel7 {
	
//	public Contents contents() {
//		//返回一个匿名类对象，该类是Contents接口的实现
//		return new Contents() {
//			private int i = 11;
//			public int value() {
//				return i;
//			}
//		};		
//	}
	
	class PContents implements  Contents{
		private int i = 11;
		public int value() {
			return i;
		}
	}	
	public Contents contents() {
		return new PContents();
	}		
	public static void main(String[] args) {
		Parcel7 p = new Parcel7();
		Contents c = p.contents();
	}
}

实例二

在示例一匿名内部类中，使用的是默认构造函数，但是如果基类需要一个有参数的构造器，我们只需要简单的传递合适的参数给基类的构造器即可，下面演示一个例子：

class Wrapping{
	private int i;
	//需要一个参数
	public Wrapping(int x) {
		i = x;
		System.out.println("基类构造器:"+x);
	}	
	public int value() {
		return i;
	}
}
public class Parcel8 {
	public Wrapping wrapping(int x) {
		//一个匿名类 实现类Wrapping类，并传递x给基类的构造器
		return new Wrapping(x) {
			public int value() {
				return super.value()*47;
			}
		};
	}	
	public static void main(String[] args) {
		Parcel8 p = new Parcel8();
		Wrapping w = p.wrapping(10);
	}
}

Wrapping是一个具有具体实现的简单类。我们将x传递进new Wrapping(x)，这个x最终会传递给基类Wrapping的构造函数。

实例三

如果在匿名类中定义字段，还可以对其执行初始化，如下：

///匿名类中初始化字段
public class Parcel9 {
	//dest用来初始化匿名类字段，必须声明为final
	public Destination destination(final String dest) {
		return new Destination() {
			private String label = dest;
			public String readLabel(){
				return label;
			}
		};
	}	
	public static void main(String[] args) {
		Parcel9 p = new Parcel9();
		Destination d = p.destination("北京");
	}

如果我们我们定义一个匿名内部类，并且希望它使用一个在其外部定义的对象，那么编译器会要求其参数引用是final，就像上面这个例子一样。

实例四

如果只是给匿名类中的一个字段赋值，示例三是很好的作用。但是如果想做一些类似构造器的行为呢？然而，匿名函数不可能有命名构造器，但是可以通过实例初始化，就能达到为匿名内部类创建一个构造器的效果，如下：

///通过实例初始化，达到为匿名内部类创建一个构造器的效果

abstract class Base{
	public Base(int i) {
		System.out.println("Base constructor, i = "+i);
	}
	public abstract void f(); 
} 
public class AnonymousConstructor {		
	//price必须是final，因为它在匿名类内部直接使用
	public static Base getBase(int i,final float price) {
		//i被传给匿名类的基类构造器，不要求是final，因为它不在匿名类内部直接使用
		return new Base(i) {		
			private int cost;
			//内部类实例初始化
			{
				cost = Math.round(price); 
				System.out.println("Inside instance initializer："+cost);				
			}
			public void f() {
				System.out.println("In anonymous f()");
			}			
		};
	}	
	public static void main(String[] args) {
		Base base = getBase(47,101.395F);
		base.f();
	}
}

输出结果如下：

Base constructor, i = 47
Inside instance initializer:101
In anonymous f()

在上例中i不要求是final的，因为i是被传递给匿名类的基类构造器的，它并不会在匿名类内部被直接使用。而price必须是final的，因为它在匿名类内部直接使用。

匿名内部类和正规的继承相比有些受限，匿名内部类既可以扩展类，也可以扩展接口，但是不能两者兼备。而且如果是实现接口，也只能实现一个接口。

实例五

我们先来看一个工厂方法实例：

///工厂方法

interface  Service{
	void method1();
	void method2();
}
interface ServiceFactory{
	Service getService();
}
class Implementations1 implements Service{
	private Implementations1(){}
	public void method1() {
		System.out.println("Implementation1 method1");
	}	
	public void method2() {
		System.out.println("Implementation1 method2");
	}	
	public static ServiceFactory factory = new ServiceFactory() {
		public Service getService() {
			return new Implementations1();
		}
	} ;
}
class Implementations2 implements Service{
	private Implementations2(){}
	public void method1() {
		System.out.println("Implementation1 method1");
	}	
	public void method2() {
		System.out.println("Implementation1 method2");
	}	
	public static ServiceFactory factory = new ServiceFactory() {
		public Service getService() {
			return new Implementations2();
		}
	} ;
}
public class Factories {
	public static void serviceConsumer(ServiceFactory fact) {
		Service s = fact.getService();
		s.method1();
		s.method2();
	}	
	public static void main(String[] args) {
		serviceConsumer(Implementations1.factory);
		serviceConsumer(Implementations2.factory);		
	}
}

在上例中Implementations1和Implementations2的构造器都是private的，并且把工厂类写成了匿名内部类的形式。此外，在实际中，经常只需要单一的工厂对象，因此把factory声明为static，这样表明一个类最多只会生成一个实例对象。

二成员内部类的继承

1、成员内部类的继承

在之前我们介绍过成员内部类可以使用外部类的成员，这是因为当某个外部类对象创建一个成员内部类对象时，成员内部类对象会秘密的捕获一个指向外部类对象的引用，在访问外部类成员时，就是使用那个引用来选择外部类的成员(编译器会帮我们处理这个细节)。

构建成员内部类对象时，需要一个指向其外部类对象的引用，如果编译器访问不到这个引用就会报错。因此，如果有一个子类继承自成员内部类，当创建一个子类对象时，首先会调用成员内部类的构造函数创建一个内部成员类对象，但是此内部成员类对象不存在指向其外部类对象的引用，就会报错。要解决这个问题，必须向子类构造器传入一个指向外部类对象的引用，并且在构造器第一句中使用如下语法：

enclosingClassReference.super(xx) //enclosingClassReference外部类对象引用，super(xx)成员内部类的构造函数

如下所示：

///成员内部类的继承

class WithInner{
	private String name = "临安";
	private int age = 25;
	private boolean sex = false;
	
	WithInner(boolean sex){
		this.sex = sex;
		System.out.println("外部类构造函数：WithInner()");
	}	
	//成员内部类
	class Inner{
		//构造函数 初始化外部类成员
		Inner(String name,int age){
			WithInner.this.name = name;
			WithInner.this.age = age;
			System.out.println("内部类构造函数：Inner():" + WithInner.this.name + " " + WithInner.this.age + " " + WithInner.this.sex);
		}
	}
}

//成员内部类的子类
public class InheritInner  extends WithInner.Inner {
	//构造函数  必须传递一个指向外部类对象的引用
	InheritInner(WithInner wi,String name,int age){		
		//调用成员内部类构造函数
		wi.super(name, age);			
	}		
	public static void main(String[] args) {
		//创建一个外部类对象
		WithInner wi = new WithInner(true);
		InheritInner ii = new InheritInner(wi,"郑阳",23);
	}
}

输出结果：

外部类构造函数：WithInner()
内部类构造函数：Inner():郑阳 23 true

三静态嵌套类

静态嵌套类其实就是在顶级类中封装的一个顶级类，它的行为和顶级类一样，它被封装在顶级类中其实就是为了方便打包。

静态嵌套类是外部类的静态成员，它可以直接使用外部类名.静态嵌套类名访问自身；
它可以访问外部类的静态成员和静态私有成员；
与其他类一样，静态嵌套类不能访问非静态成员；

实例一

正常情况下，不能在接口内部放置任何代码，但嵌套类可以作为接口的一部分。并且放到接口中任何类型(字段，方法)都自动的是public和static的。由于接口中的类是static，因此它是静态嵌套类。如下所示：

///接口内部的类：自动是public和static的
public interface ClassInInterface {
	void howdy();	
	//静态嵌套类
	class Test implements ClassInInterface{
		public void howdy() {
			System.out.println("Howdy!");
		}
	}	
	public static void main(String[] args) {
		new Test().howdy();
	}
}

我们在接口ClassInInterface中定义了一个静态嵌套类Test，该静态嵌套类实现了外部接口类。

实例二

class OuterClass{  
    // 外部类的静态数据成员
    static int data = 30;  
    // 外部类中的静态嵌套类
    static class StaticNestedClass {  
        // 静态嵌套类中的实例方法
        void getData() {System.out.println("data is "+data);}  
    }
    public static void main(String args[]){  
        // 实例化静态嵌套类（创建对象）
        OuterClass.StaticNestedClass obj = new OuterClass.StaticNestedClass();  
        obj.getData();  
    }  
}

在上面的例子中，你需要先创建一个静态嵌套类的实例，因为你需要访问它的实例方法getData()。但是你并不需要实例化外部类，因为静态嵌套类相对于外部类来说它是静态的，可以直接使用外部类名.静态嵌套类名访问。

实例三

如果静态嵌套类中有静态成员，则不需要实例化静态嵌套类即可直接访问。

class OuterClass2{  
    static int data = 10;  
    static class StaticNestedClass{  
        // 静态嵌套类的静态方法
        static void getData() {System.out.println("data is "+data);}  
    }  
    public static void main(String args[]){  
        // 不需要创建实例可以直接访问
        OuterClass2.StaticNestedClass.getData();
    }  
}

参考文献

[1] Java编程思想

[2]Java 嵌套类基础详解

[3]static关键字修饰类

来源：https://www.cnblogs.com/zyly/p/10596268.html

标签

静态类