内部类

• 内部类
• 1. 分类
• • 1.1 成员内部类
  • • 1.1.1 成员内部类外界如何访问？
  • 1.2 局部内部类
  • 1.3 匿名内部类
  • 1.4 匿名内部类的应用
  • • 案例：
    • 示例代码：

成员内部类和局部内部类

格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象

譬如：

Outer.Inner oi = new Outer().new Inner();

示例

public class Outer {


    private int age = 10;

    //    public class Inner{
//        public void show(){
//            System.out.println(age);
//        }
//    }
    private class Inner {
        public void show() {
            System.out.println(age);
        }
    }

    public void method(){
        Inner inner = new Inner();
        inner.show();
    }
}

public class test {
    public static void main(String[] args) {
        //创建内部类方法并调用
//        Outer.Inner oi = new Outer().new Inner();
//        oi.show();
        Outer outer = new Outer();
        outer.method();
    }
}

//output
10

注意inner方法通常使用private修饰，这时调用inner方法就需要在outer下写方法，类似于之前的getter/setter方法，达到封装效果。

局部内部类是在方法内部中定义的类，所以外界无法直接使用，需要在方法内部创建对象并使用
该类可以直接访问外部类的成员，也可以访问方法中的成员变量

示例代码

package com.outer_inner;

public class Outer {


    private int age = 10;

    //    public class Inner{
//        public void show(){
//            System.out.println(age);
//        }
//    }


    public void method() {
        int num = 100;
        class Inner {
            public void show() {
                System.out.println(age);
                System.out.println(num);
            }
        }
        //创建对象调方法
        Inner inner = new Inner();
        inner.show();

    }
}

package com.outer_inner;

public class test {
    public static void main(String[] args) {
        //创建内部类方法并调用
//        Outer.Inner oi = new Outer().new Inner();
//        oi.show();
        Outer outer = new Outer();
        outer.method();
    }
}

//output
10
100

前提：存在一个接口或者一个类；该类可以是具体类或抽象类
格式：
new 类名或接口名(){ 重写方法;};
注意：匿名内部类结尾部分有分号
本质：是一个继承了该类或者实现了该接口的子类匿名对象，简而言之，本质是一个对象

格式示例：

    new Inter(){
    	//重写方法
        public void show(){  
        }
    };

代码示例：

package com.outer_inner;

public interface inter {
    public abstract void show();
}

package com.outer_inner;

public class Outer {

//    new Inter(){
//        public void show(){
//
//        }
//    }


    private int age = 10;

    //    public class Inner{
//        public void show(){
//            System.out.println(age);
//        }
//    }


    public void method() {

//        new inter(){
//            @Override
//            public void show() {
//                System.out.println("匿名内部类");
//            }
//        };//这里只是定义了一个匿名内部类，仅仅是一个对象
//        new inter() {
//            @Override
//            public void show() {
//                System.out.println("匿名内部类");
//            }
//        }.show();//这里就表示对象并且调用了方法

        inter i = new inter(){//这里inter()为inter接口的实现类对象，通过多态的形式赋给i；这是由于匿名接口的的本质是一个对象或者接口的实现类对象
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        };//这里就表示对象并且调用了方法

        i.show();
        i.show();

    }
}

package com.outer_inner;

public class test {
    public static void main(String[] args) {
        System.out.println("输出结果为： ");
        //创建内部类方法并调用
//        Outer.Inner oi = new Outer().new Inner();
//        oi.show();
        Outer outer = new Outer();
        outer.method();

    }
}

输出结果为： 
匿名内部类
匿名内部类

注意：一个类的方法，方法的参数名是一个接口名，那么实际上他调用的是该接口的实现类对象；这里其实应该分开写一节的，但是很容易理解，便没再去写了

编写一个调高类接口，在接口操作类里面有一个方法，方法的参数名是一个接口名，在测试类中，床架接口操作类的对象，并调用method()方法
b站视频

package com.nimingDemo;

public interface jumpping {
    void jump();
}

package com.nimingDemo;

public class cat implements jumpping{
    @Override
    public void jump() {
        System.out.println("cat can jump!");
    }
}

package com.nimingDemo;

public class jumpOperator {
    public void method(jumpping j){//new cat();
        j.jump();

    }
}

package com.nimingDemo;

public class jumpDemo {
    public static void main(String[] args) {
        System.out.println("输出结果为：");
        jumpOperator jo = new jumpOperator();
        jumpping j = new cat();
        jo.method(j);

        jo.method(new jumpping() {
            @Override
            public void jump() {
                System.out.println("cat can jump now" +
                        "1");
            }
        });
    }

}

输出结果为：
cat can jump!
cat can jump now1