内部类

内部类

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类

什么时候使用内部类

一个事物内部还有一个独立的事物，内部的事物脱离外部的事物无法独立使用

1. 人里面有一颗心脏。
2. 汽车内部有一个发动机。
3. 为了实现更好的封装性。

内部类的分类

1. 静态内部类，类定义在了成员位置 (类中方法外称为成员位置，有static修饰的内部类)
2. 实例内部内，类定义在了成员位置 (类中方法外称为成员位置，无static修饰的内部类)
3. 局部内部类，类定义在方法内
4. 匿名内部类。一般定义在方法中，或者可执行代码中

1.静态内部类

静态内部类特点：有static修饰的内部类，属于外部类本身的。

• 总结：静态内部类与其他类的用法完全一样。只是访问的时候需要加上外部类.内部类。
• 拓展:静态内部类可以直接访问外部类的静态成员。

对象创建格式

外部类.内部类 变量 = new 外部类.内部类构造器;

实例

class Outer01{
     private static  String sc_name = "黑马程序";
  // 内部类: Inner01
  public static class Inner01{ 
       // 这里面的东西与类是完全一样的。 
       private String name;
      public Inner01(String name) {
          this.name = name; 
		 }
      
 public void showName(){ 
 	 System.out.println(this.name);
      // 拓展:静态内部类可以直接访问外部类的静态成员。 
      System.out.println(sc_name);
     }
  }
}  

测试类实现
public class InnerClassDemo01 {
    public static void main(String[] args) {
        // 创建静态内部类对象。
        // 外部类.内部类  变量 = new  外部类.内部类构造器;
       	 Outer01.Inner01 in  = new Outer01.Inner01("张三");       	in.showName();
    }
}

2.实例内部类

无static修饰的内部类，属于外部类对象的。

宿主：外部类对象。

拓展1：实例内部类不能定义静态成员。

拓展2：实例内部类可以直接访问外部类的私有和静态成员。

创建对象格式：

外部类.内部类 变量 = new 外部类构造器.new 内部类构造器;

实例

测试类实现

public class InnerClassDemo02 {
    public static void main(String[] args) {
        //  宿主：外部类对象。
        // Outer02 out = new Outer02();
        // 创建内部类对象。
  Outer02.Inner02 in = new Outer02().new Inner02("张三");        		in.showName();    
    }
}

class Outer02{
    // 实例内部类，属于外部类对象的。
    // 拓展：实例内部类不能定义静态成员。
    public class Inner02{
        // 这里面的东西与类是完全一样的。
        private String name;
        public Inner02(String name) {
            this.name = name;
        }
        public void showName(){
            System.out.println(this.name);
        }
    }
}

实例内部类面试题

public class Demo05 {
    public static void main(String[] args) {
        Body.Heart heart = new Body().new Heart();
        heart.jump();
    }
}
class Body {
    // 身体    private int weight = 30;
    // 在成员位置定义一个类
    class Heart {
        private int weight = 20;
        public void jump() 
        {
            int weight = 10;
            System.out.println("心脏在跳动 " + ?);   // 10            	  System.out.println("心脏在跳动 " + ?);   // 20            		System.out.println("心脏在跳动 " + ?);   // 30
        }
    }
}

3.局部内部类

定义在方法中的类

定义格式

class 外部类名 {

  数据类型 变量名; 

修饰符 返回值类型 方法名(参数列表) {

 // …   class 内部类 {

​ // 成员变量

		 // 成员方法

	 } 

​ }

}

4.匿名内部类

匿名内部类是内部类的简化写法。它的本质是一个带具体实现的 父类或者父接口的 匿名的 子类对象。 开发中， 常用到的内部类就是匿名内部类了

特点

1. 定义一个没有名字的内部类
2. 这个类实现了父类，或者父类接口
3. 匿名内部类会创建这个没有名字的类的对象

实例

interface Swim {
    public abstract void swimming();
}
public class Demo07 {
    public static void main(String[] args) {
        // 使用匿名内部类
        new Swim() {
            @Override
            public void swimming() {
                System.out.println("自由泳...");
            }
        }.swimming();
        // 接口 变量 = new 实现类();
        // 多态,走子类的重写方法
        Swim s2 = new Swim() {
            @Override
            public void swimming() {
                System.out.println("蛙泳...");
            }
        };
        s2.swimming();
        s2.swimming();
    }
}

​

匿名内部类的使用场景

通常在方法的形式参数是接口或者抽象类时，也可以将匿名内部类作为参数传递。代码如下：

interface Swim {
    public abstract void swimming();
}
public class Demo07 {
    public static void main(String[] args) {
        // 普通方式传入对象
        // 创建实现类对象
        Student s = new Student();
        goSwimming(s);
        // 匿名内部类使用场景:作为方法参数传递
        Swim s3 = new Swim() {
            @Override
            public void swimming() {
                System.out.println("蝶泳...");
            }
        };
        // 传入匿名内部类
        goSwimming(s3);
        // 完美方案: 一步到位
        goSwimming(new Swim() {
            public void swimming() {
                System.out.println("大学生, 蛙泳...");
            }
        });
        goSwimming(new Swim() {
            public void swimming() {
                System.out.println("小学生, 自由泳...");
            }
        });
    }  
    // 定义一个方法,模拟请一些人去游泳
    public static void goSwimming(Swim s) {
        s.swimming();
    }
}