Java021——内部类

朱雀 2024-05-05 22:18 30阅读 0赞

## 一、成员内部类 ##

类中的东西都是成员，  
![在这里插入图片描述][adc91ef384494317a7fd3d81b3cf5e68.png]

### 1.1、成员内部类定义 ###

定义成员内部类的格式：

class OuterClass {
        //外部类
    	class InnerClass{
        //内部类（内部类实际是外部类的一个属性）
    	
    	}
    }

示例

public class Outer {
        
    
        private static int radius = 1;
        private int count =2;
    
        class Inner {
        
            public void visit() {
        
                System.out.println("visit outer static variable:" + radius);
                System.out.println("visit outer variable:" + count);
            }
        }
    
        public static void main(String[] args) {
        
            Outer outer =new Outer();
            Outer.Inner inner = outer.new Inner();
    
            inner.visit();
        }
    }
    
    //输出
    visit outer static variable:1
    visit outer variable:2

编译上述代码会产生两个class文件：Outer.class和Outer$Inner.class。

> 创建内部类对象的格式：  
> 外部类 outer = new 外部类();  
> 外部类.内部类 inner = outer.new 内部类();

### 1.2、使用 this 关键字获取内部类与外部类的引用 ###

如果在外部类中定义的成员变量与内部类的成员变量名称相同，可以使用 this 关键字。

public class TheSameName {
        
    	private int x = 7; // 外部类的x
    
    	private class Inner {
        
    		private int x = 9;// 内部类的x
    
    		public void doit() {
        
    			int x = 11; // 局部变量x
    			this.x++; // 调用内部类的x
    			TheSameName.this.x++; // 调用外部类的x
    		}
    	}
    }

## 二、匿名内部类 ##

匿名内部类就是没有名字的内部类

### 2.1、继承式的匿名内部类 ###

public class Car {
        
        public void drive(){
        
            System.out.println("Driving a car!");
        }
        
        public static void main(String[] args) {
        
            Car car = new Car(){
        
                public void drive() {
        
                    System.out.println("Driving another car!");
                }
            };
            car.drive();
        }
    }
    
    //输出
    Driving another car!

*  匿名内部类不能有构造方法。
 *  匿名内部类不能定义任何静态成员、静态方法。
 *  匿名内部类不能是public,protected,private,static。
 *  只能创建匿名内部类的一个实例。
 *  一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
 *  因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。

### 2.2、接口式的匿名内部类 ###

interface Vehicle {
        
        public void drive();
    }
    
    class Test{
        
        public static void main(String[] args) {
        
            Vehicle v = new Vehicle(){
        
                public void drive(){
        
                    System.out.println("Driving a car!");
                }
            };
            v.drive();
        }
    }
    
    //输出
    Driving a car!

### 2.3、参数式的匿名内部类 ###

class Bar{
        
        void doStuff(Foo f){
        
            f.foo();
        }
    }
    
    interface Foo{
        
        void foo();
    }
    
    class Test{
        
        static void go(){
        
            Bar b = new Bar();
            b.doStuff(new Foo(){
        
                public void foo(){
        
                    System.out.println("foofy");
                }
            });
        }
    }

### 2.4、抽象式的匿名内部类 ###

abstract class Dog {
        
    	String Color;
    
    	public abstract void move();
    
    	public abstract void call();
    }
    
    public class Demo {
        
    	public static void main(String args[]) {
        
    		Dog maomao = new Dog() {
        
    			public void move() {
        
    				System.out.println("四腿狂奔");
    			}
    
    			public void call() {
        
    				System.out.println("嗷呜~");
    			}
    		};
    		maomao.Color = "灰色";
    		maomao.move();
    		maomao.call();
    	}
    }

## 三、方法内部类 ##

把类放在方法内

class Outer {
        
        public void doSomething(){
        
            final int a =10;
            class Inner{
        
                public void seeOuter(){
        
                    System.out.println(a);//只能使用该内部类所在方法的final局部变量
                }
            }
            Inner in = new Inner();//方法内部类只能在定义该内部类的方法内实例化
            in.seeOuter();
        }
        public static void main(String[] args) {
        
            Outer out = new Outer();
            out.doSomething();
        }
    }
    
    //输出
    10

(1)、方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。  
(2)、方法内部类对象不能使用该内部类所在方法的非final局部变量。

## 四、静态内部类 ##

class Outer {
        
        private static int radius = 1;
    
        static class StaticInner {
        
            public void visit() {
        
                System.out.println("visit outer static variable:" + radius);
            }
        }
        
         public static void main(String[] args){
        
             Outer.StaticInner inner = new Outer.StaticInner();
             inner.visit();
         }
    }
    
    //输出
    visit outer static variable:1

静态内部类可以访问外部类所有的静态变量，而不可访问外部类的非静态变量；

> 静态内部类的创建方式：  
> 外部类.静态内部类 内部类名 = new 外部类.静态内部类()，  
> 如下： Outer.StaticInner inner = new Outer.StaticInner();

## 五、为什么需要内部类 ##

内部类（Inner Class）是指在一个类的内部定义的另一个类。在Java中，内部类可以嵌套在其他类中，在外部类的成员变量和方法中，可以直接访问内部类的成员，包括私有成员。以下是使用内部类的几个常见的理由：

1.  封装和隐藏：内部类可以将类隐藏在其他类的内部，只对外部类可见。这可以实现更好的封装性和模块化，隐藏内部类的实现细节，仅暴露必要的接口。
2.  访问外部类的成员：内部类可以直接访问外部类的成员，包括私有成员。这有助于实现更紧密的类之间的关系，方便数据共享和操作。
3.  实现多重继承：内部类可以在不引入多重继承的情况下实现多个接口，提供更灵活的设计选择。一个类可以实现多个接口，并且每个接口都可以有其自己的内部类，从而实现多重功能的组合。
4.  回调和事件处理：内部类常常用于实现回调和事件处理机制。例如，一个窗口类可以定义一个内部类来处理按钮的点击事件，内部类可以直接访问外部类的成员和方法，方便事件处理。
5.  代码组织和逻辑清晰：内部类可以将相关的类组织在一起，使代码更具可读性和可维护性。当内部类与外部类之间具有紧密的关系时，使用内部类可以提高代码的可读性，并且逻辑更清晰。

需要注意的是，内部类并不是必需的，很多情况下都可以通过其他方式来达到相同的效果。内部类的使用应该根据具体的需求和情况来决定，合理地使用内部类可以带来更灵活、更清晰的代码结构。

## 与君共享 ##

?????最后，有兴趣的小伙伴可以点击下面链接，这里有我整理的完整Java学习博客内容，谢谢~ ?????

[《Java基础专栏完整学习》][Java]

[adc91ef384494317a7fd3d81b3cf5e68.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/e9146043cba341cdbf4a8543f33cdd09.png
[Java]: https://blog.csdn.net/weixin_45084986/category_11588062.html