Java内部类

最新推荐文章于 2024-10-28 23:25:49 发布

XiaYuBao吖

最新推荐文章于 2024-10-28 23:25:49 发布

阅读量118

点赞数

CC 4.0 BY-SA版权

分类专栏： JavaSE

本文链接：https://blog.youkuaiyun.com/xiayubao7788/article/details/99231182

JavaSE 专栏收录该内容

34 篇文章

订阅专栏

1.内部类的概述

可以将一个类的定义放在另一个类的内部，这就是内部类。

//这是外部类，外部类是相对与内部类而言
class Outer {
  //dosomething
  
  class Inner { //内部类
      //dosomething
  }
}

2.内部类的访问特点

内部类可以直接访问外部类的成员，包括私有
外部类要访问内部类的成员，必须创建对象
格式：外部类名.内部类名对象名=外部类对象.内部类对象

class Demo {
 public static void main(String[] args) {
     //创建内部类对象
     Outer.Inner i = new Outer().new Inner();
     i.method();
 }
}

//这是外部类，外部类是相对与内部类而言
class Outer {

 class Inner { //内部类
     public void method() {
         System.out.println("我是内部类");
     }
 }
}
输出：我是内部类

3.为什么使用内部类

每个内部类都能独立的继承一个（接口的）实现，所以无论是外部类是否已经继承了某个（接口的）实现，对于内部类都没有影响。
内部类可以有多个实例，每个实例都有自己的状态信息，并且与其他外部对象的信息相互独立。
内部类并没有令人迷惑的is a的概念，内部类就是一个独立的实体。
内部类提供了更好的封装，除了所属的外部类，其他类都不能访问
创建内部类对象的时刻并不依赖于外部类对象的创建。


// 1. Outer类继承了ClassA，实现了IFunctionA
public class Outer extends ClassA implements IFunctionA{ 

	//Inner类继承了ClassB，实现了IFunctionB
	public class Inner extends ClassB implements IfunctionB{
	
	} 
}

4.内部类的分类

普通内部类、静态内部类、匿名内部类、局部内部类
在这里插入图片描述

5.成员内部类私有使用

成员内部类前可以用任何的访问修饰符
内部类的内部不能有静态信息
内部类也是类，可以继承、重写、重载、this和super随便用
外部类要访问内部类信息，必须new之后打点访问（理解不？？？哈哈哈）
内部类可以直接使用外部类的任何信息，如果属性或者方法发生冲突，调用外部类使用this.name或this.properties;

class Demo {
  public static void main(String[] args) {
      Outer o=new Outer();
      o.print();
  }
}

//这是外部类，外部类是相对与内部类而言
class Outer {
  private int a = 10;

  public void print() {
      Inner i = new Inner();
      i.method();
  }

  private class Inner { //内部类
      public void method() {
          System.out.println("我是内部类" + a);
      }
  }
}

6.静态成员内部类

静态内部类可以包含任何信息，不管是静态的还是非静态的
静态内部类的方法只能访问外部类的static关联的信息
利用Outer.Inner oi = new Outer.Inner();然后引用.成员信息（属性、方法）
访问内部类的静态信息，直接外部类.内部类.静态信息
静态内部类可以独立存在，不依赖其他外部类

class Demo {
 public static void main(String[] args) {
     Outer.Inner oi = new Outer.Inner();
     oi.method();

 }
}

//这是外部类，外部类是相对与内部类而言
class Outer {
 private int a = 10;

 static class Inner { //内部类
     public void method() {
         System.out.println("我是内部类");
     }
 }
}

访问静态内部中的静态方法

class Demo {
 public static void main(String[] args) {
     Outer.Inner oi = new Outer.Inner();
     oi.method();
     Outer.Inner2.print();
 }
}

//这是外部类，外部类是相对与内部类而言
class Outer {
 private int a = 10;

 static class Inner { //内部类
     public void method() {
         System.out.println("我是内部类");
     }
 }
 static class Inner2{
   public static void print(){
   System.out.println("我是静态内部类的静态方法");
   }
  }
}

7.局部内部类访问局部变量的问题

局部内部类定义前不能有修饰符
局部内部类只能在所属方法内使用
局部内部类无法创建静态信息
局部内部类可以访问所属方法中的局部变量和参数（直接被final修饰的变量），但是不能修改。
可以随意的访问外部类的任何信息。

class Demo {
public static void main(String[] args) {
    Outer o = new Outer();
    o.method();
}
}

class Outer {
private  int b=20;
public void method() {
    final int a=10;
    //局部内部类，类前不能有访问修饰符
    class Inner {
        public void print() {
            System.out.println("我是局部内部类"+a+"----"+b);
        }
    }
//局部内部类，只能在其所属的方法中访问
    Inner i = new Inner();
    i.print();
}
}

8.匿名内部类

匿名内部类是没有访问修饰符的
使用匿名内部类时，这个new之后的类首先是要存在的，其次我们要重写new后的类的某个或某些方法。
匿名内部类访问方法参数时也有和局部内部类同样的限制。
*匿名内部类没有构造方法。

/*
* 匿名内部类：就是内部类的简化写法
* 前提：存在一个类或者接口
* 格式：
*   new 类名或接口名(){
*      重写方法
*    }
* 本质：是一个继承该类或实现了该接口的子类匿名对象
* */

class demo{
   public static void main(String[] args) {
       Outer o=new Outer();
       o.method();
   }
}

interface Inter {
 public void print();
}

class Outer {
 class Inner implements Inter {
     public void print() {
         System.out.println("重写Inter的print方法");
     }
 }

 public void method() {
     //Inner i = new Inner();
     //i.print();

     new Inter() { //实现Inter接口
         //重写抽象方法
         public void print() {
             System.out.println("匿名内部类的使用");
         }
     }.print();
 }
}

输出：匿名内部类的使用

匿名内部类重写多个方法调用

class demo {
public static void main(String[] args) {
    Outer o = new Outer();
    o.method();
}
}

interface Inter {
public void show1();

public void show2();
}

class Outer {

public void method() {
    new Inter() { //实现Inter接口
        //重写抽象方法
        public void show1() {
            System.out.println("show1的使用");
        }

        public void show2() {
            System.out.println("show2的使用");
        }
    }.show1();
}
}

输出：show1的使用，调用哪个就输出哪个