内部类——四种内部类的语法以及运用规则，最简单最易懂附代码演示

内部类

类/接口里定义类——内部类
类里定义类

• 方法内部类
• 成员内部类
• 静态内部类
• 匿名内部类

1. 方法内部类

1.1 概念
在方法内定义类
可以定义所有的非静态信息以及静态常量
可以正常的继承和实现
不能被访问权限修饰符来修饰，但是可以被abstract和final修饰
可以获取外部类所有的信息
只能获取当前方法的常量信息

1.2 代码演示

package cn.tedu.inner;

public class InnerDemo1 {
    public static void main(String[] args) {
        //创建外部类调用方法，执行创建内部类对象的语句
        new Outer1().m();
    }
}
//外部类
class Outer1{
    //属性
    private static int k=1;
    //方法
    public void m(){
        int y=1;//在jdk1.8以前定义常量需要手动加上final
                //在jdk1.8及其以后定义变量时底层默认添加final，
                // 但是如果手动添加了底层就不再添加
        //方法内部类
        //定义所有非静态信息以及静态常量
        //可以正常继承和实现
        //不能被访问权限修饰符修饰，但是可以被abstract和final来修饰
        //可以获取外部类的所有信息
        //只能获取本方法的常量
         class Inner1 extends Object implements Cloneable{
            static final int x=1;
            public void n(){
                System.out.println(k);
                System.out.println(y);
            }
        }
        //创建方法内部类对象
        Inner1 in1=new Inner1();
        in1.n();
    }
}

2. 成员内部类

2.1 概念
在成员位置定义类
可以定义所有的非静态信息以及静态常量
可以正常的继承和实现
可以让访问权限修饰符以及abstract和final来修饰
可以获取外部所有类的信息：Outer2.Inner2 inner2=new Outer2().new Inner2();

2.2 代码演示

package cn.tedu.inner;

import java.util.Scanner;
public class InnerDemo2 {
    public static void main(String[] args) {
        //Outer2.Inner2表示内部类
        //Outer2.Inner2 inner2=new Outer2().in2;
        //in2=new Inner2();
        Outer2.Inner2 inner2=new Outer2().new Inner2();
    }
}
//外部类
class Outer2{
    //属性
    static int k=1;
    //非静态属性
    Inner2 in2=new Inner2();
    //成员内部类
    //可以定义所有的非静态信息以及静态常量
    //可以正常的继承和实现
    //可以让访问权限修饰符以及abstract和final来修饰
    //可以获取外部所有类的信息
    class Inner2 extends Object implements Cloneable{
        static final int x=1;
        public void n(){
            System.out.println(k);
            m();
        }
    }
    //方法
    public void m(){}
}

3. 静态内部类

3.1 概念
成员内部类被static修饰
可以定义所有信息
可以正常的继承和实现
可以让访问权限修饰符以及abstract和final来修饰
只能获取外部类的静态信息：Outer3.Inner3 inner3=new Outer3.Inner3();

3.2 代码演示

package cn.tedu.inner;

public class InnerDemo3 {
    public static void main(String[] args) {
        //创建静态内部类对象
        Outer3.Inner3 inner3=new Outer3.Inner3();
    }
}
//外部类
class Outer3{
    //属性
    static int k=1;
    //
    static Inner3 in3=new Inner3();
    //静态内部类----static修饰的类一定是内部类
    //可以定义所有信息
    //可以进行正常的继承和实现
    //可以让访问权限修饰符以及abstract和final来修饰
    //只能获取外部类的静态信息
    static class Inner3 extends Object implements Cloneable{
        static final int x=1;
        public void n(){
            System.out.println(k);
        }
    }
    //方法
    public void m(){}
}

4. 匿名内部类

4.1 概念
匿名内部类
用于继承类/实现接口，重写抽象方法
可以被继承的类/接口都可以拥有匿名内部类的形式
匿名内部类只能使用一次
当做参数传递时来使用

4.2 代码演示

package cn.tedu.inner;

public class InnerDemo4 {
    public static void main(String[] args) {
        //创建抽象类子类对象
       /* D d=new D();
        d.m();*/
        //匿名内部类
        //继承类，重写抽象方法，创建匿名内部类的对象
        //当类可以被继承/是接口时，拥有匿名内部类的形式
        //只能使用一次
        C c=new C() {
            @Override
            public void m() {
                System.out.println(1);
            }
        };
        c.m();
        D d=new D(){};
        //普通类也具有匿名内部类的形式
        B b=new B(){};
        //接口也具有匿名内部类的形式
        A a=new A(){};
        //调用方法
        //匿名内部类当做参数使用
        m(new A(){});
    };
    //
    public static void m(A a){  //只能接收A接口的实现类对象
    }
}
//接口
interface A{}
//普通类
class B{}
//
abstract class C{
    public abstract void m();
}
class D extends C{
    @Override
    public void m() {
        System.out.println(1);
    }
}

接口里定义类/内部接口默认都是被static修饰

package cn.tedu.inner;

public class InnerDemo5 {
    public static void main(String[] args) {
        System.out.println(Outer5.Inner5.i);
        System.out.println(Outer5.Inner6.j);
        System.out.println(Outer5.Inner5.Inner7.x);
    }
}
interface Outer5{
    //接口里定义接口，默认被static修饰
    static interface Inner6{
        int j=1;
    }
    //接口里定义内部类默认被static修饰
    static class Inner5{
        static int i=1;
        //类里定义接口,默认被static修饰
        static interface Inner7{
            int x=1;
        }
    }
}