内部类(Inner Class)
一个类是可以在其它类中定义的类，我们可以将数据储存在有意义的内部类，在别人调用我们类、运用相关方法的时候，能做更有序、灵活的运用，如下：
public class EasyInnerClass {
private People list[] = null;
private int count = 0;
public EasyInnerClass() {
list = new People[5];
}
class People {
String name;
int height;
int weight;
public String toString() {
return "[ "+name+" ]: height- "+height+" ,weight- "+weight;
}
}
public void enrollPeople(String name, int h, int w) {
if(count < 5) {
People theOne = new People();
theOne.name = name;
theOne.height = h;
theOne.weight = w;
list[count] = theOne;
count++;
} else {
System.out.println("too many people...");
}
}
public void printList() {
if(list.length > 0)
for(int i = 0; i < list.length; i++)
{
if(list[i]!=null)
System.out.println(list[i].toString());
}
else
System.out.println("no one is on the list");
}
public static void main(String[] args) {
EasyInnerClass ec = new EasyInnerClass();
ec.enrollPeople("jg",150,60);
ec.enrollPeople("zg",150,60);
ec.enrollPeople("st",150,60);
ec.enrollPeople("ot",150,60);
ec.enrollPeople("dt",150,60);
ec.enrollPeople("sd",150,60);
ec.printList();
}
}
比如在上例，我们在 enrollPeople() 这个方法中，产生一个用内部类对象构建的对象，数据存到该对象，并将这个对象存在一个数组中，而调用此 API的人，便无须了解我们如何処理这些数据，只要有合理的输入及正确的输出即可。另外要注意的是，当自外部宣告非静态( non-static )内部类时，应为：
外部类名.内部类名 变数名 = 外部类变数.宣告方法()public class EasyInnerClass {
public class People {
String name;
int height;
int weight;
public People(String n, int h, int w) {
name = n;
height = h;
weight = w;
}
public String toString() {
return "[ "+name+" ]: height- "+height+" ,weight- "+weight;
}
}
public People initPeople(String name, int h, int w){
return new People(name,h,w);
}
public void printPeople(People ppl) {
System.out.println(ppl.toString());
}
public static void main(String[] args) {
EasyInnerClass ec = new EasyInnerClass();
EasyInnerClass.People one = ec.initPeople("John",175,65);
ec.printPeople(one);
}
}
如果用下面的方法这麽写：
public static void main(String[] args) {
EasyInnerClass ec = new EasyInnerClass();
EasyInnerClass.People one = new EasyInnerClass.People("john",149,22);
ec.printPeople(one);
}
"non-static variable this cannot be referenced from a static context" 这句话的意思是说 EasyInnerClass.People 是一个静态的上下文(static context)，而 new 是一个非静态的变数宣告方法，此処所宣告的内存为动态内存，不能为静态上下文所引用。（因为静态变数在内存中的位置是一开始就知道的，而动态变数是程序执行中才会知道的）修改的办法除了上面的方法以外，我们也可以将内部类改为静态的内部类，如下：
public class EasyInnerClass {
public static class People {
String name;
int height;
int weight;
public People(String n, int h, int w) {
name = n;
height = h;
weight = w;
}
public String toString() {
return "[ "+name+" ]: height- "+height+" ,weight- "+weight;
}
}
public People initPeople(String name, int h, int w){
return new People(name,h,w);
}
public void printPeople(People ppl) {
System.out.println(ppl.toString());
}
public static void main(String[] args) {
EasyInnerClass ec = new EasyInnerClass();
People one = new People("john",149,22);
ec.printPeople(one);
}
}在下面这个范例中，内部类作为判断目前数组 index 的方法，它可以存取 private 属性的 ObArray 以判断和实现 InnerPointer 接口，如下：
public class InnerArray {
private Object[] ObArray;
private int next;
interface InnerPointer {
boolean end();
void next();
Object current();
}
private class InnerPointerImpl implements InnerPointer {
private int i = 0;
@Override
public boolean end() {
return i == ObArray.length;
}
@Override
public void next() {
if(!end())
i++;
else
System.out.println("Out of index");
}
@Override
public Object current() {
return ObArray[i];
}
}
public InnerArray(int size) {
ObArray = new Object[size];
}
public InnerPointerImpl initInnerPointerImpl() {
return new InnerPointerImpl();
}
public void add(Object a) {
if(next < ObArray.length) {
ObArray[next] = a;
next++;
}
else
System.out.println("out of array index");
}
public static void main(String[] args) {
InnerArray ia = new InnerArray(10);
InnerArray.InnerPointerImpl ip = ia.initInnerPointerImpl();
for(int i = 0; i < 10; i++)
{
ia.add(i);
}
while(!ip.end())
{
System.out.println(String.valueOf(ip.current()));
ip.next();
}
}
}
.this 和 .new
类名.this外部类对象.new 内部类名();如下：
import java.util.Arrays;
public class DotNewPractice {
private Object[] jobQueue;
private int curExecIndex;
private interface ProgressListener {
float getCurrentProgress();
boolean isEnd();
}
private ProgressListener listener;
public DotNewPractice(int jobNum) {
System.out.println("this is: " + this.getClass());
jobQueue = new Object[jobNum];
}
public void execute() {
final int Len = jobQueue.length;
for(int i =0; i<Len; i++) {
jobQueue[i] = 0;
curExecIndex = i;
System.out.println(""+listener.getCurrentProgress()+"%");
}
}
public void getJobs() {
Arrays.fill(jobQueue,100);
}
public void initListener() {
listener = new innerclass();
}
public void setProgressListener(ProgressListener ltn) {
listener = ltn;
}
public class innerclass implements ProgressListener {
public innerclass() {
System.out.println("this is: " + this.getClass());
System.out.println("Outer Class this is: " + DotNewPractice.this.getClass()); // 外部类名.this 在这～
System.out.println(innerclass.this.getClass() + " created!");
}
@Override
public float getCurrentProgress() {
return ((float)(curExecIndex+1)/(float)jobQueue.length)*100;
}
@Override
public boolean isEnd() {
return (curExecIndex+1 == jobQueue.length);
}
};
public static void main(String[] args) {
DotNewPractice dp = new DotNewPractice(10);
dp.setProgressListener(dp.new innerclass()); // 用dp.initListener(); 也会得到一样的效果
dp.getJobs();
dp.execute();
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
