自学Java Day14

学习目标：

• 成员内部类

---

学习内容：

1、创建内部类对象格式：

      外部类.内部类  对象名 = new 外部类对象().new 内部类对象();

注意：内部类，访问外部成员，可以直接访问，包括私有

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

2、成员内部类

成员内部类，也属于（成员），既然是成员就可以被一些修饰符所修饰

private

      私有成员内部类访问：在自己所在的内部类中创建对象访问。

public class Test1Innerclass {
    public static void main(String[] args) {

        Outer o = new Outer();
        o.method();
    }
}

class Outer {
    private class Inner {
        public void show(){
            System.out.println("inner...show");
        }
    }
    public void method(){
        Inner i = new Inner();

         i.show();
    }
}

static

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

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

public class Test2Innerclass {
    public static void main(String[] args) {
        // 外部类名.内部类名 对象名 = new 外部类名.内部类名( );
        Outer.Inner oi = new Outer. Inner();
        oi.show();

        Outer.Inner.method();
    }
}

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

 3、局部内部类

public class Test3Innerclass {
    /*
         局部内部类：
             编写位置：方法中
             访问方式：
     */
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

class Outer {

    int a = 10;

    public void method(){

        int b = 20;

        class Inner {
            public void show(){
                System.out.println("show...");
                System.out.println(a);
                System.out.println(b);
            }
        }
        Inner i = new Inner();
        i.show();
    }
}

4、匿名内部类

格式：

new 类名或者接口名(){

     重写方法

};

范例：

new Inter(){

    public  void show(){

      }

};

public class Test4Innerclass {
    /*
     1. 创建实现类，通过implement关键字实现窗口
     2. 重写方法
     3. 创建实现类对象
     4. 调用重写后的方法

     匿名内部类：
         前提：需要存在类/接口
         格式：
              new 类名/接口名(){
              重写方法
              }
     */
    public static void main(String[] args) {
        InterImpl ii = new InterImpl();
        ii.show();

        // 匿名内部类的理解：将继承\实现，方法重写，创建对象，放在一步进行。
        new Inter(){

            @Override
            public void show() {
                System.out.println("匿名类中的show方法");
            }
        }.show();

        //接口在存在多个方法
        Inter2 i = new Inter2(){

            @Override
            public void show1() {
                System.out.println("匿名类中show1方法");
            }

            @Override
            public void show2() {
                System.out.println("匿名类中show2方法");
            }
        };
        
        i.show1();
        i.show2();
    }
}

interface Inter {
    void show();
}

interface Inter2 {
    void show1();
    void show2();
}

class InterImpl implements Inter{
    @Override
    public void show() {
        System.out.println("InterImpl  重写的show方法");
    }
}

---