JAVA面向对象内部类

在内中定义类则为内部类

访问特点：

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

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

     

   外部类名.内部类名 对象名 = 外部类对象.内部类对象；

public class inner {
    public static void main(String[] args) {
        Outer.Inner i=new Outer().new Inner(); //创建内部类对象
        i.method();
    }
}
class Outer {
    class Inner {
        public void method() {
            System.out.println(12345);
        }
    }
}

运行结果

public class inner {
    public static void main(String[] args) {
        Outer.Inner i=new Outer().new Inner(); //创建内部类对象
        i.method();
    }
}
class Outer {
    private int num = 10;
    class Inner {
        public void method() {
            System.out.println(num);
        }
    }
}

 运行结果

成员内部类私有使用

public class inner {
    public static void main(String[] args) {
        Outer i=new Outer();
        i.print();
    }
}
class Outer {
    private int num = 10;
    private class Inner {
        public void method() {
            System.out.println(num);
        }
    }
    public void print() {
        Inner n=new Inner();
        n.method();
    }
}

运行结果

静态成员内部类

public class inner {
    public static void main(String[] args) {
        Outer.Inner i=new Outer.Inner();
        i.method();
    }
}
class Outer {

    static class Inner {
        public void method() {
            System.out.println(234567);
        }
    }
  
}

外部类名.内部类名 对象名 = 外部类名.内部类对象;

new之所以放在前面是因为书写习惯

public class inner {
    public static void main(String[] args) {
        Outer.Inner i=new Outer.Inner();
        Outer.Inner.i.method();
    }
}
class Outer {

    static class Inner {
        public static void method() {
            System.out.println(234567);
        }
    }

}

面试题

在输出中修改使得输出30 20 10

public class inner {
    public static void main(String[] args) {
        Outer.Inner i=new Outer().new Inner();
        i.method();
    }
}
class Outer {
    public int num=10;
    class Inner {
        public int num=20;
        public void method() {
            int num=30;
            System.out.println(num);
            System.out.println(this.num);
            System.out.println(Outer.this.num);
        }
    }

}

运行结果

局部内部类访问局部变量的

public class n {
    public static void main(String[] args) {
        Outerr o=new Outerr();
        o.method();
    }
}
class Outerr {
    public void method() {
        final int num=10;
        class Interr {
            public void print() {
                System.out.println(num);
            }
        }
        Interr i = new Interr();
        i.print();
    }
}

为什么num要用final修饰

为了延长num的声明周期，当调用方法时num的生命周期跟方法的声明周期是一样的，当方法弹栈，这个局部变量也会消失，那么如果局部内部类对象还没由马上消失想用这个局部变量，就没有了，但是用final修饰会加载进常量池，即使方法弹栈，常量也还在常量池，依旧可以继续使用，但是jdk1.8取消了这个事情，可以不加final了

匿名内部类：

        就是内部类的简化写法、

前提：存在一个类或者接口

new 类名或者接口名() {
    重写方法;
}

本质是一个继承了该类或者实现了该接口的子类匿名对象

核心重点是“父类引用指向子类对象”

public class Inter {
    public static void main(String[] args) {
        Outer o=new Outer();
        o.method();
    }
}
interface Interr {
    public void print();
}
class Outer {
   /* class Inner implements Interr {
        public void print() {
            System.out.println(2345);
        }

    }*/
    public void method() {
        new Interr() {
            public void print() {
                System.out.println(2345);
            }
        }.print();
    }
}

匿名内部类重写多个方法调用

public class NoNameInner {
    public static void main(String[] args) {
        Outer o =new Outer();
        o.methods();
    }
}
interface Inter {
    public void show1();
    public void show2();
}
class Outer {
    public void methods() {
        Inter i =new Inter() {
            public void show1() {
                System.out.println("show1");
            }

            public void show2() {
                System.out.println("show2");
            }

        };
        
        i.show1();
        i.show2();
    }
}

运行结果

 

匿名内部类是不能向下转型的因为没有子类类名，因此如果内部有自己的方法则无法调用

匿名内部类在开发中的应用

public class NoNameInner {
    public static void main(String[] args) {
        PersonDemo pd=new PersonDemo();
        pd.method(new Person(){
            public void show() {
                System.out.println(23);
            }
        });
    }
}
abstract class Person {
    public abstract void show();
}
class PersonDemo {
    public void method(Person p) {
        p.show();
    }
}

匿名内部类当作参数传递，本质把匿名内部类看作一个对象

面试题

//按照要求补全代码
public class Noname {
    public static void main(String[] args) {
        Outer.method().show();
    }
}
interface Inter {
        void show();
}
class Outer {
    
}        

public class NoName {
    public static void main(String[] args) {
        Outer.method().show();
    }
}
interface Inter {
public void show();
        }
class Outer {
    public static Inter method() {
        return new Inter() {
            public void show() {
                System.out.println(123);
            }
        };
    }
}

链式编程，每次调用方法后还能继续调用方法，证明调用方法返回的是对象

Outer.method().show();


Inter i=Outer.methods();
i.show();

他们的效果是一样的