定义:在一个类中定义一个类。举例:在一个类A的内部定义一个类B,类B就被称为内部类,类A称为外部类。
定义格式:
修饰符 class 外部类名{
修饰符 class 内部类名{ }
}
代码举例:
public class Outer {
public class Inner { }
}
内部类的访问特点
- 内部类可以直接访问外部类的成员,包括私有
- 外部类要访问内部类的成员,必须创建对象
/* 内部类访问特点:
内部类可以直接访问外部类的成员,包括私有
外部类要访问内部类的成员,必须创建对象
*/
public class Outer {
private int num = 10;
public class Inner {
public void show() {
System.out.println(num);
}
}
public void method() {
Inner i = new Inner();
i.show();
}
}
成员内部类
- 成员内部类 :定义在类中方法外的类。
- 外界创建成员内部类格式
- 格式:外部类名.内部类名 对象名 = 外部类对象.内部类对象;
- 举例:Outer.Inner oi = new Outer().new Inner();
public class Outer {
private int num = 10;
public class Inner {
public void show() {
System.out.println(num);
}
}
public void method() {
Inner i = new Inner();
i.show();
}
}
public class InnerDemo {
public static void main(String[] args) {
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}
- 内部类同名访问
public class Outer01 {
int num = 10; // 外部类的成员变量
public class Inner{
int num = 20; // 内部类的成员变量
public void methodInner() {
int num = 30; // 内部类方法的局部变量
System.out.println(num); // 局部变量,就近原则
System.out.println(this.num); // 内部类的成员变量
System.out.println(Outer01.this.num); // 外部类的成员变量
}
}
}
public class Demo02InnerClass {
public static void main(String[] args) {
// 外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
Outer01.Inner obj = new Outer01().new Inner();
obj.methodInner();
}
}
- 成员内部类的推荐使用方案
- 将一个类,设计为内部类的目的,大多数都是不想让外界去访问,所以
内部类的定义应该私有化
,私有化之后,再提供一个可以让外界调用的方法,方法内部创建内部类对象并调用
- 将一个类,设计为内部类的目的,大多数都是不想让外界去访问,所以
public class Outer {
private int num = 10;
private class Inner {
public void show() {
System.out.println(num);
}
}
public void method() {
Inner i = new Inner();
i.show();
}
}
public class InnerDemo {
public static void main(String[] args) {
//Outer.Inner oi = new Outer().new Inner();
//oi.show();
Outer o = new Outer();
o.method();
}
}
局部内部类
- 局部内部类定义位置
- 局部内部类是在方法中定义的类。
- 局部内部类方式
- 局部内部类,外界是无法直接使用,需要在方法内部创建对象并使用。
- 该类可以直接访问外部类的成员,也可以访问方法内的局部变量。
定义格式:
修饰符 class 外部类名称 {
修饰符 返回值类型 外部类方法名称(参数列表) {
class 局部内部类名称 {
// ...
}
}
}
示例代码
public class Outer {
private int num = 10;
public void method() {
int num2 = 20;
class Inner {
public void show() {
System.out.println(num);
System.out.println(num2);
}
}
Inner i = new Inner();
i.show();
}
}
public class OuterDemo {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
public > protected > (default) > private
定义一个类的时候,权限修饰符规则:
- 外部类:public / (default)
- 成员内部类:public / protected / (default) / private
- 局部内部类:什么都不能写
- 局部内部类的final问题
局部内部类,如果希望访问所在方法的局部变量,那么这个局部变量必须是【有效final的】。
备注:从Java 8+开始,只要局部变量事实不变,那么final关键字可以省略。
原因:
- new出来的对象在堆内存当中。
- 局部变量是跟着方法走的,在栈内存当中。
- 方法运行结束之后,立刻出栈,局部变量就会立刻消失。
- 但是new出来的对象会在堆当中持续存在,直到垃圾回收消失。
public class MyOuter {
public void methodOuter() {
int num = 10; // 所在方法的局部变量
class MyInner {
public void methodInner() {
System.out.println(num);
}
}
}
匿名内部类
-
匿名内部类的前提
- 匿名内部类必须继承一个父类或者实现一个父接口。这里的类可以是具体类也可以是抽象类
-
匿名内部类的格式
-
格式:
new 类名或接口名 ( ) { 重写方法 }
-
举例:
new Inter(){ @Override public void method(){} }
-
-
匿名内部类的本质
- 本质:是一个继承了该类或者实现了该接口的子类
-
匿名内部类的细节
- 匿名内部类可以通过多态的形式接受
Inter i = new Inter(){ @Override public void method(){ } }
-
匿名内部类直接调用方法
interface Inter{
void method();
}
class Test{
public static void main(String[] args){
new Inter(){
@Override
public void method(){
System.out.println("我是匿名内部类");
}
}.method(); // 直接调用方法
}
}
- 匿名内部类在开发中的使用(应用)
当发现某个方法需要,接口或抽象类的子类对象,我们就可以传递一个匿名内部类过去,来简化传统的代码 。
示例代码:
//跳高接口
public interface Jumpping {
void jump();
}
//接口操作类,里面有一个方法,方法的参数是接口名
public class JumppingOperator {
public void method(Jumpping j){
j.jump();
}
}
//测试类
public class JumppingDemo {
public static void main(String[] args) {
//需求:创建接口操作类的对象,调用method方法
JumppingOperator jo=new JumppingOperator();
Jumpping j=new Cat();
jo.method(j);
Jumpping j2=new Dog();
jo.method(j2);
System.out.println("-----------");
//匿名内部类简化
jo.method(new Jumpping() {
@Override
public void jump() {
System.out.println("猫可以跳高了");
}
});
//匿名内部类简化
jo.method(new Jumpping() {
@Override
public void jump() {
System.out.println("狗可以跳高了");
}
});
}
}