十一、Java内部类

最新推荐文章于 2021-11-06 17:30:14 发布

HJHO

最新推荐文章于 2021-11-06 17:30:14 发布

阅读量134

点赞数

分类专栏： JavaSE-上文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/weixin_49576031/article/details/121176383

版权

JavaSE-上专栏收录该内容

31 篇文章 1 订阅

订阅专栏

概念：

类的类就称为Java内部类。

内部类分类：

成员内部类、方法内部类、静态嵌套类、匿名内部类

1.成员内部类

相当于Java中的成员变量

基本格式：

public class TestClass {

public class InnerClass{ //成员内部类

}

}

TestClass ：外部类

InnerClass : 成员内部类

内部类编译后会形成一个新的字节码文件【外部类类名$内部类类型.class】如果用eclipse 需要在项目-->bin->对应的包中可以找到字节码文件。

特点：

1.成员内部类可以使用任意的访问限制修饰符。（相当于成员属性）

2.成员内部类中可以有 --实例属性、实例方法、构造方法。 （没有构造属性和方法）

3.成员内部类中的[构造方法、实例方法]可以访问本类（当前内部类）其他的其他构造方法【new】，可以访问实例变量/方法、this.实例变量/方法，[可以省略this]。【内访内】

4.成员内部类中的（构造方法和实例方法）可以访问外部类的构造方法，实例方法/变量，类方法/变量。【内访外】

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

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

例子：

public class TestClass {
	//成员内部类1  公共修饰符
	//实例属性
	String name = "李四";
	private  int age = 20;
	public static String city = "西安";
	public TestClass(){
		System.out.println("外部类的构造方法");
		
		//访问内部类
		}
	public TestClass(String name){
		//访问内部类
		System.out.println(new InnerClass4().age);
		System.out.println(new InnerClass4().name);
		System.out.println(new InnerClass4().city);
		new InnerClass4().InnerMethods();
	}
	public void methodsTestf(){
		System.out.println("外部类实例方法");
		System.out.println(new InnerClass4().age);
		System.out.println(new InnerClass4().name);
		System.out.println(new InnerClass4().city);
		new InnerClass4().InnerMethods();
	}
	public static void testMethods(){
		System.out.println("外部类的静态方法");
//		静态变量无发访问内部成员类中的属性和方法
//		System.out.println(new InnerClass4().age);
//		System.out.println(new InnerClass4().name);
//		System.out.println(new InnerClass4().city);
//		new InnerClass4().InnerMethods();
		
	}
	
	public class InnerClass1{
		//实例属性
		public String name = "张三";
		protected int age = 18;
		char sex = '男';
		private String city = "北京";
		
		//构造方法
		public InnerClass1(){}
		public InnerClass1(String name){
			
			//访问内部类
			System.out.println(new InnerClass1().name);
			System.out.println(new InnerClass1().age);
			System.out.println(new InnerClass1().sex);
			System.out.println(new InnerClass1().city);
			System.out.println(name + "\t" + age + "\t" + city + "\t" + sex + "\n");
			System.out.println("name为："+ name);
			System.out.print(this.name);
			System.out.print(this.age);
			System.out.print(this.city);
			System.out.print(this.sex);
			
			new InnerClass1().methodsTest1();
			this.methodsTest1();
			methodsTest1();
			
			//方位外部类
			System.out.println(new TestClass().name);
			System.out.println(TestClass.this.name);//访问外部类的实例name
			System.out.println(TestClass.this.age);
			System.out.println(this.name);//访问内部类得实例name
			System.out.println(name);//访问的当前作用域中的name
			System.out.println(TestClass.city); //访问外部类的city
			System.out.println(this.city);
			TestClass.this.methodsTestf();
			new TestClass().methodsTestf();
			methodsTestf();
			
			//访问外部静态方法
//			one
			TestClass.testMethods();
//			tow
			new TestClass().testMethods();
//			three
			TestClass.this.testMethods();
			
//			访问其他的外部类
			InnerClass3 fClass1 = new InnerClass3();
			
		}
		
		//实例方法
		public void methodsTest1(){
			System.out.println("内部成员类无参的实例方法");
		}
		public void methodsTest2(){
			System.out.println("内部成员类有参的实例方法");
			methodsTest1();
		}
	};
	//成员内部类2 缺省限制符号
	class InnerClass2{};
	//友好修饰符 成员内部类3
	protected class InnerClass3{};
	//私有成员内部类
	private class InnerClass4{
		public String name = "王伟";
		protected int age = 20;
		char sex = '女';
		private String city = "西安";
		
		//构造方法
		public InnerClass4(){
			System.out.println("私有的内部成员类构造函数");
		}
		public void InnerMethods(){
			System.out.println("私有内部成员类方法");
		}
		
	};
}

2.方法内部类

-定义在方法内部的类 (相当于局部变量)

格式：

public class TestClass {

        public TestClass(){
                   //构造方法中的内部类

                 class  InnerClass1{

           }

}

public  void  testMethod(String canshu){
           //实例方法中的内部类
         class  InnerClass2{

        }

}

public static  void  testStaticMethod(String canshu){
        //静态方法中的内部类
         class  InnerClass3{

                }

        }

}

特点：

1.方法内部类不能使用访问修饰限制符。（类似于方法中的局部变量）

2.方法内部类可以有实例变量/方法，构造方法。（没有静态方法）

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

4.方法内部类可以访问当前方法中的局部变量，局部变量默认被final修饰，只能访问不能改写。

5.方法内部类可以访问外部了的实例变量/方法、静态变量/方法、构造方法。（都可以访问）。

6.外部类无法访问内部方法类。

//内部方法类
public class TestClass1 {
	private int age = 18;
	public String name  = "吗尔雅";
	public TestClass1(){
		//当内部类访问的时候默认添加了final
		String name = "张三";
		name = 18 + "";
		//方法内部类不能使用修饰符
		class InnerMthodsClass{
			public String name = "李四";
			private  char sex= '女';
				public InnerMthodsClass(){}
			public InnerMthodsClass(String name){
				//访问内部类 当前类
				System.out.println(this.name);
				System.out.println(this.sex);
				System.out.println();
				System.out.println(new InnerMthodsClass().name);
				System.out.println(name);
				InnerMethods();
				
				
				//访问外部类
				System.out.println(new TestClass1().name);
				System.out.println(new TestClass1().age);
				new TestClass1().testMethods1();
				
			}
			
			public void InnerMethods(){
				//访问内部类 当前类
				System.out.println(this.name);
				System.out.println(this.sex);
				System.out.println();
				System.out.println(new InnerMthodsClass().name);
				System.out.println(name);
			}
		}
	}
	
	public void testMethods(){
		class InnerMthodsClass{
			public String name = "李四";
			private  char sex= '女';
				public InnerMthodsClass(){}
			public InnerMthodsClass(String name){
				//访问内部类 当前类
				System.out.println(this.name);
				System.out.println(this.sex);
				System.out.println();
				System.out.println(new InnerMthodsClass().name);
				System.out.println(name);
				InnerMethods();
				
				
				//访问外部类
				System.out.println(new TestClass1().name);
				System.out.println(new TestClass1().age);
				new TestClass1().testMethods1();
				
			}
			
			public void InnerMethods(){
				//访问内部类 当前类
				System.out.println(this.name);
				System.out.println(this.sex);
				System.out.println();
				System.out.println(new InnerMthodsClass().name);
				System.out.println(name);
			}
		}
	}
	
	
	public static void staticMtehods(){
		class InnerMthodsClass{
			public String name = "李四";
			private  char sex= '女';
				public InnerMthodsClass(){}
			public InnerMthodsClass(String name){
				//访问内部类 当前类
				System.out.println(this.name);
				System.out.println(this.sex);
				System.out.println();
				System.out.println(new InnerMthodsClass().name);
				System.out.println(name);
				InnerMethods();
				
				
				//访问外部类
				System.out.println(new TestClass1().name);
				System.out.println(new TestClass1().age);
				new TestClass1().testMethods1();
				
			}
			
			public void InnerMethods(){
				//访问内部类 当前类
				System.out.println(this.name);
				System.out.println(this.sex);
				System.out.println();
				System.out.println(new InnerMthodsClass().name);
				System.out.println(name);
			}
		}
	}
//	测试构造函数
	public TestClass1(String name){
		//		外部类的构造方法
	}
//	测试事例方法
	public void testMethods1(){
		System.out.println("外部类的事例方法");
	}
//测试的静态方法
	public static void staticMtehods1(){
		System.out.println("外部类的静态方法");
		class fn{
			String name = "123";
			public void mtehdos(){
				new TestClass1();
			}
		}
	}
}

3.静态嵌套类

静态嵌套类中可以有构造方法，实例变量/方法，类变量/方法。（类似静态属性）

格式：

//外部类
public class TestClass2 {
	//静态嵌套类
	public static class InnerStaticClass{
		public String name = "张三";
		private char age = '女';
		public static String city = "城市";
		public InnerStaticClass(){
			System.out.println("静态嵌套类的构造方法");
		}
		
		public void innerMethods(){
			System.out.println("静态嵌套的事例方法");
		}
		
		public static void innerStaticMethods(){
			System.out.println("静态嵌套类的静态方法");
		}
	}
}

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

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

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

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

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

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

4.匿名内部类

没有名字的java类,在不用创建出新类的情况下，构建出当前类的子类，构建的子类没有名字，所以叫匿名内部类

基本格式:

public class MainTest2 {

public static void main(String[] args) {

// TODO Auto-generated method stub



//第二种匿名类

TestClass3 test1 = new TestClass3() {

@Override

public void sayhi() {

// TODO Auto-generated method stub

        System.out.println("匿名重写抽象类");

    }

};

    InnterFace test2 = new InnterFace() {

@Override

        public void JKout() {

// TODO Auto-generated method stub

        System.out.println("匿名重写接口");

            }

        };

    }

}

//子类的第一种写法
class AbstractClass extends TestClass3 {

@Override

public void sayhi() {

    }

}
class InterFaceClass implements InnterFace{
@Override

public void JKout() {

// TODO Auto-generated method stub

System.out.println( name );

    }

}

无奈源于不够强大

HJHO

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
十一、Java内部类

概念：类的类就称为Java内部类。内部类分类：成员内部类、方法内部类、静态嵌套类、匿名内部类1.成员内部类相当于Java中的成员变量基本格式：publicclassTestClass {publicclassInnerClass{ //成员内部类}}TestClass：外部类InnerClass : 成员内部类内部类编译后会形成一个新的字节码文件【外部类类名$内部类类型.class】如果用ecli...
复制链接

扫一扫