【java基础】Java中的内部类

我会带着你远行 2022-08-23 09:54 143阅读 0赞

# 内部类： #

在一个类里面包含另外一个类.外边的类就是外部类，被包含在里边的就是内部类.

# 作用： #

1.  内部类提供了更好的封装，将内部类隐藏在外部类中.不允许同一个包中的其他类访问.
2.  内部类的方法可访问外部类的所有成员变量(包含private的).
3.  若内部类为static，则只能访问外部类的静态成员变量.若访问非static成员变量，则会报如下错误：
4.  Error： Cannot make a static reference to the non-static field javaClass.name

# 分类： #

*  成员内部类
 *  静态内部类
 *  方法内部类
 *  匿名内部类

## 成员内部类： ##

也称之为“普通内部类”.先通过一段代码来进入正题：

public class memberClass {
        //外部类的私有属性name
        private String nametest = "成员内部类";
        private String name = "caicai";
        
        //外部类的成员属性
        int age = 20;
        
    	//成员内部类Inner
    	public class Inner {
    		String name = "rabbit";
            //内部类中的方法
    		public void show() { 
    			System.out.println("外部类中的nametest：" + nametest);
    			System.out.println("外部类中的name：" + memberClass.this.name);
    			System.out.println("内部类中的name：" +  name );
    			System.out.println("外部类中的age：" + memberClass.this.age);
    		}
    	}  
    	//测试成员内部类
    	public static void main(String[] args) {      
            //创建外部类的对象
    		memberClass o = new memberClass (); 
            //创建内部类的对象
    		Inner inn = o.new Inner()  ;        
            //调用内部类对象的show方法
    		inn.show();
    	}
    }

执行结果:

外部类中的nametest：成员内部类
    外部类中的name：caicai
    内部类中的name：rabbit
    外部类中的age：20

总结：

*  成员内部类中的方法，可直接访问外部类的私有属性，如（nametest）.
 *  外部类和内部类若存在相同的成员变量或方法，内部类会默认访问自己的;若想访问外部类的，则需要：外部类.this.成员变量.这种形式访问.
 *  外部类不能直接访问内部类的方法和成员变量，须创建内部类对象，通过对象访问.
 *  须通过外部类对象去创建内部类对象.如：Inner inn= o.new Inner();

## 静态内部类： ##

//外部类
    public class javaClass {
    	// 外部类中的静态变量score
    	private static int score = 84;
    	static int testscore=1;
    	// 创建静态内部类
    	public static class SInner {
    		// 内部类中的变量score
    		int score = 91;
    
    		public void show() {
    			System.out.println("外部类中的score：" + javaClass.score);
    			System.out.println("外部类中的testscore：" + testscore);
    			System.out.println("内部类中的score：" + score);
    		}
    	}
    	// 测试静态内部类
    	public static void main(String[] args) {
    		// 直接创建内部类的对象
    		SInner si = new SInner();
    		// 调用show方法
    		si.show();
    	}
    }

结果：

外部类中的score：84
    外部类中的testscore：1
    内部类中的score：91

## 特点：   1.若外部类的静态成员和内部类的成员名称相同，可通过"类名.静态成员"访问外部类的静态成员；若外部类的静态成员与内部类的成员名称不同，可通过"成员名"直接调用外部类的静态成员.   2.创建静态内部类的对象时，可直接创建 内部类 对象名= new 内部类(). ##

## 方法内部类: ##

定义在外部类的方法中.只在方法内部可见.

public class functionClass {
    	private String name = "caicai";
    
    	// 外部类中的show方法
    	public void show() {
    		// 定义方法内部类
    		class MInner {
    			int score = 83;
    
    			public int getScore() {
    				return score + 10;
    			}
    		}
    		// 创建方法内部类的对象
    		MInner mi = new MInner();
    		// 调用内部类的方法
    		int newScore = mi.getScore();
    
    		System.out.println("姓名：" + name + "\n加分后的成绩：" + newScore);
    	}
    
    	// 测试静态内部类
    	public static void main(String[] args) {
    		// 创建外部类的对象
    		functionClass mo = new functionClass();
    		// 调用外部类的方法
    		mo.show();
    	}
    }

结果：

姓名：caicai
    加分后的成绩：93

特点：

*  方法内部类因只能在方法内部使用，so不能使用任何访问控制符和static修饰

代码编译完成之后，会产生如下文件：

![Center][]

其中第一个是内部类的class文件.第二个是外部类的class文件.成员内部类的class文件命名：外部类名$内部类名.class

[Center]: /images/20220721/969ed97616e64e82a6c5868d4daef8fc.png