内部类
内部类提供了更好的封装,可以把内部类隐藏在外部类之内,不允许同一个包中的其他类访问该类。假设需要创建Cow类,Cow类需要组合一个CowLeg对象,CowLeg类只有在Cow类里才有效,离开Cow类之后没有任何意义。在这种情况下,就可以把CowLeg类定义成Cow的内部类,不允许其他类访问CowLeg类。
内部类的访问规则;
1,内部类可以直接访问外部类中的成员,包括私有。
之所以可以直接访问外部类中的成员,是因为内部类中持有了一个外部类的引用,格式是
外部类名.this
代码第十一行
Outer.this.x —– 输出3
this.x ————- 输出4
x ——————- 输出6
2,外部类要访问内部类,必须建立内部类对象。
class Outer{
private int x = 3;
class Inner { //内部类
int x = 4;
void function(){
int x = 6;
System.out.peintln("inner :"+Outer.this.x);
}
}
void method(){
Inner in = new Inner();
in.function();
}
}
class InnerClassDemo{
public static void main(String[] args){
outer out = new Outer();
out.method();
/*
直接访问内部类中的成员
Outer.Inner in = new Outer().new Inner();
in.function();
*/
}
}
访问格式;
1.当内部类定义在外部类的成员位置上,而且非私有,可以在外部其他 类中。可以直接建立内部类对象。
格式
外部类名.内部类名 变量名 = 外部类对象.内部对象;
Outer.Inner in = new Outer().new Inner();
2当内部类在成员位置上.就可以被成员修饰符所修饰。
比如,private:将内部类在外部类中进行封装。
private class Inner{}
静态内部类
static:内部类就具备了static的特性。
static class Inner{} //静态内部类
当内部类被static修饰后,只能直接访问外部类中的static成员。出现了访问局限。
在外部其他类中如何直接访问静态内部类的非静态成员呢?
class Demo1_InnerClass {
public static void main(String[] args) {
//外部类名.内部类名 对象名 = 外部类名.内部类对象;
Outer.Inner oi = new Outer.Inner();
oi.method();
}
}
class Outer {
static class Inner {
public void method() {
System.out.println("method");
}
}
}
new Outer.Inner().method();
new一个内部类对象来调用method 方法。
在外部其他类中,如何直接访问静态内部类的静态成员呢?就是将public void method(){} 变为 public static void method(){}.
Outer.Inner.method();
注意:
当内部类中定义了静态成员,该内部类必须是static的。
当外部类中的静态方法访问内部类时,内部类也必须是static的。
局部内部类
局部内部类,只能在其所在的方法中访问
class Demo1_InnerClass {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
//局部内部类
class Outer {
public void method() {
final int num = 10;
class Inner {
public void print() {
System.out.println(num);
}
}
Inner i = new Inner();
i.print();
}
}
局部内部类访问局部变量必须用final修饰
局部内部类在访问他所在方法中的局部变量必须用final修饰,为什么?
因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用但是jdk1.8取消了这个事情,所以我认为这是个bug
如果不加final,内存变化如图所示
匿名内部类
匿名内部类是局部内部类的一种,必须写在方法里。匿名内部类就是内部类的简化写法。
(1)前提:存在一个类或者接口
*这里的类可以是具体类也可以是抽象类。
(2)格式:
new 类名或者接口名(){
重写方法;
}
(3)本质是什么呢?
*是一个继承了该类或者实现了该接口的子类匿名对象。
首先演示内部类实现接口
class Demo{
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
interface Inter {
public void print();
}
class Outer {
class Inner implements Inter {
public void print() {
System.out.println("print");
}
}
public void method(){
new Inner().print();
}
}
匿名内部类实现接口
class Demo {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
interface Inter {
public void print();
}
class Outer {
public void method(){
new Inter() { //实现Inter接口
public void print() { //重写抽象方法
System.out.println("print1");
}
}.print();
}
}
匿名内部类只针对重写一个方法时使用
练习
按照要求,补齐代码
interface Inter { void show(); }
class Outer { //补齐代码 }
class OuterDemo {
public static void main(String[] args) {
Outer.method().show();
}
}
要求在控制台输出”HelloWorld”
outer调用完method方法后还能调用show方法,说明method方法返回的是一个Inter的一个子类对象
class Test2_NoNameInnerClass {
public static void main(String[] args) {
//Outer.method().show(); //链式编程,每次调用方法后还能继续调用方法,证明调用方法返回的是对象
Inter i = Outer.method();
i.show();
}
}
interface Inter {
void show();
}
class Outer {
//补齐代码
public static Inter method() {
return new Inter() { //代表返回Inter的子类对象
public void show() {
System.out.println("show");
}
};
}
}