Java学习【阶段一[04]】继承与多态（10内部类）

最新推荐文章于 2024-07-12 14:04:44 发布

222100327赵振廷

最新推荐文章于 2024-07-12 14:04:44 发布

阅读量109

点赞数

分类专栏： Java学习路线

本文链接：https://blog.csdn.net/qq_41915980/article/details/102789449

版权

Java学习路线专栏收录该内容

35 篇文章 0 订阅

订阅专栏

一、内部类概述

如果一个事物的内部包含另外一个事物，那么这就是一个类内部包含另一个类
例如：身体和心脏汽车和发动机的关系

分类：
1、成员内部类
2、局部内部类（包含匿名内部类）

二、成员内部类的定义

成员内部类的定义格式：
修饰符 class 外部类名称{
修饰符 class 内部类名称{
//.....
}
//....
}
注意：内用外，随意访问；外用内，需要内部类对象。

三、成员内部类的使用

使用成员内部类的两种方法
1、在外部类的方法中使用内部类，然后main只是调用外部类的方法
2、直接方式：公式：
类名称对象名=new 类名称（）；
【外部类名称.内部类名称对象名=new 外部类名称（）.new 内部类名称（）；】

在外部类中定义内部类

package Day11_Demo02;

public class Body {//外部类
	
	public class Heart{//成员内部类
		//内部类的方法
		public void beat() {
			System.out.println("心脏跳动！！");
			System.out.println("我叫"+name);//正确写法
		}
	}
	//外部类的成员变量
	private String name;
	//外部类的方法
	public void methodBody() {
		System.out.println("外部类的方法");
		new Heart().beat();
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}

}

使用内部类

package Day11_Demo02;
/*
如果一个事物的内部包含另外一个事物，那么这就是一个类内部包含另一个类
例如：身体和心脏    汽车和发动机的关系

分类：
1、成员内部类
2、局部内部类（包含匿名内部类）

成员内部类的定义格式：
修饰符 class 外部类名称{
      修饰符 class 内部类名称{
      //.....
     }
     //....
}
注意：内用外，随意访问；外用内，需要内部类对象。
==============================
使用成员内部类的两种方法
1、在外部类的方法中使用内部类，然后main只是调用外部类的方法
2、直接方式：公式：
类名称 对象名=new 类名称（）；
【外部类名称.内部类名称 对象名=new 外部类名称（）.new 内部类名称（）；】


 */
public class Demo01InnerClass {
	public static void main(String[] args) {
		Body body=new Body();//外部类的对象
		//通过外部类的对象，调用外部类的方法，里面间接使用内部类Heart
		body.methodBody();
		System.out.println("================");
		Body.Heart heart=new Body().new Heart();
		heart.beat();
	}
}

四、成员内部类的同名变量访问

如果出现了重名现象，那么格式是：外部类名称.this.外部类成员变量名

外部类与内部类的创建

package Day11_Demo02;

/*
如果出现了重名现象，那么格式是：外部类名称.this.外部类成员变量名
 */
public class Outer {
	
	int num=10;//外部类的成员变量
	
	public class Inner{
		
		int num=20;//内部类的成员变量
		
		public void methodInner() {
			int num=30;//内部类方法的局部变量
			System.out.println(num);//局部变量，就近原则 输出：30
			System.out.println(this.num);//20
			//System.out.println(super.num);//错误，内部类和外部类不是继承关系
			System.out.println(Outer.this.num);//外部类的成员变量
		}
	
	}

}

调用

package Day11_Demo02;

public class Demo02InnerClass {
	public static void main(String[] args) {
		//外部类名称.内部类名称 对象名=new 外部类名称.new内部类名称（）；
		Outer.Inner obj=new Outer().new Inner();
		obj.methodInner();
	}
}
/*输出结果：
30
20
10
*/

五、局部内部类的定义

如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。
“局部”：只有当前所属的方法才能使用它，出来这个方法外面就不能用了。

定义格式
修饰符 class 外部类名称{
修饰符返回值类型外部类方法名称（参数列表）{
class 局部内部类名称{
//...
}
}
}

定义一个类的时候，权限修饰符规则
1、外部类：public/(default)，没有外边的类，不能用private/protected
2、成员内部类：public/protected/(default)/private
3、局部内部类：什么都不能写，因为它只在所在方法能用

例子：

public class Outer {
	
	public void methodOuter() {
		class Inner{//局部内部类
			int num=10;
			public void methodInner() {
				System.out.println(num);//10
			}
		}
	}

六、局部内部类的final问题

局部内部类如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】
从Java8开始，只要局部变量事实不变，那么final关键字可以省略

原因：
1、new出来的对象在堆内存中。
2、局部变量是跟着方法走的，在栈内存中
3、方法运行结束后，立刻出栈，局部变量就会立刻消失
4、但是new出来的对象会在堆当中持续存在，直到垃圾回收消失

package Day11_Demo03;
/*
局部内部类如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】
从Java8开始，只要局部变量事实不变，那么final关键字可以省略

原因：
1、new出来的对象在堆内存中。
2、局部变量是跟着方法走的，在栈内存中
3、方法运行结束后，立刻出栈，局部变量就会立刻消失
4、但是new出来的对象会在堆当中持续存在，直到垃圾回收消失
 */
public class MyOuter {
	
	public void methodOuter() {
		int num=10;//所在方法的局部变量，虽然没写但是num值没有变也算有效final，
		class MyInner{
			public void methodInner() {
				System.out.println(num);
			}
		}
	}

}

七、匿名内部类

如果接口的实现类或者是父类的子类只需要使用唯一的一次，
那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】

匿名内部类的定义格式
接口名称对象名=new 接口名称（）{
//覆盖重写接口中所有抽象方法
}；//没有名字的类

package Day11_Demo04;
/*
如果接口的实现类或者是父类的子类只需要使用唯一的一次，
那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】

匿名内部类的定义格式
接口名称 对象名=new 接口名称（）{
    //覆盖重写接口中所有抽象方法
}；//没有名字的类
 */
public class DemoMain {
	
	public static void main(String[] args) {
		
		//  MyInterfaceImpl impl=new MyInterfaceImpl();
		//  impl.method();
		
		//MyInterface some=new MyInterface（）；//错误写法
		
		//使用匿名内部类
		MyInterface obj=new MyInterface() {

			@Override
			public void method() {
				System.out.println("匿名内部类实现了方法");	
			}
			
		};
		obj.method();
	}

}

八、匿名内部类的注意事项

对格式进行解析“new 接口名称（）{.....}”
1、new代表创建对象的动作
2、接口名称就是匿名内部类需要实现哪个接口
3、{...}才是匿名内部类的内容

另外还要注意几点问题：
1、匿名内部类在创建对象的时候只能使用唯一的一次。
如果希望多次创建对象，而且类的内容一样的话就必须使用单独定义的实现类了。
2、匿名对象在【调用】方法的时候，只能调用唯一一次。
如果希望同一个对象调用多次方法，那么必须给对象起一个名字。
3、匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】
【强调】匿名内部类和匿名对象不是一回事！！！

package Day11_Demo04;
/*
如果接口的实现类或者是父类的子类只需要使用唯一的一次，
那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】

匿名内部类的定义格式
接口名称 对象名=new 接口名称（）{
    //覆盖重写接口中所有抽象方法
}；//没有名字的类

对格式进行解析“new 接口名称（）{.....}”
1、new代表创建对象的动作
2、接口名称就是匿名内部类需要实现哪个接口
3、{...}才是匿名内部类的内容

另外还要注意几点问题：
1、匿名内部类在创建对象的时候只能使用唯一的一次。
如果希望多次创建对象，而且类的内容一样的话就必须使用单独定义的实现类了。
2、匿名对象在【调用】方法的时候，只能调用唯一一次。
如果希望同一个对象调用多次方法，那么必须给对象起一个名字。
3、匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】
【强调】匿名内部类和匿名对象不是一回事！！！
 */
public class DemoMain {
	
	public static void main(String[] args) {
		
		//  MyInterfaceImpl impl=new MyInterfaceImpl();
		//  impl.method();
		
		//MyInterface some=new MyInterface（）；//错误写法
		
		//使用匿名内部类,但不是匿名对象，对象名称就叫objA
		MyInterface objA=new MyInterface() {

			@Override
			public void method1() {
				System.out.println("匿名内部类实现了方法111A");	
			}

			@Override
			public void method2() {
				System.out.println("匿名内部类实现了方法222A");	
				
			}
			
		};
		objA.method1();
		objA.method2();
		
		System.out.println("===========================");
		
		//使用了匿名内部类，而且省略了对象名称，也是匿名对象
		new MyInterface() {


			@Override
			public void method1() {
				System.out.println("匿名内部类实现了方法111B");	
				
			}

			@Override
			public void method2() {
				System.out.println("匿名内部类实现了方法222B");	
				
			}
	    }.method1();
	 //因为匿名对象无法调用第二次方法，所以需要在创建一个匿名内部类的匿名对象
	    new MyInterface() {


			@Override
			public void method1() {
				System.out.println("匿名内部类实现了方法111B");	
				
			}

			@Override
			public void method2() {
				System.out.println("匿名内部类实现了方法222B");	
				
			}
	    }.method2();
	}
}

222100327赵振廷

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java学习【阶段一[04]】继承与多态（10内部类）

一、内部类概述如果一个事物的内部包含另外一个事物，那么这就是一个类内部包含另一个类例如：身体和心脏汽车和发动机的关系分类：1、成员内部类2、局部内部类（包含匿名内部类）二、成员内部类的定义成员内部类的定义格式：修饰符 class 外部类名称{ 修饰符 class 内部类名称{ //..... } //....}注意：内...
复制链接

扫一扫