文章目录
1,Java内部类分类
在 Java 中,可以将一个类定义在另一个类里面或者一个方法里面,这样的类称为内部类。根据内部类的修饰符和权限不同,可以将内部类分为静态内部类和非静态内部类。其中非静态内部类又有成员内部类,局部内部类和匿名类。
下面分别介绍这些内部类。
2,非静态内部类
非静态内部类中,包含成员内部类,局部内部类和匿名类。
2.1 成员内部类
成员内部类是最普通的内部类,它的定义位于另一个类的内部,格式如下:
class OuterClass { // 外部类
// ...
class InnerClass { // 嵌套类,或称为内部类
// ...
}
}
由于成员内部类看起来像是外部类的一个成员,所以可以像类的成员一样拥有多种权限修饰。成员内部类可以拥有 private、default、protected、public 访问权限。如果成员内部类用 private 修饰,则只能在外部类的内部访问,如果用 public 修饰,则任何地方都能访问;如果用 protected 修饰,则只能在同一个包下或者继承外部类的情况下访问;如果是默认访问权限,则只能在同一个包下访问。这一点和外部类有一点不一样,外部类只能被 public 和包访问两种权限修饰。
2.1.1 成员内部类的创建
成员内部类是依附外部类而存在的,也就是说,如果要创建成员内部类的对象,前提是必须存在一个外部类的对象。
class Out {
int x = 10;
class In {
int y = 5;
}
}
class Test {
public static void main(String[] args) {
Out out = new Out();
Out.In in = out.new In(); //ok
Out.In in2 = new Out().new In(); //it's ok
System.out.println(in.y + out.x);
}
}
如果一个内部类被private修饰,那它只能被外部类中的方法操作。
class Out {
private In in = null;
int x = 10;
private class In {
int y = 5;
}
public Inner getInnerInstance() {
if(in == null)
in = new In();
return in;
}
}
class Test {
public static void main(String[] args) {
Out out = new Out();
Out.In in = out.new In(); //error
}
}
2.1.2 内部类访问外部类的成员
成员内部类可以无条件访问外部类的所有成员属性和成员方法(包括private成员和静态成员)。
class Circle {
private double radius = 0;
public static int count =1;
public Circle(double radius) {
this.radius = radius;
}
class Draw { //内部类
public void drawSahpe() {
System.out.println(radius); //外部类的private成员
System.out.println(count); //外部类的静态成员
}
}
}
当成员内部类拥有和外部类同名的成员变量或者方法时,会发生隐藏现象,即默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员,需要以下面的形式进行访问:
外部类.this.成员变量
外部类.this.成员方法
class Out {
private int age = 12;
class In {
private int age = 13;
public void print() {
int age = 14;
System.out.println("局部变量:" + age);
System.out.println("内部类变量:" + this.age);
System.out.println("外部类变量:" + Out.this.age);
}
}
}
public class Demo {
public static void main(String[] args) {
Out.In in = new Out().new In();
in.print();
}
}
运行结果:
局部变量:14
内部类变量:13
外部类变量:12
2.1.3 外部类访问内部类成员
在外部类中如果要访问成员内部类的成员,必须先创建一个成员内部类的对象,再通过指向这个对象的引用来访问。
2.2 局部内部类
局部内部类是定义在一个方法或者一个作用域里面的类,它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。
class Out {
private int age = 12;
public void Print(final int x) {
class In {
public void inPrint() {
System.out.println(x);
System.out.println(age);
}
}
new In().inPrint();
}
}
public class Demo {
public static void main(String[] args) {
Out out = new Out();
out.Print(3);
}
}
- 注意: 局部内部类就像是方法里面的一个局部变量一样,是不能有 public、protected、private 以及 static 修饰符的。
2.3 匿名类
Java 中可以实现一个类中包含另外一个类,且不需要提供任何的类名直接实例化。
主要是用于在我们需要的时候创建一个对象来执行特定的任务,可以使代码更加简洁。
匿名类是不能有名字的类,它们不能被引用,只能在创建时用 new 语句来声明它们。
匿名类语法格式:
class outerClass {
// 定义一个匿名类
object1 = new Type(parameterList) {
// 匿名类代码
};
}
以上的代码创建了一个匿名类对象 object1,匿名类是表达式形式定义的,所以末尾以分号 ; 来结束。
匿名类通常继承一个父类或实现一个接口。
2.3.1 匿名类继承一个父类
以下实例中,创建了 Polygon 类,该类只有一个方法 display(),AnonymousDemo 类继承了 Polygon 类并重写了 Polygon 类的 display() 方法:
class Polygon {
public void display() {
System.out.println("在 Polygon 类内部");
}
}
class AnonymousDemo {
public void createClass() {
// 创建的匿名类继承了 Polygon 类
Polygon p1 = new Polygon() {
public void display() {
System.out.println("在匿名类内部。");
}
};
p1.display();
}
}
class Main {
public static void main(String[] args) {
AnonymousDemo an = new AnonymousDemo();
an.createClass();
}
}
执行以上代码,匿名类的对象 p1 会被创建,该对象会调用匿名类的 display() 方法,输出结果为:
在匿名类内部。
2.3.2 匿名类实现一个接口
以下实例创建的匿名类实现了 Polygon 接口:
interface Polygon {
public void display();
}
class AnonymousDemo {
public void createClass() {
// 匿名类实现一个接口
Polygon p1 = new Polygon() {
public void display() {
System.out.println("在匿名类内部。");
}
};
p1.display();
}
}
class Main {
public static void main(String[] args) {
AnonymousDemo an = new AnonymousDemo();
an.createClass();
}
}
输出结果为:
在匿名类内部。
- 注意:局部内部类和匿名内部类只能访问局部final变量
3,静态内部类
静态内部类是不需要依赖于外部类的,这点和类的静态成员属性有点类似,并且它不能使用外部类的非static成员变量或者方法。
public class Test {
public static void main(String[] args) {
Outter.Inner inner = new Outter.Inner();
}
}
class Outter {
public Outter() {
}
static class Inner {
public Inner() {
}
}
}
4,内部类的继承
最后补充一点知识:关于成员内部类的继承问题。一般来说,内部类是很少用来作为继承用的。但是当用来继承的话,要注意两点:
- 1)成员内部类的引用方式必须为 Outter.Inner
- 2)构造器中必须有指向外部类对象的引用,并通过这个引用调用super()。这段代码摘自《Java编程思想》
class WithInner {
class Inner{
}
}
class InheritInner extends WithInner.Inner {
// InheritInner() 是不能通过编译的,一定要加上形参
InheritInner(WithInner wi) {
wi.super(); //必须有这句调用
}
public static void main(String[] args) {
WithInner wi = new WithInner();
InheritInner obj = new InheritInner(wi);
}
}
5,内部类面试题
1.根据注释填写(1),(2),(3)处的代码
public class Test{
public static void main(String[] args){
// 初始化Bean1
(1)
bean1.I++;
// 初始化Bean2
(2)
bean2.J++;
//初始化Bean3
(3)
bean3.k++;
}
class Bean1{
public int I = 0;
}
static class Bean2{
public int J = 0;
}
}
class Bean{
class Bean3{
public int k = 0;
}
}
从前面可知,对于成员内部类,必须先产生外部类的实例化对象,才能产生内部类的实例化对象。而静态内部类不用产生外部类的实例化对象即可产生内部类的实例化对象。
创建静态内部类对象的一般形式为: 外部类类名.内部类类名 xxx = new 外部类类名.内部类类名()
创建成员内部类对象的一般形式为: 外部类类名.内部类类名 xxx = 外部类对象名.new 内部类类名()
因此,(1),(2),(3)处的代码分别为:
Test test = new Test();
Test.Bean1 bean1 = test.new Bean1();
Test.Bean2 b2 = new Test.Bean2();
Bean bean = new Bean();
Bean.Bean3 bean3 = bean.new Bean3();
2.下面这段代码的输出结果是什么?
public class Test {
public static void main(String[] args) {
Outter outter = new Outter();
outter.new Inner().print();
}
}
class Outter
{
private int a = 1;
class Inner {
private int a = 2;
public void print() {
int a = 3;
System.out.println("局部变量:" + a);
System.out.println("内部类变量:" + this.a);
System.out.println("外部类变量:" + Outter.this.a);
}
}
}
3
2
1