当两个业务之间联系比较紧密时,用内部类是一个不错的选择,例如一个类中有方法取到数据准备存储到数据库中,一个类是加密解密算法,通过算法将数据加密存到数据库服务器上,这时可以将算法类声明为内部类,嵌套第一个类中。
interface Interclass {
}
public class Myoutclass {
private int j = 0;
private static int s = 5;
void aa() {
};
class Innerclass extends Myoutclass implements Interclass {
@Override
void aa() {
super.aa();
}
void method() {
j = 1;// 可以直接访问非静态变量
Myoutclass.s = 6;
}
}
static class Staticinnerclass extends Myoutclass {
static int i = 1;
void method() {
s = 6;// 可以直接访问静态变量
}
static void smehtod() {
i = 4;
s = 7;
}
}
public static void main(String[] args) {
// 非静态内部类的调用,要通过外围类的实例
Myoutclass.Innerclass inner = new Myoutclass().new Innerclass();
// 静态内部类的调用,要通过外围类的名字
Myoutclass.Staticinnerclass sinner = new Myoutclass.Staticinnerclass();
}
}
内部类分为静态内部类和非静态内部类,但他们都可以访问外围类的私有成员变量
* 非静态内部类不能定义静态方法和静态变量,但是可以直接访问外围类的静态变量和非静态变量
* 静态内部类可以定义静态方法和静态变量,但是可以直接访问外围类的静态变量,非静态变量只能通过实例来访问
*
* 内部类可以继承内部类,也可以实现接口,其他类也可以调用某类中的内部类
* 内部类一样会生成对应的字节码文件,格式为:外围类名$内部类名.class
匿名内部类是没有名字的内部类,一般用于方法的灵活传参,其中最典型的两种方法如下:
class A {
void fun() {
System.out.println("fun()");
}
}
public class Myinnerclass {
void method(A a) {
a.fun();
}
public static void main(String[] args) {
Myinnerclass my = new Myinnerclass();
my.method(new A() {// 类似于new了一个没有名字的A类型临时对象,重写了fun方法内容,传递给method方法接收。调用就是重构的方法。打印"fun2()"
void fun() {
System.out.println("fun2()");
}
});
}
}
上面这种一般用于重构类,如一些老系统中有的类我们必须继承后再重构其方法,利用这种方式就比较灵活。
还有一种用于接口的情况,我们一般要将接口的实现类赋给接口,再调用其方法,从而达到部分面向接口编程。但这样必须写多个实现接口的实现类,如果其中有方法需要
重构时,就需要重新写实现接口的类。这时可使用匿名内部类写法技巧,达到代码的简化,如下:
interface Iface { // 声明一个接口
void fun();
}
class Ifaceimp {
void test(Iface ia) {// 准备接收该接口的实现类
ia.fun();
}
}
public class Myinner2class {
public static void main(String[] args) {
Ifaceimp imp = new Ifaceimp();
imp.test(new Iface() { // 语法:new 接口(){方法体} 相当于创建了一个临时的对象,该对象实现了Iface接口,打印"fun"
public void fun() {
System.out.println("fun");
}
});
imp.test(new Iface() { // new 接口() 相当于创建了一个实现该接口的具体的类,只是没有名称(匿名内部类),这时就可以重构其方法,打印"fun2"
public void fun() {
System.out.println("fun2");
}
});
}
}
由此可见,编码时适当的使用匿名内部类写法可以简化代码,但对于初学者而言可读性不强