Java小记——内部类、匿名内部类

目录

内部类

成员内部类

局部内部类

匿名内部类

---

内部类

内部类概念

定义在其他类中的类，称为内部类

内部类访问特点

1.直接访问外部类的成员，包括私有

2.外部类访问内部类成员，必须创建对象

在外部类创建内部类对象     Nei nei = new Nei()

在测试类创建内部类对象    Wai.Nei nei = new Wai().new Nei()

成员内部类

定义在成员位置的类，称为成员内部类

class B {
    //成员内部类
    class A {

    }

    public void show() {
        //局部内部类
        class C {

        }
    }

}

若成员内部类被private修饰（内部类可以被私有，普通类则不行），则不能在测试类中创建内部类对象，只能在外部类中创建内部类对象，再在测试类中创建外部类对象。

public class MyTest {
    public static void main(String[] args) {
        //Wai.Nei nei = new Wai().new Nei();
        //nei.neiShow();     //内部类被私有，不能在测试类创建内部类对象
                            
        Outer outer = new Outer();
        outer.waiShow();    //内部类被私有，只能通过创建外部类对象调用方法来创建内部类对象
    }
}

class Wai {
    //内部类可以私有修饰
    private class Nei {
        public void neiShow() {
            System.out.println("nei show");
        }
    }

    public void waiShow() {
        Inner inner = new Inner();
        inner.neiShow();
    }
}

被static修饰的成员内部类

1.只能访问外部类的静态成员

public class Wai {
    static int num = 100;

    public static class Nei {
        public void neiShow() {
            System.out.println(num);
        }
    }

2.静态的成员内部类，在测试类中创建对象

Wai.Nei nei = new Wai.Nei();

public class MyTest {
    public static void main(String[] args) {
        
        Wai.Nei nei = new Wai.Nei()；
    }
}

*****     :      Outer.this 表示外部类对象

局部内部类

不能直接在测试类创建对象，在方法内创建局部内部类对象，在测试类创建外部类对象调用外部类的方法

public class MyTest {
    public static void main(String[] args) {
        //局部内部类，在外界没有直接创建其对象的语法。
        Wai wai = new Wai();
        wai.waiShow();
    }
}

class Wai {
    int num = 20;
    private double a = 3.5;
    
    public void waiShow() {
        final int num=20;  //默认有final，可不写。

        //局部内部类
        class Nei {
            int t = 50;

            public void neiShow() {
                System.out.println(num);
                System.out.println(a);
            }
        }
        //创建局部内部类对象
        Nei nei = new Nei();
        nei.neiShow();
    }

    public void hehe() {
    }
}

局部变量用final修饰。因为局部变量会随着方法的调用完毕而消失，但是局部对象并没有立马从堆内存中消失，还要继续使用那个局部变量，就要用final修饰，在堆内存中储存为一个常量。

匿名内部类

匿名内部类是局部内部类的简写形式

实质上为一个对象

是继承了抽象类的一个子类对象  或   实现接口类的一个对象

抽象类：

      new Father() {       //父类的子类对象，重写了父类的方法
            @Override
            public void hehe() {
                System.out.println("呵呵呵呵呵呵");
            }
        };


        new Father() {
            @Override
            public void hehe() {
                System.out.println("44444444444444");
            }
        }.hehe();     //子类对象调用了父类方法
    }
}

abstract class Father {     //抽象父类
    public abstract void hehe();
}

接口：

public class MyTest {
    public static void main(String[] args) {
        //我想要得到接口的实现类对象
        new SS() {
            @Override
            public void ss() {
                System.out.println("sssssssssssssssssss");
            }
        };

        new SS() {
            @Override
            public void ss() {
                System.out.println("sssssssssssssssssss888888");
            }
        }.ss();

        //多态
        SS ss = new SS() {
            @Override
            public void ss() {
                System.out.println("sssssssssssssssssss888888");
            }
        };

    }
}


interface SS {
    void ss();
}

若想对对象取名

AA aa = new AA() {
            @Override
            public void aa() {
                System.out.println("aaaaaaaaaaaaaa744444aa");
            }

            @Override
            public void hehe() {
                System.out.println("hehehehehe888877777hhehehhe");
            }
        };
aa.aa();
aa.hehe();

匿名内部类，常作为参数传递或返回值

抽象类 作为参数：

public class MyTest {
    public static void main(String[] args) {
        //匿名内部类，经常作为参数，或返回值，使用比较方便。
        WW ww = new WW() {
            @Override
            public void hehe() {
                System.out.println("aaa");
            }
        };

        test(ww);

        test(new WW() {
            @Override
            public void hehe() {
                System.out.println("bbb");
            }
        });
    }

 
    public static void test(WW ww) {
        ww.hehe();
    }
}


abstract class WW {
    public abstract void hehe();
}

接口 作为参数：

public class MyTest2 {
    public static void main(String[] args) {
        HH hh = new HH() {
            @Override
            public void hh() {
                System.out.println("hhhhhhhhhhhhhhhhh");
            }
        };
        test(hh); //取名传递
        test(hh);


        test(new HH() {
            @Override
            public void hh() {
                System.out.println("hhhhhhhhhhhhhhhhh");
            }
        });  //直接作为参数传递

    }

    //当你以后看到一个方法的形参，要一个接口，类型，你就传递一个该接口的，实现类对象，多态。
    public static void test(HH hh) {
        hh.hh();
    }
}

interface HH {
    void hh();
}

抽象类 作为返回值

public class MyTest {

    public static void main(String[] args) {
        BB bb = getBB();
        bb.bb();

        BB bb2 = getBB2();
        bb2.bb();

        //匿名内部类，作为返回值，返回方便
    }

    //当你以后看到一个方法的返回值，类型是一个抽象类 类型，你就返回一个该抽象类的子类对象。
    public static BB getBB() {

        BB cc = new CC();
        return cc;
    }

    public static BB getBB2() {
        return new BB() {

            @Override
            public void bb() {
                System.out.println("bbbbbbbbbbbbbbbbb222222222");
            }
        };
    }
}

abstract class BB {
    public abstract void bb();
}

class CC extends BB {
    @Override
    public void bb() {
        System.out.println("bbbbbbbbbbbbbbbbbb");
    }
}

接口 作为返回值

public class MyTest {

    public static void main(String[] args) {
        BB bb = getBB();
        bb.hehe();

        BB bb2 = getBB2();
        bb2.hehe();

        //匿名内部类，作为返回值，返回方便
    }

    //当你以后看到一个方法的返回值，类型是一个抽象类 类型，你就返回一个该抽象类的子类对象。
    public static BB getBB() {

        BB cc = new CC();
        return cc;
    }

    public static BB getBB2() {
        return new BB() {

            @Override
            public void hehe() {
                System.out.println("bbbbb66666");
            }
        };
    }
}

interface BB {
    void hehe();
}

class CC implements BB {
    @Override
    public void hehe() {
        System.out.println("666666");
    }
}

在类中定义接口，称为内部接口

public class MyTest {
    public static void main(String[] args) {
        //创建内部接口的子类对象
        Wai.MyInterface myInterface = new Wai.MyInterface() {

            @Override
            public void hehe() {
                System.out.println("呵呵呵呵呵");
            }
        };
        myInterface.hehe();

        Wai wai = new Wai();
        wai.test();

    }
}


class Wai {
    //内部接口
    interface MyInterface {
        void hehe();
    }

    //私有内部接口
    private interface MyInterface2 {
        void hehe2();
    }

    public void test() {
        MyInterface2 myInterface2 = new MyInterface2() {
            @Override
            public void hehe2() {
                System.out.println("2222222222222222");
            }
        };
        myInterface2.hehe2();
    }
}