Java内部类详解-优快云博客

本文链接：https://blog.youkuaiyun.com/cxs_123/article/details/105949231

如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类。
例如：身体和心脏的关系。又如：汽车和发动机的关系

分类：
1.成员内部类
2.局部内部类（包含匿名内部类）

成员内部类的定义格式：
修饰符 class 外部类名称{
修饰符 class 内部类名称{
//…
}
//…
}
注意：内用外，随意访问；外用内，需要内部类对象。

=================================
如何使用成员内部类？有两种方式：
1.间接方式：在外部类的方法中，使用内部类；然后main只是调用外部类的方法
2.直接方式，公式：
类名称对象名 = new 类名称（）；
【外部类名称.内部类名称对象名 = new 外部类名称().new 内部类名称();】

//Body类
public class Body{//外部类
   public class Heart{//成员内部类
     //内部类的方法
     public void beat(){
       System.out.println("心脏跳动：蹦蹦蹦！")；
       System.out.println("我叫："+name);
     }
   }
   //外部类的成员变量
   private String name;
   //外部类的方法
   //间接方法
   public void methodBody(){
      System.out.println("外部类的方法！")；
      new Heart().beat();
   }
   public String getName(){
     return name;
   }
   public void setName(String name){
       this.name=name;
   }
}

//主程序
public class Demo01InnerClass{
   public static void main(String[] args){
       Body body = new Body();//外部类的对象
       //通过外部类的对象，调用外部类的方法，里面间接在使用内部类Heart
       body.methodBody();

       //按照公式写：
       //直接方式
       Body.Heart heart = new Body().new Heart();
       heart.beat();
   }
}

如果出现了重名现象，那么格式是：外部类名称.this.外部类成员变量名
例：

public class Outer{
   int num=10;//外部类的成员变量
   public class Inner /*extends Object*/{
      int num=20;//内部类的成员变量
      public void methodInner(){
         int num =30;//内部类方法的局部变量
         System.out.println(num);//30 局部变量，就近原则
         System.out.println(this.num);//20 内部类的成员变量
         System.out.println(Outer.this.num);//10 外部类的成员变量
      }
   }
}

如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。
“局部”：只有当前所属的方法才能使用它，出了这个方法外面就不能用了。

定义格式：
修饰符 class 外部类名称{
修饰符返回值类型外部类方法名称(参数列表){
class 局部内部类名称{
//…
}
}
}

小结一下类的权限修饰符：
public > protected > (default) > private
定义一个类的时候，权限修饰符规则：
1.外部类：public / (default)
2.成员内部类：public / protected / (default) / private
3.局部内部类：什么都不能写

//Outer 类
public class Outer{
   public void methodOuter(){
       class Inner{//局部内部类
           int num=10;
           public void methodInner(){
               System.out.println(num);//10
           }
       }
   }
}

//主程序
public class Demo01Main{
   public static void main(String[] args){
       Outer obj = new Outer();
       obj.methodOuter();//10
   }
}

如果接口的实现类(或者是父类的子类)只需要使用唯一的一次，那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】

匿名内部类的定义格式：
接口名称对象名 = new 接口名称(){
//覆盖重写所有抽象方法
}；
不要忘记分号

对格式“new 接口名称() {…};”进行解析：
1.new 代表创建对象的动作
2.接口名称就是匿名内部类需要实现哪个接口
3.{…}这才是匿名内部类的内容

另外还要注意几点问题：
1.匿名内部类，在【创建对象】的时候，只能使用唯一一次。(或者重复覆盖重写接口中的抽象方法)
如果希望多次创建对象，而且类的内容一样的话，那么就必须使用单独定义的实现类了。
2.匿名对象，在【调用方法】的时候，只能使用唯一一次。
如果希望同一个对象，调用多次方法，那么必须给对象起一个名字。
3.匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】
强调：匿名内部类和匿名对象不是一回事！！！

//接口
public interface MyInterface{
   void method1();//抽象方法
   void method2();//抽象方法
}
//主程序
public class Demo02Main{
   public static void main(String[] args){
    //要通过接口实现类才能创建对象，从而调用接口中的方法
    //现在通过匿名内部类，省去接口实现类这以步骤，(前提是接口的实现类只需要使用唯一的一次，才能这样用)
    MyInterface obj = new MyInterface(){
       @Override
       public void method1(){
            System.out.println("匿名内部类实现方法！A");
        }
        @Override
       public void method2(){
            System.out.println("匿名内部类实现方法！B");
        }
    };
    obj.method1();//匿名内部类实现方法！A
    //下面演示一下，使用匿名对象的匿名内部类
    new MyInterface(){
      @Override
      public void method1(){
         System.out.println("匿名内部类实现方法！A");
      }
       @Override
      public void method2(){
         System.out.println("匿名内部类实现方法！B");
      }
   }.method1();
   //因为匿名对象无法调用第二次，所以要再创建一个匿名内部类的匿名对象
    new MyInterface(){
      @Override
      public void method1(){
         System.out.println("匿名内部类实现方法！A");
      }
       @Override
      public void method2(){
         System.out.println("匿名内部类实现方法！B");
      }
   }.method2();
   
   
}

Java中，类、接口都可以作为成员变量的类型的，也可以作为方法的参数。下面通过一个例子来演示：

//武器类
public class Weapon{
  private String code;//武器的代号
  public Weapon(){
  }
  public Weapon(String code){
    this.code=code;
  }
   public String getCode(){
      return code;
   }
   public void setCode(Code code){
      this.code=code;
   }   
}
//游戏当中的角色类
public class Hero{
   private String name;//英雄的名字
   private int age;//年龄
   private Weapon weapon;//武器

   public Hero(){
   }
   public Hero(String name,int age,Weapon weapon){
     this.name=name;
     this.age=age;
     this.weapon=weapon;
   }
   public void attack(){
     System.out.println(age+"岁的"+name+"正在用"+weapon+"攻击");
   }
   public String getName(){
      return name;
   }
   public void setName(String name){
      this.name=name;
   }
    public String getAge(){
      return age;
   }
   public void setAge(int age){
      this.age=age;
   }
    public String getWeapon(){
      return weapon;
   }
   public void setWeapon(Weapon weapon){
      this.weapon=weapon;
   }
}
//主程序
public class Demo03Main{
  public static void main(String[] args){
    //创建一个英雄角色
    Hero hero = new Hero();
    //为英雄起一个名字，并且设置年龄
    hero.setName("盖伦")；
    hero.setAge(20);
    //创建一个武器对象
    Weapon weapon = new Weapon("多兰剑");
    //为英雄配备武器
    hero.setWeapon(weapon);
    hero.attack();
  }
}

接口作为方法的参数或返回值：

import java.util.ArrayList;
import java.util.List;

//java.util.List 正是ArrayList所实现的接口

public class DemoInterface{
   public static void main(String[] age){
     //左边是接口名称，右边是实现类名称，这就是多态写法
     List<String> list = new ArrayList<>();
     List<String> result = addNames(list);
     for(int i=0;i<result.size();i++){
        System.out.println(result.get(i));
      }
   }
   public static List<String> addNames(List<String> list){
      list.add("迪丽热巴")；
      list.add("古力娜扎")；
      list.add("马儿扎哈")；
      list.add("赵丽颖")；
      return lsit;
   }
}

Java学习记录之内部类