内部类
非静态内部类
-
内部类可以直接访问外部类的成员(public,private,protectd)
-
不能用static修饰
-
先实new一个外部类,才能new一个内部类
-
内部类可以使用 private 或 protected 来修饰,如果你不希望内部类被外部类访问可以使用 private 修饰符:
class OuterClass {
int x = 10;
class InnerClass {
int y = 5;
}
}
public class MyMainClass {
public static void main(String[] args) {
OuterClass myOuter = new OuterClass();
OuterClass.InnerClass myInner = myOuter.new InnerClass();
System.out.println(myInner.y + myOuter.x);
}
}
//该例子来自菜鸟网站
静态内部类
-
静态内部类可以使用 static 关键字定义,静态内部类我们不需要创建外部类来访问,可以直接访问它:
-
静态内部类无法访问外部类的成员。
class OuterClass {
int x = 10;
static class InnerClass {
int y = 5;
}
}
public class MyMainClass {
public static void main(String[] args) {
OuterClass.InnerClass myInner = new OuterClass.InnerClass();
System.out.println(myInner.y);
}
}//该例子来自菜鸟网站
局部内部类
- 指的是定义在一个方法中的内部类
- 局部内部类与局部变量一样,不能使用访问控制修饰符,局部内部类与局部变量一样,不能使用访问控制修饰符(public、private 和 protected)和 static 修饰符修饰。
- 局部内部类只在当前方法中有效。
- 局部内部类中不能定义 static 成员。
- 局部内部类中还可以包含内部类,但是这些内部类也不能使用访问控制修饰符(public、private 和 protected)和 static 修饰符修饰。
- 在局部内部类中可以访问外部类的所有成员。
- 在局部内部类中只可以访问当前方法中 final 类型的参数与变量。如果方法中的成员与外部类中的成员同名,则可以使用 .this. 的形式访问外部类中的成员。
public class Test {
int a = 0;
int d = 0;
public void method() {
int b = 0;
final int c = 0;
final int d = 10;
class Inner {
int a2 = a; // 访问外部类中的成员
// int b2 = b; // 编译出错
int c2 = c; // 访问方法中的成员
int d2 = d; // 访问方法中的成员
int d3 = Test.this.d; //访问外部类中的成员
}
Inner i = new Inner();
System.out.println(i.d2); // 输出10
System.out.println(i.d3); // 输出0
}
public static void main(String[] args) {
Test t = new Test();
t.method();
}
}
/*
该例子来自C语言中文网
*/
匿名类
- 匿名类和局部内部类一样,可以访问外部类的所有成员
- 如果匿名类位于一个方法中,则匿名类只能访问方法中 final 类型的局部变量和参数
package com.hyb.oop.D7;
import java.sql.SQLOutput;
class Person{
public void test(){
System.out.println("这是一个父类方法!");
}
}
public class Outner {
public static void main(String[] args) {
Outner outner = new Outner();
outner.method();
}
public int a=10;
private int b=100;
//外部类方法
public void method(){
//匿名类
//public int a=Outner.this.a;编译错误
final int a1=120;
Person person = new Person(){
//匿名类继承父类并重写其方法
final int a=Outner.this.a;
final int b=Outner.this.b;
@Override
public void test() {
System.out.println("重写父类方法!"+this.a+" "+a1+" "+this.b);
}
//如果匿名类位于一个方法中,则该类只能访问final修饰的成员
};
person.test();
}
/*
10
20
*/
}
//这里我遇到了一个问题,就是当匿名类的变量和匿名类所处的方法中的变量的时候,无论怎么调用,都是调用到匿名类里的变量,这是怎么回事?
使用内部类实现多重继承
package com.hyb.oop.D7;
//定义一个父类
public class Father {
public int strong1(){
return 9;
}
}
package com.hyb.oop.D7;
//母亲类
public class Mother {
public int strong2(){
return 10;
}
}
package com.hyb.oop.D7;
public class Son {
public static void main(String[] args) {
Son son = new Son();
System.out.println(son.method1());
System.out.println(son.method2());
/*
8
11
*/
}
public int method1(){
Father father = new Father() {
@Override
public int strong1() {
return super.strong1() - 1;
}
};
return father.strong1();
}
public int method2(){
Mother mother = new Mother() {
@Override
public int strong2() {
return super.strong2() + 1;
}
};
return mother.strong2();
}
}