Java:内部类
内部类
1.概念:在一个类中定义一个类
public class 类名 {
修饰符 class 类名 {
}
}
2.内部类访问特点:
- 内部类可以直接访问外部类的成员,包括私有
- 外部类要访问内部类的成员,必须创建对象
public class Outer {
private int num=20;
public class Inner{//内部类访问外部类成员
public void show(){
System.out.println(num);
}
}
public void method() {//外部类访问内部类的成员
//show();--报错
Inner i = new Inner();//创建内部类对象
i.show();//调用内部类方法
}
public static void main(String[] args) {
Outer o=new Outer();
o.method();
}
}
普通内部类
普通内部类,普通内部类对象依赖外部类对象而存在,即在创建一个普通内部类对象时首先需要创建其外部类对象
(测试类和Outer类不在一块,分开的)
创造对象方法
public class Demo {
public static void main(String[] args) {
//创建内部类对象,并调用方法
// Inner oi=new Inner();报错
Outer.Inner oi=new Outer().new Inner();
oi.show();
}
}
上面这种写法针对的是Inner是public,如果Inner是private这样的写法就是失效了,如果Inner是private我们怎么调用Inner的show方法呢:
成员内部类
(在类的成员位置)
public class Demo {
public static void main(String[] args) {
Outer outer=new Outer();
outer.method();
}
}
public class Outer {
private int num=20;
private class Inner{//可以有public
public void show(){
System.out.println(num);
}
}
public void method(){
Inner inner=new Inner();
inner.show();
}
}
局部内部类
(在类的局部位置,就是类的方法体里)
局部内部类是在方法中定义的类,所以外界是无法直接使用,需要在方法内部创建对象并使用
该类可以直接访问外部类的成员,也可以访问方法内(局部内部类所在的方法体)的局部变量
public class Demo {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
public class Outer {
private int num=20;
public void method(){
int num2=10;
class Inner{//不可以有public
public void show(){
System.out.println(num);//输出外部变量,访问外部类的成员
System.out.println(num2);//输出局部变量,访问方法内的局部变量
}
}
Inner inner=new Inner();
inner.show();
//在方法内部创建对象并使用该类可以直接访问外部类的成员
}
}
匿名内部类
(是局部内部类的一种特殊方法,所以同样是在类的方法的方法体内进行声明,本质是继承了该类或者实现该接口的子类匿名对象)
格式(内部类也是在方法体里面书写)
new 继承的类名或者实现的接口名(){
@Override
public void 抽象方法名() {
//重写方法
}
};//分号不要漏
举个例子:
public interface Inner {
public abstract void show();
}
public class Outer {
private int num=20;
public void method(){
new Inner(){
@Override
public void show() {
System.out.println("匿名内部类");
}
};
}
}
new Inner(){
@Override
public void show() {
System.out.println("匿名内部类");
}
};
本质是一个对象,只不过这个对象没有名字而已,既然是对象,就可以通过对象调方法
new Inner(){
@Override
public void show() {
System.out.println("匿名内部类");
}
}.show();
如果要多次调用这个对象的show方法一直复制肯定不合理,所以:
我们可以看出一个对象是一个Inner类型的实现对象,所以就可以赋给Inner的接口,也就是
Inner i = new Inner(){
@Override
public void show() {
System.out.println("匿名内部类");
}
}.show();
绕来绕去匿名内部类到底有什么用呢?——关键点,匿名内部类的本质就是一个对象,而且是实现了该接口或者继承了该类的,而且是匿名的。
public interface Jumping {
public abstract void jump();
}
public class Cats implements Jumping{
@Override
public void jump() {
System.out.println("猫可以跳高了");
}
}
public class Dogs implements Jumping{
@Override
public void jump() {
System.out.println("狗可以跳高了");
}
}
public class JumpOperator {
public void method(Jumping j){
j.jump();
}
}
public class Demo {
public static void main(String[] args) {
JumpOperator jumpOperator=new JumpOperator();
Jumping cat=new Cats();
jumpOperator.method(cat);
Jumping dog=new Dogs();
jumpOperator.method(dog);
}
}
猫可以跳高了
狗可以跳高了
如果有更多的动物可以跳高了,就得定义一个个新的类,这里我们就可以采用匿名内部类代替
public interface Jumping {
public abstract void jump();
}
public class JumpOperator {
public void method(Jumping j){
j.jump();
}
}
public class Demo {
public static void main(String[] args) {
JumpOperator jumpOperator = new JumpOperator();
jumpOperator.method(new Jumping() {
//匿名内部类的本质就是一个对象,实现了Jumping这个接口
@Override
public void jump() {
System.out.println("猫可以跳高了");
}
});
jumpOperator.method(new Jumping() {
@Override
public void jump() {
System.out.println("狗可以跳高了");
}
});
}
}