一个事物的内部包含另一个事物。一个类里面包含另一个类,这个类叫内部类,包含它的叫它外部类。
例如:身体和心脏的关系;汽车和引擎的关系。
心脏、引擎只有在身体和汽车中才有用。内部类也一样。
分类:
1.成员内部类;
2.局部内部类(包括匿名内部类);
/*
修饰符 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); // 输出: 外
}
}
}
在方法体内定义一个类,出了这个方法,就无法使用这个类(所以其他类无法使用【局部内部类】)
普及:
权限修饰符的使用规则:
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.所以,要将该内存复制到常量池才能保存继续使用。
往常,我们要使用接口方法,得先定义该接口的实现类 -> 重写该接口的所有抽象方法 -> 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();
}
}