这是我参与8月更文挑战的第8天,活动详情查看:8月更文挑战
一个事物的内部包含另一个事物。一个类里面包含另一个类,这个类叫内部类,包含它的叫它外部类。
例如:身体和心脏的关系;汽车和引擎的关系。
心脏、引擎只有在身体和汽车中才有用。内部类也一样。
分类:
1.成员内部类;
2.局部内部类(包括匿名内部类);
1.成员内部类
/* 修饰符 class 外部类名称{ 修饰符 class 内部类名称{ ...... } ...... } */
public class Outer {
private String name;
public class Inter{
public void InterMethod(){
System.out.println("内部方法");
System.out.println("姓名:" + name); // 成员内部类可以访问外部类属性
}
}
public void fun1(){
Inter in = new Inter();
in.InterMethod();
}
}
编译后,这个类的class文件保存在磁盘里
内部类的使用方式
在外部类中可以直接通过 new 对象的方式使用。
在其他类中访问:
1.间接方式:在外部类的方法中使用内部类,而在其他类中使用就 new 外部类调用这个方法;
/** * 其他类使用内部类 */
public class OuterDemo1 {
public static void main(String[] args) {
Outer out = new Outer();
out.fun1();
}
}
2.直接方式,直接创建出内部类
公式: 外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
public class OuterDemo2 {
public static void main(String[] args) {
Outer.Inter in = new Outer().new Inter();
in.InterMethod();
}
}
问题:在外部类、内部类、内部类方法体出现相同名称属性,如何输出相应的值呢?
解决:
public class OuterDemo3 {
private String name ="外";
class Inter{
private String name = "内";
public void interMethod(){
String name = "方法";
System.out.println(name); // 输出: 方法,就近原则
System.out.println(this.name); // 输出: 内
System.out.println(OuterDemo3.this.name); // 输出: 外
}
}
}
2.局部内部类
在方法体内定义一个类,出了这个方法,就无法使用这个类(所以其他类无法使用【局部内部类】)
普及:
权限修饰符的使用规则:
public > protected > (default) > private
1.外部类:能使用 public / (defautl) 修饰
2.成员内部类: public / protected / (default) / private
3.局部内部类:什么都不写
public class Test {
public void fun(){
final int num = 100;
class Fun{
private void fun2(){
System.out.println(num);
}
}
Fun fun = new Fun();
fun.fun2();
}
}
问题:为什么访问所在方法的局部变量,必须要有final修饰?
原因(本质是生命周期问题):
1.内部类 new 出来的对象在堆内存中;
2.局部变量跟着方法,在栈内存中;
3.方法运行完,立刻出栈,局部变量跟着消失;
4.但 new 出来的对象,会在堆内存持续存在,直到垃圾回收;
5.所以,要将该内存复制到常量池才能保存继续使用。
3.匿名内部类(重要)
往常,我们要使用接口方法,得先定义该接口的实现类 -> 重写该接口的所有抽象方法 -> new 实现类使用。
而如果接口的实现类只是用唯一的一次,那么这种情况就可以省略该实现类的定义,而改为使用 【匿名内部类】
接口
public interface MyInteface {
void method();
}
使用【匿名内部类】
/** * 格式: * 接口名称 对象名 = new 接口名称(){ * // 覆盖重写所有抽象方法 * }; */
public class AnonymityTest2 {
public static void main(String[] args) {
MyInteface my = new MyInteface(){
@Override
public void method() {
System.out.println("匿名内部类方法");
}
};
my.method();
}
}
很多人一开始可能会有误解:不是【匿名内部类】吗? MyInteface my = new MyInteface(){…} 这不是有名字么?
先看,对于”new MyInteface(){…};” 的解析:
1). new 代表对象创建的动作;
2). 接口名称 【匿名内部类】要实现的接口;
3). {…} 这才是【匿名内部类】的内容,里面重写着接口的所有抽象方法
它光秃秃的,的确没名没姓的。
而 MyInteface my = new MyInteface(){…} 中的 my 是对象名,它是供你调用匿名类方法的对象。
ps:匿名内部类、匿名对象
1、【匿名内部类】表示,在创建对象是,只能使用唯一一次,一般用于书写接口的实现类。
如果希望多次创建对象,而且类的内容一样的话,那还是单独定义实现类更方便。
public class AnonymityTest2 {
public static void main(String[] args) {
MyInteface my1 = new MyInteface(){
@Override
public void method() {
System.out.println("匿名内部类方法");
}
};
my1.method();
MyInteface my2 = new MyInteface(){
@Override
public void method() {
System.out.println("匿名内部类方法");
}
};
my2.method();
}
}
2.【匿名对象】表示,在调用方法时,只能调用唯一一次。
如果希望同一对象,调用多次方法,那么还是给对象起个名把。
new MyInteface(){
@Override
public void method1() {
System.out.println("匿名内部类方法1");
}
@Override
public void method2() {
System.out.println("匿名内部类方法2");
}
}.method1();
new MyInteface(){
@Override
public void method1() {
System.out.println("匿名内部类方法1");
}
@Override
public void method2() {
System.out.println("匿名内部类方法2");
}
}.method2();
3.两者不是一回事
【匿名内部类】是省略了 <实现类 / 子类>
【匿名对象】是省略了 <对象名称>
两者不是一回事。
public class AnonymityTest {
public static void main(String[] args) {
fun1();
}
private static void fun1() {
// 对于 Thread 来说,这就是【匿名对象】
// 对于 Runnable 来说,这就是【匿名内部类】
new Thread( new Runnable(){
@Override
public void run() {
}
}).start();
}
}
今天的文章内部类(成员内部类、局部内部类(包括匿名内部类))分享到此就结束了,感谢您的阅读。
版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。
如需转载请保留出处:https://bianchenghao.cn/13650.html