（Java学习十三天）内部类的知识点

深藏阁楼爱情的钟 2021-12-12 22:11 193阅读 0赞

# 什么是内部类： #

内部类就是定义在一个类内部的类，我们分为四种：成员内部类，静态内部类，方法内部类，匿名内部类

# 为什么用内部类？ #

内部类的好处是：每个内部类都可以独立的继承或者访问接口，与外部类完全不管

## 成员内部类： ##

package lei;
    //成员内部类
    public class ChengYuan {
        public class InnerChengYuan{
            
        }
    }

## 成员内部类的应用： ##

package lei;
    //成员内部类
    // 成员内部类是依附外部类的，只有创建了外部类才能创建内部类
    public class ChengYuan {
        //定义外部类非静态变量，想要通过内部类访问到，代码19-20行
        String Outinner="out inner";
        public static void main(String[] args) {
            // 成员内部类 ：新建内部类的对象
            ChengYuan.InnerChengYuan inner=new ChengYuan().new InnerChengYuan();
            // 成员内部类： 访问成员内部类的方法，通过新建的内部类对象.的形式来访问内部类方法
            inner.show();
            // 成员内部类：通过创建内部类对象，然后通过对象.的方式来访问内部类属性
            System.out.println(inner.name);
    
        }
        public class InnerChengYuan{
            String name="3";
            public void show(){
                //方法访问内部类成员变量
                System.out.println(name);
                //访问外部类成员变量，先new一个外部类对象，通过外部类对象能够访问到外部类成员变量
                ChengYuan cy=new ChengYuan();
                System.out.println(cy.Outinner);
            }
        }
    }

## 静态内部类： ##

由static关键字修饰的内部类，

静态内部类不需要依靠外部类便可以创建(static关键字)，并且静态内部类不能访问外部类的非静态的属性和方法，但可以拥有自己的成员变量。

package neibulei;
    
    public class OutStatic {
        //静态内部类
        public static class InnerStatic{
            
        }
    }

### 静态内部类的访问方式 ###

package neibulei;
    
    public class OutStatic {
        //创建外部类的静态成员变量 代码18行
        static int c=3;
        //静态内部类
        public static class InnerStatic{
            //创建内部类静态对象    代码：6，10行引用
            static int a=1;
            //静态内部类非静态对象 代码13行
            int b=2;
            public  void show(){
                //静态内部类可以直接访问到内部类的静态成员变量
                System.out.println(a);
                //静态内部类方法可以直接访问到内部类非静态成员变量
                System.out.println(b);
                //静态内部类可以直接访问到非静态外部类的静态变量
                System.out.println(c);
            }
        }
    
        public static void main(String[] args) {
            //访问静态内部类的方法：可以直接创建内部类对象，然后对象.的形式来进行调用
            InnerStatic innerStatic =new InnerStatic();
            innerStatic.show();
            //访问静态内部类的方法：因为是static 所以可以和静态常量一样可以用类名.的方式来进行访问
            //这里OutStatic.innerStatic()；是通过外部类.的方式访问内部类 然后创建对象。
            OutStatic.InnerStatic i=new OutStatic.InnerStatic();
            i.show();
        }
    }

# 方法内部类 #

方法内部类就是直接在类中的方法定义一个类，这个类伴随着方法生存，方法在，这个类就在，方法消失，这个类也就消失

package fangfaClass;
    
    public class MethodOut {
        //外部类方法
        public void method(){
            //方法中写一个类：叫做方法内部类，这个类伴随着方法存在，方法在类就在
            class MethodInner{
                public void show(){
                    System.out.println("方法内部类");
                }
            }
            //因为类存在方法中，所以只能在方法中访问
            MethodInner m=new MethodInner();
            m.show();
        }
    }

# 匿名内部类： #

**匿名内部类就是一个没有名字的方法内部类**，因此特点和方法与方法内部类完全一致，匿名内部类的特点：  
1.匿名内部类必须继承一个抽象类或者实现一个接口。  
2.匿名内部类没有类名，因此没有构造方法。

先写一个抽象类：

package ni;
    
    public abstract class Abstract {
        abstract void show();
    }

使用匿名内部类继承这个抽象类

package ni;
    interface Myinterface{
        public void show();
    }
    
    public class NiClass {
    
        //相当于子类继承了这个抽象类，然后对抽象类的抽象方法进行重写，这种情况叫匿名内部类
        Abstract a=new Abstract() {
            @Override
            void show() {
    
            }
        };
        //===========================
        //想当于调用子类调用了Myinterface的接口，然后进行重写方法。
        Myinterface mi=new Myinterface() {
            @Override
            public void show() {
                
            }
        }
    }