Java基础---内部类

最新推荐文章于 2021-11-06 13:17:40 发布
最新推荐文章于 2021-11-06 13:17:40 发布
阅读量91 收藏 1
点赞数 1
分类专栏： Java 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/airar/article/details/121169252
版权

1.内部类

内部类---包含在类中的类

外部类---包含内部类之外的类就是外部类

1.成员内部类---相当于java类中的成员变量

基本结构：

 package com.object.test1;

public class TestClass {
            public class InClass{

          }

}

TestClass---外部类

InClass---成员内部类

内部类编译后会形成一个新的字节码文件【外部类类名$内部类类名.class】

 1.成员内部类可以使用任意的访问限制修饰符

package com.object.test1;

public class TestClass {
            public class InClass{
            	//public访问限制修饰符定义的变量
            	public String name="zhangsan"; 
            	//缺省的访问限制修饰符定义的变量
            	int age=23;
            	//受保护的访问限制修饰符定义的变量
            	protected String address="西安";
            	//私有的的访问限制修饰符定义的变量
            	private int id=1001;
            }
}

2.成员内部类可以有实例变量、实例方法、构造方法，不能有静态元素。

package com.object.test1;

public class TestClass {
            public class InClass{
            	//成员内部类可以有实例变量、实例方法、构造方法，不能有静态元素。
            	//实例变量
            	public int id=1001;
            	//成员内部类不能有静态变量
            	//public static String name="zhangsan"; //报错
            	
            	//构造方法
            	public InClass(){
            		System.out.println("InClass成员内部类构造方法");
            	}
            	//实例方法
            	public void testMethod(){
            		System.out.println("InClass成员内部类实例方法");
            	}
            	//静态方法
            	//成员内部类不能有静态方法
            	//public static staticMethod(){}   //报错
            	}
}

3.成员内部类中的构造方法可以访问其他的构造方法【new】，

    可以访问实例变量/方法:【对象.实例变量/方法    ,this.实例变量/方法,可以省略对象/this】

package com.object.test1;

public class TestClass {
            public class InClass{
            	//成员内部类可以有实例变量、实例方法、构造方法，不能有静态元素。
            	//实例变量
            	public int id=1001;
            	//成员内部类不能有静态变量
            	//public static String name="zhangsan"; //报错
            	
            	//构造方法
            	//InClass成员内部类无参数构造方法
            	public InClass(){
            		System.out.println("InClass成员内部类无参数构造方法");
            	}
            	//InClass成员内部类有参数构造方法
            	public InClass(String name){
            		//成员内部类中的构造方法可以访问其他的构造方法【new】
            		//可以访问实例变量/方法【对象.实例变量/方法	,this.实例变量/方法,可以省略对象/this】
            		new InClass(); //内部类对象
            		new InClass().id=1002;
            		this.id=1003;
            		id=1004;
            		
            		new InClass().testMethod();
            		this.testMethod();
            		testMethod();
            		System.out.println("InClass成员内部类有参数构造方法");
            	}

            	//实例方法
            	//InClass成员内部类testMethod实例方法
            	public void testMethod(){
            		
            		
            	}
            	//InClass成员内部类testMethod2实例方法
            	public void testMethod2(){
            		
            	}
            	
}

4.成员内部类中的实例方法可以访问构造方法【new】

    可以访问实例变量/方法:【对象.实例变量/方法,this.实例变量/方法,可以省略对象/this】

package com.object.test1;

public class TestClass {
            public class InClass{
            	//成员内部类可以有实例变量、实例方法、构造方法，不能有静态元素。
            	//实例变量
            	public int id=1001;
            	//成员内部类不能有静态变量
            	//public static String name="zhangsan"; //报错
            	
            	//构造方法
            	//InClass成员内部类无参数构造方法
            	public InClass(){
            		System.out.println("InClass成员内部类无参数构造方法");
            	}
            	//InClass成员内部类有参数构造方法
            	public InClass(String name){
            		//成员内部类中的构造方法可以访问其他的构造方法【new】
            		//可以访问实例变量/方法【对象.实例变量/方法	,this.实例变量/方法,可以省略对象/this】
            		new InClass(); //内部类对象
            		new InClass().id=1002;
            		this.id=1003;
            		id=1004;
            		
            		new InClass().testMethod();
            		this.testMethod();
            		testMethod();
            		System.out.println("InClass成员内部类有参数构造方法");
            	}
            	//实例方法
            	//InClass成员内部类testMethod实例方法
            	public void testMethod(){
            		//成员内部类中的实例方法可以访问构造方法【new】
            		//可以访问实例变量/方法【对象.实例变量/方法,this.实例变量/方法,可以省略对象/this】
            		new InClass(); //内部类对象
            		new InClass().id=1002;
            		this.id=1003;
            		id=1004;
            		
            		new InClass().testMethod2();
            		this.testMethod2();
            		testMethod2();
            		System.out.println("InClass成员内部类testMethod实例方法");
            	}
            	//InClass成员内部类testMethod2实例方法
            	public void testMethod2(){
            		System.out.println("InClass成员内部类testMethod2实例方法");
            	}
            	
}

5.成员内部类中的构造方法/实例方法可以访问外部类的构造方法，实例方法/变量，类方法/变量。

package com.object.test1;

public class TestClass {
	       //实例变量
	        public int age=23;
	        //静态成员变量
	        public static String name="lisi";
	        //构造方法
	        public TestClass(){
	        	System.out.println("TestClass无参数构造方法");
	        }
	        //实例方法
	        public void shiliMethod(){
	        	System.out.println("TestClass无参数实例方法");
	        }
	        //静态方法
	        public static void staticMethod(){
	        	System.out.println("TestClass无参数实例方法");
	        }
            public class InClass{
            	//成员内部类可以有实例变量、实例方法、构造方法，不能有静态元素。
            	//实例变量
            	public int id=1001;
            	//成员内部类不能有静态变量
            	//public static String name="zhangsan"; //报错
            	
            	//构造方法
            	//InClass成员内部类无参数构造方法
            	public InClass(){
            		System.out.println("InClass成员内部类无参数构造方法");
            	}
            	//InClass成员内部类有参数构造方法
            	public InClass(String name){
            		//成员内部类中的构造方法可以访问其他的构造方法【new】
            		
            		new InClass(); //内部类对象
            		new InClass().id=1002;
            		this.id=1003;
            		id=1004;
            		new InClass().testMethod();
            		this.testMethod();
            		testMethod();
            		//访问外部变量和方法
            		//成员内部类中的构造方法可以访问实例变量/方法【对象.实例变量/方法	,this.实例变量/方法,可以省略对象/this】
            		new TestClass();
            		//访问外部类实例变量
            		new TestClass().age=25;
            		 TestClass.this.age=27;
            		 age=29;
            		//访问外部类静态变量
            		new TestClass().name="wangwu";
            		 TestClass.this.name="zhaowu";
            		 name="zhubajie";
            		 //访问外部类实例方法
            		new TestClass().shiliMethod();
            		TestClass.this.shiliMethod();
            		shiliMethod();
            		//访问外部类静态方法
            		new TestClass().staticMethod();
            		TestClass.this.staticMethod();
            		staticMethod();
            		System.out.println("InClass成员内部类有参数构造方法");
            	}
            	//实例方法
            	//InClass成员内部类testMethod实例方法
            	public void testMethod(){
            		//成员内部类中的实例方法可以访问构造方法【new】
            		//可以访问实例变量/方法【对象.实例变量/方法,this.实例变量/方法,可以省略对象/this】
            		new InClass(); //内部类对象
            		new InClass().id=1002;
            		this.id=1003;
            		id=1004;
            		new InClass().testMethod2();
            		this.testMethod2();
            		testMethod2();
            		//访问外部变量和方法
            		//成员内部类中的实例方法可以访问实例变量/方法【对象.实例变量/方法	,this.实例变量/方法,可以省略对象/this】
            		new TestClass();
            		//访问外部类实例变量
            		new TestClass().age=25;
            		 TestClass.this.age=27;
            		 age=29;
            		//访问外部类静态变量
            		new TestClass().name="wangwu";
            		 TestClass.this.name="zhaowu";
            		 name="zhubajie";
            		 //访问外部类实例方法
            		new TestClass().shiliMethod();
            		TestClass.this.shiliMethod();
            		shiliMethod();
            		//访问外部类静态方法
            		new TestClass().staticMethod();
            		TestClass.this.staticMethod();
            		staticMethod();
            		System.out.println("InClass成员内部类testMethod实例方法");
            	}
            	//InClass成员内部类testMethod2实例方法
            	public void testMethod2(){
            		System.out.println("InClass成员内部类testMethod2实例方法");
            	}
            	//静态方法
            	//成员内部类不能有静态方法
            	//public static staticMethod(){}   //报错
            	}
}

6.外部类中的构造方法/实例法可以访问成员内部类的构造方法，实例方法/变量，外部类中的

类方法不能访问成员内部类。【只能对象访问，不能省略对象，也不可以this访问】

package com.object.test1;

public class TestClass {
	       //实例变量
	        public int age=23;
	        //静态成员变量
	        public static String name="lisi";
	        //构造方法
	        public TestClass(){
	        	//访问内部类中的变量和方法
	        	new InClass(); //内部类对象
        		new InClass().id=1002;
        		//this.id=1003;
        		//id=1004;
        		new InClass().testMethod();
        		//this.testMethod();
        		//testMethod();
	        	System.out.println("TestClass无参数构造方法");
	        }
	        //实例方法
	        public void shiliMethod(){
	        	new InClass(); //内部类对象
        		new InClass().id=1002;
        		//this.id=1003;
        	     //id=1004;
        		new InClass().testMethod();
        		//this.testMethod();
        		//testMethod();
	        	System.out.println("TestClass无参数实例方法");
	        }
	        //静态方法
	        public static void staticMethod(){
	        	//new InClass(); //内部类对象
        		//new InClass().id=1002;
        		//this.id=1003;
        		//id=1004;
        		//new InClass().testMethod();
        		//this.testMethod();
        		//testMethod();
	        	System.out.println("TestClass无参数实例方法");
	        }
            public class InClass{
            	//成员内部类可以有实例变量、实例方法、构造方法，不能有静态元素。
            	//实例变量
            	public int id=1001;
            	//成员内部类不能有静态变量
            	//public static String name="zhangsan"; //报错
            	
            	//构造方法
            	//InClass成员内部类无参数构造方法
            	public InClass(){
            		System.out.println("InClass成员内部类无参数构造方法");
            	}
            	//InClass成员内部类有参数构造方法
            	public InClass(String name){
            		
            	}
            	//实例方法
            	//InClass成员内部类testMethod实例方法
            	public void testMethod(){
            		;
            		System.out.println("InClass成员内部类testMethod实例方法");
            	}
            	//InClass成员内部类testMethod2实例方法
            	public void testMethod2(){
            		System.out.println("InClass成员内部类testMethod2实例方法");
            	}
            	}
}

7.其他类中是可以访问成员内部类的，需要依赖外部类对象，注意访问限制修饰符。

package com.object.test1;

public class OtherClass {
	   //构造方法
        public  OtherClass(){
        	TestClass tcl=new TestClass();
        	TestClass.InClass inc1=tcl.new InClass();
        	TestClass.InClass inc2=new TestClass().new InClass();
        	inc1.id=1004;
        	inc2.id=1005;
        	inc1.testMethod();
        	inc2.testMethod();
        	
        }
        //实例方法
        public void  shiliOtherClass(){
        	TestClass tcl=new TestClass();
        	TestClass.InClass inc1=tcl.new InClass();
        	TestClass.InClass inc2=new TestClass().new InClass();
        	inc1.id=1004;
        	inc2.id=1005;
        	inc1.testMethod();
        	inc2.testMethod();
        }
        //静态方法
        public static void staticOtherClass(){
        	TestClass tcl=new TestClass();
        	TestClass.InClass inc1=tcl.new InClass();
        	TestClass.InClass inc2=new TestClass().new InClass();
        	inc1.id=1004;
        	inc2.id=1005;
        	inc1.testMethod();
        	inc2.testMethod();
        }
}

 2.方法内部类--定义在方法中的类，相当于局部变量

      1.基本格式：

package com.object.test2;

public class TestClass {
	//构造方法中的方法内部类
	public TestClass(){
		class InTestClass1{
			
		  }
	 }
		//实例方法中的方法内部类
		public void testMethod(){
			class InTestClass2{
				
			}
		}
		//静态方法中的方法内部类
		public static void staticMethod(){
			class InTestClass3{
				
			}
		}
}

1.方法内部类不能使用任何访问限制修饰符。

2.方法内部类可以有实例变量/方法，构造方法，不能有静态元素。

3.方法内部类的构造方法/实例方法可以访问本方法内部类中的构造方法，实例方法/变量【对象/this，也可以省略】。

4.方法内部类中的构造方法/实例方法中可以访问本方法的局部变量，默认会使用final修饰局部变量【直接变量名称】。

5.方法内部类可以访问外部类的构造方法，实例方法/变量，类方法/变量。

6.外部类不能访问方法内部类。

package com.object.test2;

public class TestClass {
	//方法内部类可以访问外部类的构造方法，实例方法/变量，类方法/变量。
	//实例变量
	public int num=23;
	//静态成员变量
	public String nam="wangwu";
	
	//构造方法
	public TestClass(){}
	//实例方法
	public void testshiliClass(){}
	//静态方法
	public static void staticMethod(){}
	
		//实例方法中的方法内部类
		public void testMethod(){
			class InTestClass2{
				//方法内部类可以有实例变量
				public int id=1001;
				//方法内部类不能有静态元素
				//public static String name="zhangsan";
				//方法内部类可以有实例方法，构造方法，
				public InTestClass2(){}
				public InTestClass2(int age){
					//方法内部类的构造方法中可以访问本方法内部类中的构造方法
					new InTestClass2();
					//方法内部类的构造方法中可以访问本方法内部类中实例方法/变量【对象/this，也可以省略】
					new InTestClass2().shiliMethod1();
					this.shiliMethod1();
					shiliMethod1();
					new InTestClass2().id=1002;
					//方法内部类可以访问外部类的构造方法，实例方法/变量，类方法/变量。
					new TestClass();
					new TestClass().nam="lilu";
					TestClass.this.nam="wangwu";
					nam="liuqian";
					
					new TestClass().num=27;
					TestClass.this.num=32;
					num=30;
					
					new TestClass().staticMethod();
					TestClass.this.staticMethod();
					staticMethod();
					
					new TestClass(). testshiliClass();
					TestClass.this.testshiliClass();
					testshiliClass();
					}
				public void shiliMethod1(){}
				public void shiliMethod2(){
					//方法内部类的构造方法中可以访问本方法内部类中的构造方法
					new InTestClass2();
					//方法内部类的构造方法中可以访问本方法内部类中实例方法/变量【对象/this，也可以省略】
					new InTestClass2().shiliMethod1();
					this.shiliMethod1();
					shiliMethod1();
					new InTestClass2().id=1002;
					
					new TestClass();
					new TestClass().nam="lilulu";
					new TestClass().num=29;
					new TestClass().staticMethod();
					new TestClass(). testshiliClass();
					//方法内部类不能有静态方法
					//public static void Instatic(){}
				}
				
			  }

			}
		
}

3.静态嵌套类--相当于是java类中的静态变量

基本格式：

package com.object.test3;

public class TestClass {
	      //静态嵌套类
           public static class InClass{
        	  
           }
}

1.静态嵌套类中可以有构造方法，实例变量/方法，类变量/方法。

2.静态嵌套类中构造方法/实例方法可以访问本静态嵌套类中的构造方法，实例变量/方法，类变量/方法。

3.静态内部类中类方法可以访问本静态嵌套类中的构造方法，实例变量/方法【只能对象】，类变量/方法.

4.静态内部类中的构造方法/实例方法/类方法可以访问外部类的构造方法，实例变量/方法【只能对象】，类变量/方法。

5.静态嵌套类中不能有this.

6.外部类的构造方法/实例方法/类方法可以访问，静态内部类中构造方法，实例变量/方法【只能对象】，类变量/方法.

7.其他类中可以访问静态嵌套类【new 外部类类名.静态嵌套类名()】。注意访问限制修饰符

package com.object.test3;

public class TestClass {
	   //实例变量
	    public String nam="zhangsan";
	    //静态成员变量
	    public static int  num=112;
	    //构造方法
	     public TestClass(){
	     new  InClass();
   		  new  InClass().id=1002;
   		  //this.id=1003;
   		  //id=1004;
   		  
   		  new  InClass().age=25;
   		 // this.age=26;
   		  //age=28;
   		  
   		  new  InClass().shiliMethod1();
   		  //this.shiliMethod1();
   		 //shiliMethod1();
   		  
   		  new  InClass().staticMethod();
   		 InClass.staticMethod();
   		 // this.staticMethod();
   		  //staticMethod();
	     }
	     //实例方法
	     public void testClassMethod(){
	    	  new  InClass();
	   		  new  InClass().id=1002;
	   		  //this.id=1003;
	   		  //id=1004;
	   		  
	   		  new  InClass().age=25;
	   		 // this.age=26;
	   		  //age=28;
	   		  
	   		  new  InClass().shiliMethod1();
	   		  //this.shiliMethod1();
	   		 //shiliMethod1();
	   		  
	   		  new  InClass().staticMethod();
	   		 InClass.staticMethod();
	   		 // this.staticMethod();
	   		  //staticMethod();
		     }
	     
	     //静态方法
	     public static void testClassStatic(){
	    	 new  InClass();
	   		  new  InClass().id=1002;
	   		  //this.id=1003;
	   		  //id=1004;
	   		  
	   		  new  InClass().age=25;
	   		 // this.age=26;
	   		  //age=28;
	   		  
	   		  new  InClass().shiliMethod1();
	   		  //this.shiliMethod1();
	   		 //shiliMethod1();
	   		  
	   		  new  InClass().staticMethod();
	   		 InClass.staticMethod();
	   		 // this.staticMethod();
	   		 //staticMethod();
	     }
	      //静态嵌套类
           public static class InClass{
        	   //静态嵌套类中可以有构造方法，实例变量/方法，类变量/方法。
        	   public int age=23;
        	   public static int id=1001;
        	  public InClass(){}
        	  public InClass(String name){
        		  //静态嵌套类中构造方法可以访问本静态嵌套类中的构造方法，实例变量/方法，类变量/方法。
        		  new  InClass();
        		  new  InClass().id=1002;
        		  this.id=1003;
        		  id=1004;
        		  new  InClass().age=25;
        		  this.age=26;
        		  age=28;
        		  new  InClass().shiliMethod1();
        		  this.shiliMethod1();
        		  shiliMethod1();
        		  new  InClass().staticMethod();
        		  this.staticMethod();
        		  staticMethod();
        		  
        		  new TestClass();
          		 new TestClass().nam="wahaha";
          		 //this.nam="zhaoxi";//报错
          		 //nam="zhaoliu";
          		 //TestClas.this.nam="zhaoxi";//报错
          		 new TestClass().num=234;
          		TestClass.num=244;
          		 //this.num=245;//报错
          		 //TestClass.this.num=247;//报错
          		 num=211;
          		 
          		 new TestClass().testClassMethod();
          		 //TestClass.this.testClassMethod();
          		 //testClassMethod();
          		 new TestClass().testClassStatic();
          		TestClass.testClassStatic();
          		 //TestClass.this.testClassStatic();
          		 //this.testClassStatic();
          		 testClassStatic();
        		 
        		  
        	  }
        	  
        	  //实例方法
        	  public void shiliMethod1(){}
        	  public void shiliMethod2(){
        		  //静态嵌套类中实例方法可以访问本静态嵌套类中的构造方法，实例变量/方法，类变量/方法。
        		  new  InClass();
        		  new  InClass().id=1002;
        		  this.id=1003;
        		  id=1004;
        		  
        		  new  InClass().age=25;
        		  this.age=26;
        		  age=28;
        		  new  InClass().shiliMethod1();
        		  this.shiliMethod1();
        		  shiliMethod1();
        		  new  InClass().staticMethod();
        		  this.staticMethod();
        		  staticMethod();
        		  
        		  new TestClass();
          		 new TestClass().nam="wahaha";
          		 //this.nam="zhaoxi";//报错
          		 //nam="zhaoliu";
          		 //TestClas.this.nam="zhaoxi";//报错
          		 new TestClass().num=234;
          		TestClass.num=244;
          		 //this.num=245;//报错
          		 //TestClass.this.num=247;//报错
          		 num=211;
          		 
          		 new TestClass().testClassMethod();
          		 //TestClass.this.testClassMethod();
          		 //testClassMethod();
          		 new TestClass().testClassStatic();
          		TestClass.testClassStatic();
          		 //TestClass.this.testClassStatic();
          		 //this.testClassStatic();
          		 testClassStatic();
        	  }
        	  
        	  //静态方法
        	  public static void staticMethod(){}
        	  public static void staticMethod2(){
        		  //静态内部类中类方法可以访问本静态嵌套类中的构造方法，实例变量/方法【只能对象】，类变量/方法.
        		  new  InClass();
        		  new  InClass().id=1002;
        		  //this.id=1003;
        		  id=1004;
        		  new  InClass().age=25;
        		  //this.age=26;
        		  //age=28;
        		  new  InClass().shiliMethod1();
        		  //this.shiliMethod1();
        		  //shiliMethod1();
        		  new InClass().staticMethod();
        		  //this.staticMethod();
        		  staticMethod();
        		  
        		 new TestClass();
         		 new TestClass().nam="wahaha";
         		 //this.nam="zhaoxi";//报错
         		 //nam="zhaoliu";
         		 //TestClas.this.nam="zhaoxi";//报错
         		 new TestClass().num=234;
         		TestClass.num=244;
         		 //this.num=245;//报错
         		 //TestClass.this.num=247;//报错
         		 num=211;
         		 
         		 new TestClass().testClassMethod();
         		 //TestClass.this.testClassMethod();
         		 //testClassMethod();
         		 new TestClass().testClassStatic();
         		TestClass.testClassStatic();
         		 //TestClass.this.testClassStatic();
         		 //this.testClassStatic();
         		 testClassStatic();
        	  }
           }
}

package com.object.test3;

public class OtherClass {
	public void otherMethod(){
		//其他类中可以访问静态嵌套类【new 外部类类名.静态嵌套类名()】。注意访问限制修饰符
		TestClass. InClass into =new TestClass. InClass();
           new TestClass. InClass().age=12;
           into.id=1005;
           into.shiliMethod1();
           into.staticMethod();
           
           
	}
}

4.匿名内部类

      1.没有名字的java类，再不用创建新类的情况下，构建出当前类的子类，构建的子类

没有名称，所以叫匿名内部类

     2.基本格式：

package com.object.test4;

public class Person {
       public void personIn(){
    	   System.out.println("Person类的实例方法");
       }
}

package com.object.test4;

public class TestMain {
	public static void main(String[] args) {
		Person per=new Person(){
			public void personIn(){
		    	   System.out.println("重写Person类的实例方法");
		       }
		};
		per.personIn();
	}
}

new Person(){
			public void personIn(){
		    	   System.out.println("重写Person类的实例方法");
		       }
		};

上面的代码就是一个匿名内部类的格式，就相当于Person类的子类，只是没有名字，所以叫匿名内部类。

 3.继承式的匿名内部类

例如：

package com.wangxing.test5;

public abstract class Person {
	public abstract void  perinfo();
}

package com.wangxing.test5;

public class TestClass {
	public   void  testClassShili(Person  person){
		person.perinfo();
	}
}

package com.object.test5;

public class TestMain {
	public static void main(String[] args) {
		TestClass tcl=new TestClass();
		tcl.testClassMethod(new Person(){
			@Override
			public void personIn() {
				System.out.println("重写后的抽象类方法");
				
			}
		});
	}

}

4.接口式的匿名内部类

例如：

package com.object.test6;

public  interface Person {
        void interfaceperson();
}

package com.object.test6;

public class TestClass {
    public void testClassMethod(Person person){
    	person.interfaceperson();
    }
}
package com.object.test6;

public class TestMain {
	public static void main(String[] args) {
		//当一个方法的参数是接口类型的时候，可以传递接口回调对象/当前接口的子类
		//无论是接口回调对象/当前接口的子类，都要创建子类
		//匿名内部类，可以在不需要创建子类的情况下，完成参数传递
		TestClass tcl=new TestClass();
		tcl.testClassMethod(new Person(){
			@Override
			public void interfaceperson() {
				System.out.println("重写后的抽象类方法");
				
			}
		});
	}

}

优点：避免创建额外的独立子类。

缺点：不易理解，不易阅读。 

airar
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java学习笔记（5）——内部类
iteye_709的博客
08-06 90
一、内部类1，静态内部类使用static修饰，声明在类体中静态内部类中可以访问外部类的静态成员2，成员内部类声明在类体中，不使用static,具有类的成员特征，也就是，必须有类的实例才能创建内部类实例内部类实例可以访问共享外部类的成员变量(很常用)如：链表的节点就可以定义为内部类3，局部内部类把类声明在方法中，就是局部内部类，作用域类似局部变量(很少见)4，匿名内部类匿名类，非常常见，可以写在任何...
Java 内部类访问外部类
zxcvbnmluton的专栏
08-12 1364
<br />今天需要从内部类访问外部类，查找了半天，终于发现原来可以这样处理。<br />public class Outer { private String name; public String getName(){ return name; } class Inner{ public String getName(){ return Outer.this.getName(); } } }
Java 内部类和静态内部类
刷穿算法！！！！
10-08 174
/** 总结： 1.静态内部类可以有静态成员(方法，属性)，而非静态内部类则不能有静态成员(方法，属性)。 2.静态内部类只能够访问外部类的静态成员,而非静态内部类则可以访问外部类的所有成员(方法，属性)。 3.实例化一个非静态的内部类的方法： a.先生成一个外部类对象实例 OutClassTest oc1 = new OutClassTest(); b.通过外部类的对象实例生成内部类对象 Ou...
java 外部类访问内部类变量_java – 我认为内部类可以访问外部类变量/方法？
weixin_42339759的博客
02-20 226
内部类可以通过自己的方法访问外部类的方法和属性.看下面的代码：class OuterClass {String a = "A";String b = "B";String c = "C";class InnerClass{int x;public String getA(){return a; // access the variable a from outer class}}public st...
java 外部类 内部类_【Java】内部类与外部类的互访使用小结
weixin_34900026的博客
02-20 134
内部类又称为嵌套类。可以把内部类理解为外部类的一个普通成员。内部类访问外部类里面的可以自由访问外面的，规则和static一样。(访问非静态时必须先创建对象)具体如下：非静态内部类的非静态方法直接访问public class Outter {int i = 5;static String string = "Hello";class Inner1{void Test1 () {System.out....
Java基础内容-内部类学习笔记
最新发布
03-21
根据老师讲解写的笔记
java基础知识-try-catch的使用
06-14
如果其中的catch块能够处理当前发生的异常，就会进入该catch块，并执行其内部的处理逻辑。如果没有找到匹配的catch块，异常将向上层调用堆栈传递，直到找到合适的catch块或程序终止。 通常在catch块中，可以打印...
JAVA基础-GUI
08-19
4. 一般用匿名内部类来表示 5. 在覆盖方法的时候，方法的参数一般是XXXEvent类型的变量接收 6. 事件触发后会把事件打包成对象传递给该变量（其中包括事件源对象。通过getSource()或者getComponent()获取） 5. 创建...
Java基础内部类.xmind文件
01-23
Java基础内部类.xmind文件
大学课程讲义-Java基础-高级类特性.pptx
08-14
Java 基础-高级类特性 本资源摘要信息涵盖了 Java 编程语言的高级类特性，包括 static 关键字、final 关键字、抽象类、接口、内部类等知识点。 1. static 关键字 static 关键字是 Java 中的一个关键字，用于修饰...
十一、Java内部类
拾荒人博客
11-06 134
概念： 类的类就称为Java内部类。 内部类分类： 成员内部类、方法内部类、静态嵌套类、匿名内部类 1.成员内部类 相当于Java中的成员变量 基本格式： publicclassTestClass { publicclassInnerClass{ //成员内部类 } } TestClass： 外部类 InnerClass : 成员内部类 内部类编译后会形成一个新的字节码文件【外部类类名$内部类类型.class】如果用ecli...
JAVA 中内部类的一些用法，以及内部类访问外部变量为什么需要final修饰
xzb5566的专栏
05-24 356
JAVA 中内部类的一些用法，以及内部类访问的变量为什么需要final修饰 几个小问题，我们想想看： 内部类访问类成员变量，该成员变量需要 final修饰吗？为什么？ 内部类访问方法的局部变量，该局部变量需要final修饰吗？为什么？ 接下来我们来解答这两个问题 在java8出现之前，内部类的写法，我们经常这样写：写在某个类中，或者某个类的方法中，或者匿名内部类。但是使用内部内部类经常遇到一个问题，就是内部类有时要访问到方法中的局部变量，或类变量，导致需要变量申明为 fin...
沈师PTA--JAVA程序设计-第3章习题集（2）--填空题答案版 2021-11-03
小泽同学的博客
11-03 1518
R4-1 For a class Class1 in Class1.java as below: package Testpackage; public class Class1{ … … } The main() is in MainPro.java as below: import Testpackage.*; … … The CLASSPATH is "c:\java\lib\classes.zip;.; ". The MainPro.java is in c:\Testdir. The curren
一看你就懂，超详细java中的ClassLoader详解
热门推荐
frank 的专栏
02-10 31万+
本篇文章已授权微信公众号 guolin_blog （郭霖）独家发布 ClassLoader翻译过来就是类加载器，普通的java开发者其实用到的不多，但对于某些框架开发者来说却非常常见。理解ClassLoader的加载机制，也有利于我们编写出更高效的代码。ClassLoader的具体作用就是将class文件加载到jvm虚拟机中去，程序就可以正确运行了。但是，jvm启动的时候，并不会一次性加载所有的...
Java技能测试试卷二及答案
:)一位靓仔偶然路过的博客
01-26 1万+
Java技能测试试卷二 第一部分：基础部分    软件基础 （每题3分，共18分）  1、十进制数10相当于二进制数的多少？   1010  2、请写出五个基本数据类型。   byte/short/int/long/boolean    3、程序的控制语句有哪些？      4、break语句和continue语句有什么区别？   break是指中断当前语句块/
java内部类访问外部变量_Java嵌套内部类访问外部类变量
weixin_29711757的博客
02-21 484
嵌套的内部类ABar和BBar可以访问主类的变量吗？例如：public class Foo {public ABar abar = new ABar();public BBar bbar = new BBar();public int someCounter = 0;public class ABar {public int i = 0;public void someMethod(){i++;s...
Java文件编译成功后的class文件无法执行
Alony成长记
08-22 7796
平时用惯了Eclipse，今天偶尔在
使用java命令运行class文件提示“错误：找不到或无法加载主类“的问题分析
z583636762的博客
01-24 821
错误：找不到或无法加载主类； 解决方法： 1） intellij写的，要去掉package 2）每当修改java文件，再测试时，需要重新进入cmd，不要一直开着cmd的界面反复进行测试，那样会一直按修改前的系统变量执行的。 正确示范：
java内部类 构造方法 【java基础】
07-28
Java内部类的构造方法与普通类的构造方法有一些区别。在内部类中，构造方法的调用需要通过外部类的实例来进行。 首先，内部类可以分为成员内部类和局部内部类。对于成员内部类，它是外部类的一个成员，可以访问外部...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值