内部类
内部类可以实现多继承的效果。
- 成员内部类
- 静态内部类
- 方法内部类
- 匿名内部类
成员内部类
成员内部类内部不允许存在任何static
变量或方法 正如成员方法中不能有任何静态属性 (成员方法与对象相关、静态属性与类有关)
成员内部类是依附外部类的,只有创建了外部类才能创建内部类。
class OuterClass {
int x = 10;
private class InnerClass {
int y = 5;
public void p(){
x++;//访问父类属性
}
}
}
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);
}
}
重名
见内部类与外部类关系
类.this.属性/方法 //类名为外部类或内部类
访问权限
内部类与外部类可以访问彼此的所有属性,方法(包括私有方法、私有属性)。
静态内部类
使用static修饰的内部类我们称之为静态内部类,静态内部类和非静态内部类之间存在一个最大的区别,非静态内部类在编译完成之后会隐含的保存着一个引用,该引用是指向创建它的外围类,但是静态类没有。没有这个引用就意味着:
- 静态内部类的创建不需要依赖外部类可以直接创建。
- 静态内部类不可以使用任何外部类的非static类(包括属性和方法),但可以有自己的成员变量。
public class A {
public String name = "test";
private static int age =20;
static class Inner{
private String name;
public void fun()
{
System.out.println(name);
System.out.println(age);
}
}
public static void main(String [] args)
{
A.Inner in = new A.Inner();
in.fun();
}
}
访问权限
内部类与外部类可以访问彼此的所有属性,方法(包括私有方法、私有属性)。
方法内部类
定义在方法里的类
-
方法内部类不允许使用访问权限修饰符(
public、private、protected
)均不允许。 -
方法内部类对外部完全隐藏,除了创建这个类的方法可以访问它以外,其他地方均不能访问
-
方法内部类如果想要使用方法形参,该形参必须使用final声明(
JDK8
形参变为隐式final声明)
public class A {
private int num =5;
//普通方法
public void dispaly(int temp)
{
//方法内部类即嵌套在方法里面
class Inner{
public void fun()
{
System.out.println(num);
//temp++; //Error
System.out.println(temp);// Fine
}
}
//方法内部类在方法里面创建
new Inner().fun();
}
public static void main(String[] args) {
A out = new A();
out.dispaly(2);
}
}
匿名内部类
匿名内部类就是一个没有名字的方法内部类,因此特点和方法与方法内部类完全一致,除此之外,还有自己的特点:
- 匿名内部类必须继承一个(或抽象)类或者实现一个接口。(创建实例写法)
- 匿名内部类没有类名,因此没有构造方法。
interface MyInterface {
//接口中方法没有方法体
void test();
}
public class A{
private int num = 5;
public void dispaly(int temp)
{
//匿名内部类,匿名的实现了MyInterface接口
// 接口单方法,可以写成lambada表达式
new MyInterface()
{
public void test()
{
System.out.println("匿名实现MyInterface接口");
System.out.println(temp);
}
}.test();
}
public static void main(String[] args)
{
A out = new A();
out.dispaly(3);
}
}
方法参数也可以
interface MyInterface {
void test();
}
abstract class Z1{
abstract public void p(MyInterface my);
}
public class A extends Z1{
private int num = 5;
public static void main(String[] args)
{
A out = new A();
out.dispaly(3);
out.p(() ->{
System.out.println("f");
});
}
@Override
public void p(MyInterface my) {
}
}
创建内部类对象
在外部类内创建
Inner in = new Inner();
在外部类外部 创建非静态内部类
需先创建外部类实例
语法: 外部类.内部类 内部类对象 = new 外部类().new 内部类();
举例: Outer.Inner in = new Outer().new Inner();
在外部类外部 创建静态内部类
语法: 外部类.内部类 内部类对象 = new 外部类.内部类();
举例: Outer.Inner in = new Outer.Inner();
内部类与外部类的关系
- 对于非静态的内部类,内部类的创建依赖外部类的实例对象,在没有外部类实例之前是无法创建内部类的。
- 内部类可以直接访问外部类的元素(包括私有域)外部类在内部类之前创建,创建内部类时会将外部类的对象传入
class Outer{
//成员变量 与对象有关
private String msg;
private int age;
//--------------------------
class Inner{
public void dispaly()
{
//此处有一个隐藏的Outer.this
msg = "test";
age = 20;
System.out.println(msg);
System.out.println(age);
}
}
//--------------------------
public void test()
{
Inner in = new Inner();
in.dispaly();
}
}
public class Test{
public static void main(String[] args)
{
Outer out = new Outer();
out.test();
}
}
- 外部类可以通过内部类的引用间接访问内部类元素 – -要想访问内部类属性,必须先创建内部类对象
class Outer{
public void dispaly()
{
//外部类通过创建内部类的对象间接访问内部类元素
Inner in = new Inner();
in.dispaly();
}
class Inner{
public void dispaly()
{
System.out.println("内部类");
}
}
}
public class Test1{
public static void main(String[] args)
{
Outer out = new Outer();
out.dispaly();
}
}
匿名类
见匿名内部类
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();
}
}