Nested methods

Question

I'm missing this programming techinque very much. I find 3 reasons to use nested methods: hierarchic code is easier to understand, no need to pass local variables as paraters and resulting speedup.
Here is an example from one of the replays on the topic:
class Foo {
     int num;
     void foo() {
          num = 3;
          class MethodClass {
               void printHI() { System.out.println("HI"); }
          MethodClass.printHI();
          MethodClass.printHI();
}The author of this example stated that it's very un-OO, meantime Java doesn't support nested methods.
Is it really bad OO practise? I suppose that having nested methods makes reflection more complex, in place of class methods we would have hierarchy of methods. In fact Java classes should already have hirearcy of nested variables (classes). Why not to make the same thing for methods? I'm not sure wheter it's correct Dephi's RTTI and reflection but methods nesting doesn't harm to RTTI.
I see that creating an instance of class just for calling one of its methods is not very effective and slows down the execution even more than passing local variables as parameters in the case of non-nested functions.

Answer 1

Does this code looks like algorithm?
method1() {
     do(1);
     do(2);
     do(3);
     do(1);
     do(2);
     do(3);
}When do you define new procedure? IMO a procedure is a snippet of reusable code. Thus I would define procedure do123() {
     do(1);
     do(2);
     do(3);
}and would write
method1() {
     do123();
     do123();
}Imagine that this sequence (do 1, do2, do3, do1, do2, do3) is not used only by method1. In this case procedure do123 is (re)used only by method1 scope. I can't find any reason to define this procedure in the object scope, even specifying it as private. do123 should be defined in the scope of method1. Even worse, when you want to use method1 local variables from do123.
proposed.
advantages:
     1) the procedure do123() is defined and
        used only at metod1 scope
     2) no need to pass parameter a into the procedure
        do123
void method1() {
     int a = x;
     void do123() {
          use(a);
     do123();
/*Java implementation 1.
disadvantages:
     1) the procedure do123() is used only from method1 scope
        while it is defined at object scope
     2) we need to pass parameter a into the procedure do123 that
        is verbose too and sows down run time
private void do123(int a) {
     use(a);
void method1() {
     int a = x;
     do123(a);
/*Java implementation 2.
disadvantages:
     1) the procedure do123() is used only from the scope of
        method1 but is defined at the object scope
     2) we need to define variable a at the object scope while it
        is used only in method1
private int a = x;
private void do123() {
     use(a);
void method1() {
     do123();
}They told that private methods are inlined, but it is not possible for recursive calls and it is not true for normal privates, because there is a special bytecode to invoke private methods. Because methods are not inlined all parameters must be copied into new stack frame.
Objects can incapsulate data and methods, methods incapsulate only local variables. If incapsulation is a key OOP notion then why we can't incapsulate methods onto methods?
I'm trying to tell that nested methods is an extremly powerful feature in describing algoritms. Using local methods would lead to less verbose, easier to maintain and faster code.