内部类(成员内部类、静态内部类、匿名内部类)

成员内部类

//语法结构
修饰符 class 外部类名称{
    修饰符 class 内部类名称{
		//....
    }
   //...
}

使用方法

直接在外部类的方法里面创建内部类，调用内部类的方法即可

public class outside {
    public void outsedeMethod(){
        System.out.println ("这个外部类的方法！");
        new inner ().eat ();
    }
    class inner{
        public  void eat(){
            System.out.println ("老莫，我想吃鱼！");
        }
    }
}
public class DemoinnerClass {
    public static void main(String[] args) {
        outside outside = new outside ();
        outside.outsedeMethod ();
    }
}
=========打印结果==========
这个外部类的方法！
老莫，我想吃鱼！

总结：

• 主要是用来弥补单继承的缺陷，补充类的功能
• 除了外部类都无法直接访问内部类，可以提供更好的隐蔽性
• 内部类定义的 private 属性外部类也不可以访问，因此对外界来说，比 private 的访问权限更小
• 成员内部类不允许有任何的静态成员，必须先创建外部类再创建内部类

静态内部类

//语法结构
修饰符 class 外部类名称{
    static class 内部类名称{
		//....
    }
   //...
}

使用方法

public class outside {
    public void outsedeMethod(){
        System.out.println ("这个外部类的方法！");

    }
    public static void eat(){
        System.out.println ("我今天想吃鲫鱼！");
    }
    
    static class inner{
        public  void eat(){
            System.out.println ("老莫，我想吃鱼！");
        }
        public void eatmore(){

            new outside ().outsedeMethod ();
            eat ();
        }
    }
}
public class DemoinnerClass {
    public static void main(String[] args) {
        outside.inner inner = new outside.inner ();
        inner.eat ();
        inner.eatmore ();
    }
}
========打印结果=========
老莫，我想吃鱼！
这个外部类的方法！
老莫，我想吃鱼！

总结：

• 静态内部类可以直接访问外部类的静态成员，包括私有的,但是不能访问非静态成员–>需要创建创建实例对象调用

• 创建静态内部类不需要创建外部类，可以直接使用 new 外部类.内部类.方法 来调用静态内部类的方法

• 静态内部类可以有静态或非静态的成员，且获取静态内部类对象时，不需要先创建外部类对象

  匿名内部类

匿名内部类是局部内部类的一种简化形式.本质上是一个对象,是实现了该接口或继承了该抽象类的子类对象

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

使用方法

public interface Eating {
    public  void eat();
}
public class anonymousinnerClass {
    public static void main(String[] args) {
        new Eating (){
            @Override
            public void eat(){
                System.out.println ("吃鱼！");
            }
        }.eat ();
    }
}

=============打印==================
    吃鱼！
    
 public abstract class Eating {
    public abstract void eating();
}   
public class outside {
    public void outsedeMethod(){
        System.out.println ("这个外部类的方法！");
    }
    public static void eat(){
        System.out.println ("我今天想吃鲫鱼！");
    }
    static class inner{
        public  void eat(){
            System.out.println ("老莫，我想吃鱼！");
        }
        public void eatmore(){

            new outside ().outsedeMethod ();
            eat ();
        }
    }
}    
  =============打印==================
我今天想吃鲫鱼
我今天想吃鳜鱼！
    
    
    
    

总结：

• 匿名内部类，经常作为参数，或返回值，使用比较方便
• 不需要重新写一个类再实现接口，减少资源浪费*
• 一个类中可以嵌套一个接口，并调用重写后的方法