java外部类与内部类的关系详解

 private，public，protected，default的访问权限区别

在学习外部类与内部类之前我们首先要弄明白private，public，protected，default在访问权限上有什么不同，这对我们之后的理解会有一定的帮助。

• 1、private：访问权限最低的访问控制符，被它修饰的变量只能访问本类的对象。
• 2、public：访问权限最高，不仅是本类，子类，本包，其他的包，都可以去访问它修饰的对象。
• 3、default：访问权限限制在本类以及本包内。
• 4、protected：访问的范围是本类，本包内，子类，但别的包不可以访问。

外部类访问内部类

在外部类的main方法中创建了外部类的对象，并通过它创建了内部类的对象，并调用了内部类的方法，这里我们观察调用时，age变量的变化。

public class people {	
	         private string name;
	         private int age=20;
	         private int id ;	     	     
	         public static void main(string[] args){
		    	 people p = new people();
		    	 people.student s = p.new student();
		    	 s.study();	    	 
	     }	    	
	    class student {
		    	private string name;
		    	private int age=18;
		    	private int studentnumber;
	    		public void study(){
		    		system.out.println("输出age"+age);
		    		system.out.println("内部类变量"+this.age);
		    		system.out.println("外部类变量"+people.this.age);			    		
	    	}	    	    	
	    }		
}

输出结果：

输出age18、内部类变量18、外部类变量20

经测试，我们可以发现内部类对象不能直接获得，只能由外部类的对象获取。并且我们通过输出结果，可以发现当外部类和内部类有相同属性时，在内部类中会优先输出内部类的属性，只有通过外部类的对象来调用age属性，才会在本例中输出20。在内部类中，使用this，可以获取内部类的属性。

局部内部类

这时候，我们转变一下思路，索性把student类的创建放在people类的方法里，再看看结果会怎么样。

public class people {	
	       private string name;
	       private int age=20;
	       private int id ;	          
	       public static void main(string[] args){
		       people p = new people();
		       class student {
			       private string name;
			       private int age=18;
			       private int studentnumber;	    	
		  	       public void study(){
		  	       system.out.println("输出age"+age);
		               system.out.println("内部类变量"+this.age);
		  	       system.out.println("外部类变量"+p.age);			    		
	    	   }	 
	        }
	        new student().study();
	    }
}

输出结构和之前是一样的，这也不奇怪，我们只是把类在方法里定义了，我们可以联想到局部变量的定义，只能在本方法中使用，那么，方法内的类自然也只是属于这个方法，访问权限只限于方法内。

静态嵌套类

既然开始了我们就不停下探索的脚步，我们把内部类变成静态类，我们可以理解为，这个内部类现在属于外部类了，外部类可以通过类名来调用这个类并创建对象，毫无疑问，结果是输出18。

public class people {
	     private string name;
	     private int age=20;
	     private int id ;	     	     
	     public static void main(string[] args){
		     people p = new people();	    	 
		     new people.student().study();	    	 
	     }	    	
	    static class student {
		    private string name;
		    private int age=18;
		    private int studentnumber;
	            public void study(){
			    system.out.println("输出age"+age);
			    system.out.println("内部类变量"+this.age);  			    		
	    	}	    	    	
	    }
}

匿名内部类

匿名内部类的实现涉及到了抽象类的实现，那么什么是抽象类呢？抽象类拥有一系列抽象的属性或者方法，它本身不能new对象，只有在它被继承并被重写所有抽象方法之后才能得到实现。我们这次要通过创建一个匿名内部类的对象来使得一个抽象的类得到实体化并执行一系列方法。首先我们需要创建一个抽象类，然后再写一个类创建匿名内部类的对象实现抽象类的方法（此处我们没有用到继承）。

abstract class people {	
	     private string name;
	     private int age=20;
	     private int id ;	     	     
	     public abstract void work();    
}
 public class test{	   	   
	     public static void main(string[] args){	    	  
		     test t = new test();
		      t.test(new people(){
		      public void work(){
		      system.out.println("我在工作");
	        	}
	         });
	      }	        
	       public void test(people people){
		         people.work();
		}			
}	

这段代码的关键部分在：

 t.test(new people(){
		      public void work(){
		      system.out.println("我在工作");
	        	}
	         });

似乎我们new了一个抽象类people的对象，但其实我们通过了匿名内部类来实现people类的实例化，它实现了work()抽象方法，然后调用此方法，输出“我在工作”。

以上所述是小编给大家介绍的java外部类与内部类的关系详解，希望对大家有所帮助。在此也非常感谢大家对网站的支持！