内部类
- 定义：在一个类中进行其他机构的嵌套
内部类的简单定义：
class Outer{
private String msg="Hello world!";
//定义一个内部类
class Inner{
//定义一个普通方法
public void print(){
//调用msg属性
System.out.println(msg);
}
}
//在外部类中定义一个方法，该方法负责产生内部类对象并且调用print()方法
public void fun(){
//内部类对象
Inner in=new Inner();
// 内部类提供的print()方法
in.print();
}
}
public class Test{
public static void main(String[] args) {
//外部类对象
Outer out=new Outer();
//外部类方法
out.fun();
}
}
// 打印结果如下
//Hello word!将内部类拆分到外部
class Outer{
private String msg = "Hello World!" ;
//通过此方法才能取得msg属性
public String getMsg(){
return this.msg ;
}
//3.现在由out对象调用了fun()方法
public void fun(){
//4.this表示当前对象
Inner in = new Inner(this);
//7.调用方法
in.print();
}
}
class Inner{
private Outer out;
//5.Inner.out = mian.out
public Inner(Outer out){
//6.引用传递
this.out = out ;
}
//8.执行此方法
public void print(){
System.out.println(out.getMsg());
}
}
public class Test{
public static void main(String[] args) {
//1. 实例化Outter类对象
Outer out = new Outer();
//2.调用Outter类方法
out.fun();
}
}内部类的优点：
-
内部类与外部类可以互相访问彼此的私有域（最大优点）
-
内部类可以实现Java的单继承局限
使用内部类实现多继承
class A{
private String name="A的私有类";
public String getName(){
return name;
}
}
class B{
private int age=20;
public int getAge(){
return age;
}
}
class Outter{
private class InnerClassA extends A{
public String name(){
return super.getName();
}
}
private class InnerClassB extends B{
public int age(){
return super.getAge();
}
}
public String name(){
return new InnerClassA().name();
}
public int age(){
return new InnerClassB().age();
}
}
public class Test{
public static void main(String[] args) {
Outter outter=new Outter();
System.out.println(outter.name());
System.out.println(outter.age());
}
}-
内部类可以对同一包中其他类隐藏起来，仅供外部类使用
内部类的缺点：结构复杂
内部类与外部类的关系
-
对于非静态内部类而言，内部类的创建需要依靠外部类的实例化对象，在没有外部类对象之前是无法创建内部类的
-
内部类是一个相对独立的个体，与外部类不是is - a 关系
-
内部类可以直接访问外部类的元素（包含私有域），但是外部类不可以直接访问内部类元素，需要通过内部类的引用间接访问。
内部类直接访问外部元素
class Outter{
private String outName;
private int outAge;
class Inner {
private int InnerAge;
public Inner() {
Outter.this.outName="I am Outter class";
Outter.this.outAge=20;
}
public void display(){
System.out.println(outName);
System.out.println(outAge);
}
}
}
public class Test{
public static void main(String[] args) {
Outter.Inner inner=new Outter().new Inner();
inner.display();
}
}外部类通过内部类间接引用访问内部类元素
class Outter{
public void display(){
//外部类访问内部元素，需要通过内部类引用访问
Inner inner=new Inner();
inner.display();
}
class Inner {
public void display(){
System.out.println("I am InnerClass");
}
}
}
public class Test{
public static void main(String[] args) {
Outter out=new Outter();
out.display();
}
}创建内部类的语法（在外部类的外部创建内部类） *** 灰常重要 ***
创建非静态内部类：
-
外部类 . 内部类 内部类引用 = new 外部类（）. new 内部类（）；
-
Outter . Inner in = new Outter( ) . new Inner( ) ; 创建内部类的对象
隐藏的对象 Outter . this 表示外部类对象
创建静态内部类
-
外部类 . 内部类 内部类引用 = new 外部类 . 内部类（）；
-
Outter . Inner in = new Outter . Inner（）； //直接产生内部类，没有外部类产生
内部类的分类 ***重要***
-
成员内部类 --- 成员方法
1 . 成员内部类不能存在任何static变量或方法，可以访问外部类的静态域，不用拥有静态属性
2 . 内部类可以使用private封装，表示私有内部类，该内部类仅供外部类使用（HashMap中Entry内部类，ArreyList的Node内部类） ***重要***
3 . 成员内部类必须依附外部类new Outter（）. new Inner（）；
-
静态内部类 --- 静态方法
1 . 静态内部类的创建不需要外部类，可以直接创建
2 . 静态内部类不可以访问外部类的任何非static域。
使用static创建内部类
class Outer{
private static String msg="Hello World!";
//定义一个内部类
static class Inner {
//此时只能使用外部类中的static操作
public void print(){
//调用msg属性
System.out.println(msg);
}
}
//在外部类中定义一个方法，该方法负责产生内部类对象并且调用print()方法
public void fun(){
//内部类对象
Inner in=new Inner();
//内部类提供的print()方法
in.print();
}
}
public class Test{
public static void main(String[] args) {
Outer.Inner in=new Outer.Inner();
in.print();
}
}-
方法内部类
-
匿名内部类