面向对象—深度剖析内部类
面向对象—深度剖析内部类
内部类在我们编程中虽不常用，但在某些方面仍具有一技之长
这里我们深度介绍一下内部类，成员内部类和匿名内部类并给出匿名内部类的一个编程常用方法
内部类
内部类概述：
- 在一个类里定义一个类（如在一个类A中定义类B，类B称为内部类）
内部类定义格式：
public class 类名{
修饰符 class 类名{
......
}
}
内部类访问特征:
- 内部类可以直接访问外部类的成员,包括私有成员
- 外部类要访问内部类的的成员,必须创建对象
成员内部类
成员内部类是内部类的一种,主要辨别方法是:类B位于类A的成员位置
成员内部类:
public class Demo1 {
private int i=1;
//创建成员内部类
public class Demo1Inner{
......
}
}
外部创建成员内部类方法:
外部类名.内部类名 对象名 = new 外部类对象.内部类对象
下面我们给出详细案例进行剖析:
public class application {
public static void main(String[] args) {
//在主函数我们只需要创建外部类对象，然后通过外部类对象访问内部类方法
Demo1 demo = new Demo1();
demo.inneruse();
//当然我们也可以建造内部类对象
//格式：外部类名.内部类名 对象名 = new 外部类对象.内部类对象
Demo1.Demo1Inner demoinner = new Demo1().new Demo1Inner();
demoinner.jump();
}
}
public class Demo1 {
private int i=1;
//创建内部类
public class Demo1Inner{
//内部类的函数一般是隐藏的,因为内部类不希望外界直接访问，而是通过外部类的方法来访问
//内部类可以调用外部类的private
private void say(){
System.out.println("saying");
}
public void jump(){
System.out.println("jumping");
}
}
//在外界创造一种方法来访问内部类的功能
public void inneruse(){
Demo1Inner D = new Demo1Inner();
D.say();
}
}
运行结果:
saying
jumping
局部内部类
局部内部类是内部类的一种,主要辨别方法是:类B位于类A的局部位置
局部内部类:
public class Demo1 {
private int i=1;
//创建局部内部类,在方法中创建类
public void nums(){
//创建局部内部类
class inner{
...
}
//在方法中使用类
inner ins = new inner();
ins.run();
}
}
外部不需要调用局部内部类,只需要创建对象,然后调用相对应方法即可
下面给出实际案例剖析:
public class application {
public static void main(String[] args) {
Demo1 demo = new Demo1();
demo.nums();
}
}
public class Demo1 {
private int i=1;
//创建局部内部类,在方法中创建类
public void nums(){
//创建局部内部类
class inner{
//在类里定义方法
public void run() {
System.out.println("running");
}
}
//在方法中使用类
inner ins = new inner();
ins.run();
}
}
运行结果:
running
匿名内部类
匿名内部类的主要特征是:隐藏类名,作为一次性类使用,并且该类的是对象
匿名内部类的前提:需要存在一个类或接口,这里的类可以是具体类也可以是抽象类
匿名内部类创建方法:
- 首先需要一个接口或类作为媒介
//匿名内部类需要一个类或接口作为媒介
public interface Demo2 {
void run();
}
- 在另一个类中使用该接口创造类(注意:如果使用匿名类,需要重写接口和类的所有未定义方法)
public class Demo1 {
//匿名内部类也需要在方法中实现
public void s(){
//相当于创建一个匿名方法类
new Demo2(){
public void run(){
System.out.println("running");
}
};
}
我们直接给出实例展现匿名内部类的使用方式:
public class application {
public static void main(String[] args) {
Demo1 demo = new Demo1();
demo.s();
}
}
public class Demo1 {
//匿名内部类也需要在方法中实现
public void s(){
//相当于创建一个匿名方法类
new Demo2(){
public void run(){
System.out.println("running");
}
};
//如何使用匿名方法类呢
//匿名方法类实际上是一个对象，我们可以把它当作对象来使用：
//这里直接当作对象来调用
new Demo2(){
public void run(){
System.out.println("running");
}
}.run();
//这里当作对象来赋值：
//接口 接口对象名 = new 匿名方法类
Demo2 demo = new Demo2(){
public void run(){
System.out.println("running");
}
};
demo.run();
}
}
//匿名内部类需要一个类或接口作为媒介
public interface Demo2 {
void run();
}
匿名类实用性
这里我们给出匿名类的一种开发实用性:
这里给出跳高接口:
public interface Demo2 {
//参口是跳高
void jump();
}
这里给出接口操作类,里面有一个方法,方法参数是接口名:
public class Demo1 {
public void name(Demo2 de){
de.jump();
}
}
然后我们希望创建跳高参口对象并实现jump:
public class application {
public static void main(String[] args) {
.......
}
}
如果我们按照正常逻辑,应当是先创建类,该类继承于接口,并在main方法创建Demo1对象使用方法:
public class application {
public static void main(String[] args) {
//首先创造Demo1的对象
Demo1 demo1 = new Demo1();
//这里使用往常方法，创建类然后带入，但多数类会导致文件繁杂
demo1.name(new Demo3());
}
}
public class Demo3 implements Demo2 {
public void jump(){
System.out.println("cat jumping");
}
}
但如果我们学习了匿名内部类,并且该类后来不需要使用:
public class application {
public static void main(String[] args) {
//首先创造Demo1的对象
Demo1 demo1 = new Demo1();
//创造匿名内部类直接使用，而不是新创建类来使用方法
demo1.name(new Demo2() {
@Override
public void jump() {
System.out.println("dog jumping");
}
});
}
}
我们就可以直接使用匿名内部类来代替Demo1中的接口参数来节省空间
结束语
好的,关于内部类的详解就讲解到这里
