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

今天药忘吃喽~ 2022-12-02 00:55 88阅读 0赞

## 内部类 ##

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

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

### 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;
            }
        }
    }