如果一个事物的内部包含另一个事物,那么这就是一个类内部包含另一个类。 例如:身体和心脏的关系。又如:汽车和发动机的关系。
分类:
1. 成员内部类
2. 局部内部类(包含匿名内部类)
一,成员内部类
1.成员内部类的定义格式:
修饰符 class 外部类名称 { 修饰符 class 内部类名称 { // ... } // ... }
public class Body { // 外部类
public class Heart { // 成员内部类
// 内部类的方法
public void beat() {
System.out.println("心脏跳动:蹦蹦蹦!");
System.out.println("我叫:" + name); // 正确写法!
}
}
}
生成的Java文件:
1)必须要重新complile才能生成
2)$符号以表示内部类,因此很多时候在编写Java代码时不能用$。
2.访问规则:
内部类可以直接访问外部类的成员,包括私有成员。
外部类要访问内部类的成员,必须要建立内部类的对象。
即:内用外,随意访问;外用内,需要内部类对象。
3.如何使用成员内部类
有两种方式:
1. 间接方式:在外部类的方法当中,使用内部类;然后main只是调用外部类的方法。
如下:在外部类方法methodBody中创建内部类heart
2. 直接方式,公式: 类名称 对象名 = new 类名称(); 【外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();】
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;
}
}
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.外部类成员变量名
public class Outer {
int num = 10; // 外部类的成员变量
public class Inner /*extends Object*/ {
int num = 20; // 内部类的成员变量
public void methodInner() {
int num = 30; // 内部类方法的局部变量
System.out.println(num); // 局部变量,就近原则 30
System.out.println(this.num); // 内部类的成员变量 20
System.out.println(Outer.this.num); // 外部类的成员变量 10
}
}
}
public class Demo02InnerClass {
public static void main(String[] args) {
// 外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
Outer.Inner obj = new Outer().new Inner();
obj.methodInner();
}
}
三,局部内部类
如果一个类是定义在一个方法内部的,那么这就是一个局部内部类。
“局部”:只有当前所属的方法才能使用它,出了这个方法外面就不能用了。
1.定义格式:
修饰符 class 外部类名称 { 修饰符 返回值类型 外部类方法名称(参数列表) { class 局部内部类名称 { // ... } } }
2.如何使用
class Outer {
public void methodOuter() {
class Inner { // 局部内部类
int num = 10;
public void methodInner() {
System.out.println(num); // 10
}
}
Inner inner = new Inner();
inner.methodInner();
}
}
public class DemoMain {
public static void main(String[] args) {
Outer obj = new Outer();
obj.methodOuter();
}
}
意义:内部类当前这个方法中所特有的东西,除了它(该方法)谁用都不行。所以局部内部类也没有权限修饰符。
3.小节一下类的权限修饰符:
public > protected > (default) > private
定义一个类的时候,权限修饰符规则:
1. 外部类:public / (default)
2. 成员内部类:public / protected / (default) / private
3. 局部内部类:什么都不能写
4.局部内部类的final问题
局部内部类,如果希望访问所在方法的局部变量,那么这个局部变量必须是【有效final的】,即只要成员变量事实不变就行。
备注:从Java 8+开始,只要局部变量事实不变,那么final关键字可以省略。
原因:
1. new出来的对象在堆内存当中。
2. 局部变量是跟着方法走的,在栈内存当中。
3. 方法运行结束之后,立刻出栈,局部变量就会立刻消失。
4. 但是new出来的对象会在堆当中持续存在,直到垃圾回收消失。
Java7:
public class MyOuter {
public void methodOuter() {
final int num = 10; // 所在方法的局部变量,必须有这个final修饰符
class MyInner {
public void methodInner() {
System.out.println(num);
}
}
}
}
Java8+:
public class MyOuter {
public void methodOuter() {
int num = 10; // 所在方法的局部变量,只要事实不变就行
class MyInner {
public void methodInner() {
System.out.println(num);
}
}
}
}
四,匿名内部类
1.由来:
1)定义一个接口
public interface MyInterface {
void method(); // 抽象方法
//省略了抽象修饰,应为:
//public abstract void method();
}
2)实现类覆盖重写了方法(ctrl+enter生成@Override)
public class MyInterfaceImpl implements MyInterface {
@Override
void method() {
System.out.println("实现类覆盖重写了方法!111");
}
}
3)Main中创建一个实现类的实例对象,执行实现类的方法体
public class DemoMain {
public static void main(String[] args) {
MyInterfaceImpl impl = new MyInterfaceImpl();
impl.method();
}
}
4)也可以用多态,左父右子,左边是一个接口obj
public static void main(String[] args) {
MyInterface obj = new MyInterfaceImpl();
obj.method();
}
注:在Main中右边的实现类MyInterfaceImpl只使用了这一次。
引出【匿名内部类】:
如果接口的实现类(或者是父类的子类)只需要使用唯一的一次,
那么这种情况下就可以省略掉该类的定义,而改为使用【匿名内部类】。
2.格式
匿名内部类的定义格式: 接口名称 对象名 = new 接口名称() { // 覆盖重写所有抽象方法 -->这括号体内就是匿名内部类 };
对格式“new 接口名称() {...}”进行解析: 1. new代表创建对象的动作 2. 接口名称就是匿名内部类需要实现哪个接口 3. {...}这才是匿名内部类的内容
现在要实现刚才的功能的话,不用定义MyInterfaceImpl这个实现类。
直接:
1)定义接口
public interface MyInterface {
void method(); // 抽象方法
//省略了抽象修饰,应为:
//public abstract void method();
}
2)在Main中用【匿名内部类】替代曾经的Impl实现类
public static void main(String[] args) {
// MyInterface obj = new MyInterfaceImpl();
// obj.method();
// MyInterface some = new MyInterface(); // 错误写法!
// 使用匿名内部类,但不是匿名对象,对象名称就叫objA
MyInterface objA = new MyInterface() {
@Override
public void method() {
System.out.println("匿名内部类实现了方法");
}
}
objA.method();
}
注:
1)其中括号体内无名无姓的部分称为匿名内部类,是【匿名】的由来。
{
@Override
public void method() {
System.out.println("匿名内部类实现了方法");
}
}
2)右边的new的是接口名。MyInterface objA = new MyInterface(){@Override【匿名内部类】}
3)直接new接口是错误的,
3)意义:想写接口又不想麻烦地去写接口实现类,就直接在创建接口对象时,后面跟上有override注解的匿名内部类。
另注:
1. 匿名内部类,在【创建对象】的时候,只能使用唯一一次。 如果希望多次创建对象,而且类的内容一样的话,那么就需要使用单独定义的实现类了。
2. 匿名对象,在【调用方法】的时候,只能调用唯一一次。 如果希望同一个对象,调用多次方法,那么必须给对象起个名字。
3. 匿名内部类是省略了【实现类/子类名称】,但是匿名对象是省略了【对象名称】 强调:匿名内部类和匿名对象不是一回事!!! */
public class DemoMain {
public static void main(String[] args) {
// MyInterface obj = new MyInterfaceImpl();
// obj.method();
// MyInterface some = new MyInterface(); // 错误写法!
// 使用匿名内部类,但不是匿名对象,对象名称就叫objA
MyInterface objA = new MyInterface() {
@Override
public void method1() {
System.out.println("匿名内部类实现了方法!111-A");
}
@Override
public void method2() {
System.out.println("匿名内部类实现了方法!222-A");
}
};
objA.method1();
objA.method2();
System.out.println("=================");
// 使用了匿名内部类,而且省略了对象名称,也是匿名对象
new MyInterface() {
@Override
public void method1() {
System.out.println("匿名内部类实现了方法!111-B");
}
@Override
public void method2() {
System.out.println("匿名内部类实现了方法!222-B");
}
}.method1();
// 因为匿名对象无法调用第二次方法,所以需要再创建一个匿名内部类的匿名对象
new MyInterface() {
@Override
public void method1() {
System.out.println("匿名内部类实现了方法!111-B");
}
@Override
public void method2() {
System.out.println("匿名内部类实现了方法!222-B");
}
}.method2();
}
}
由上可见,如果存在重复块,用匿名内部类还是挺麻烦的。。。。。。