内部类的详解和使用

内部类

• 内部类包括了成员内部类、局部内部类、匿名内部类

内部类的基本使用

内部类的概述

• 在一个类中再定义一个类，比如在A类中再定义一个B类，就称B类为内部类。

/*
	格式：
    class 外部类名{
    	修饰符 class 内部类名{
    	
    	}
    }
*/

class Outer {
     
    public class Inner {
     
        
    }
}

• 内部类的访问特点
  • 内部类可以直接访问外部类的成员，包括私有成员
  • 外部类访问内部类时候需要创建对象，通过对象进行访问

/*
    内部类访问特点：
        内部类可以直接访问外部类的成员，包括私有
        外部类要访问内部类的成员，必须创建对象
 */
public class Outer {
     
    private int num = 10;
    
    //  内部类Inner
    public class Inner {
     
        public void show() {
     
            System.out.println(num);
        }
    }
    public void method() {
     
        Inner i = new Inner();
        i.show();
    }
}

成员内部类

• 成员内部类的定义位置和类中的成员变量是一个位置
• 创建成员内部类对象格式
  • 格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象
  • 举例：Outer.Inner oi = new Outer().new Inner();
• 私有内部类
  • 将一个类，设计为内部类的目的，大多数都是不想让外界去访问，所以内部类的定义应该私有化，私有化之后，再提供一个可以让外界调用的方法，方法内部创建内部类对象并调用

class Outer {
     
    private int num = 10;
    private class Inner {
     
        public void show() {
     
            System.out.println(num);
        }
    }
    
    //在method类中，创建内部类的对象，该方法供其他类调用使用
    public void method() {
     
        Inner i = new Inner();
        i.show();
    }
}
public class InnerDemo {
     
    public static void main(String[] args) {
     
		//Outer.Inner oi = new Outer().new Inner();
		//oi.show();
        Outer o = new Outer();
        
        //通过method方法调用私有内部类
        o.method();
    }
}

• 静态成员内部类

  • 静态成员内部类访问格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();

  • 静态成员内部类中的静态方法：外部类名.内部类名.方法名();

class Outer {
     
    static class Inner {
     
        public void show(){
     
            System.out.println("inner..show");
        }

        public static void method(){
     
            System.out.println("inner..method");
        }
    }
}

public class Test3Innerclass {
     
    /*
        静态成员内部类演示
     */
    public static void main(String[] args) {
     
        // 外部类名.内部类名 对象名 = new 外部类名.内部类名();
        Outer.Inner oi = new Outer.Inner();
        oi.show();

        Outer.Inner.method();
    }
}

局部内部类

• 局部内部类定义是在方法中定义的类
• 局部内部类是其他类无法直接使用的，需要在方法内创建对象进行使用
• 局部内部类可以直接访问外部类的成员，也可以访问方法内的局部变量

class Outer {
     
    private int num = 10;
    public void method() {
     
        int num2 = 20;
        class Inner {
     
            public void show() {
     
                System.out.println(num);
                System.out.println(num2);
            }
        }
        //在method方法中创建对象使用局部内部类Inner
        Inner i = new Inner();
        i.show();
    }
}
public class OuterDemo {
     
    public static void main(String[] args) {
     
        Outer o = new Outer();
        o.method();
    }
}

匿名内部类

• 匿名内部类的前提是要存在一个类或者接口，这个类可以是具体类也可以是抽象类
• 匿名内部类的格式：
  • new 类名 ( ) { 重写方法 }
  • new 接口名 ( ) { 重写方法 }

new Inter(){
     
    @Override
    public void method(){
     }
} 

• 匿名内部类的本质是一个继承了该类或者实现了该接口的子类匿名对象
• 匿名内部类可以通过多态的形式接收

//父类引用，子类对象
Inter i = new Inter(){
     
  @Override
    public void method(){
     
        
    }
}

• 匿名内部类直接调用方法

interface Inter{
     
    void method();
}

class Test{
     
    public static void main(String[] args){
     
        new Inter(){
     
            @Override
            public void method(){
     
                System.out.println("我是匿名内部类");
            }
        }.method();	// 直接调用方法
    }
}

• 当某个方法需要接口或者抽象类的子类对象时，可以传递一个匿名内部类来简化代码

//创建接口，可以通过匿名内部类来实现
interface Jumpping {
     
    void jump();
}
class Cat implements Jumpping {
     
    @Override
    public void jump() {
     
        System.out.println("猫可以跳高了");
    }
}
class Dog implements Jumpping {
     
    @Override
    public void jump() {
     
        System.out.println("狗可以跳高了");
    }
}
class JumppingOperator {
     
    public void method(Jumpping j) {
      //new Cat();   new Dog();
        j.jump();
    }
}
class JumppingDemo {
     
    public static void main(String[] args) {
     
        //需求：创建接口操作类的对象，调用method方法
        JumppingOperator jo = new JumppingOperator();
        Jumpping j = new Cat();
        jo.method(j);

        Jumpping j2 = new Dog();
        jo.method(j2);
        System.out.println("--------");

        // 匿名内部类的简化，不用再重新写一个实现类
        jo.method(new Jumpping() {
     
            @Override
            public void jump() {
     
                System.out.println("猫可以跳高了");
            }
        });
		// 匿名内部类的简化
        jo.method(new Jumpping() {
     
            @Override
            public void jump() {
     
                System.out.println("狗可以跳高了");
            }
        });
    }
}