服务器之家

服务器之家 > 正文

整理java读书笔记十五之java中的内部类

时间:2020-03-06 19:53     来源/作者:mrr

内部类是指在一个外部类的内部再定义一个类。类名不需要和文件夹相同。
*内部类可以是静态static的,也可用public,default,protected和private修饰。(而外部顶级类即类名和文件名相同的只能使用public和default)。

前言

 Java从JDK1.1的时候,就开始引入内部类的概念了,那么小编也通过这篇博客来分享一下Java中有关内部类的一些特性。

 什么是内部类?

 在很多情况下,类被定义成一个独立的程序单元,但是有时候也会把一个类放在另一个类的内部定义,这个定义在其他类内部的类就称为内部类。

从语法上来看的话,定义内部类和定义外部类的语法大致相同,内部类除了需要定义在其他类里面之外,还存在如下两点区别。

 1.内部类比外部类多使用三个修饰符:private——protected、static——外部类不可以使用这三个修饰符。

 2.非静态内部类不能拥有静态成员。

 除了以上两点之外,其他的地方都与普通的类相同,下面来列举一下常见的内部类操作。

  非静态内部类

  定义内部类也非常简单,只要把一个类放在另一个类内部定义即可,甚至都可以放置在方法的内部。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
<span style="font-family:Comic Sans MS;font-size:18px;">package com.test;
public class Cow
{
  private double weight;
  // 外部类的两个重载的构造器
  public Cow(){}
  public Cow(double weight)
  {
    this.weight = weight;
  }
  // 定义一个非静态内部类
  private class CowLeg
  {
    // 非静态内部类的两个实例变量
    private double length;
    private String color;
    // 非静态内部类的两个重载的构造器
    public CowLeg(){}
    public CowLeg(double length , String color)
    {
      this.length = length;
      this.color = color;
    }
    // 下面省略length、color的setter和getter方法
    public void setLength(double length)
    {
      this.length = length;
    }
    public double getLength()
    {
      return this.length;
    }
    public void setColor(String color)
    {
      this.color = color;
    }
    public String getColor()
    {
      return this.color;
    }
    // 非静态内部类的实例方法
    public void info()
    {
      System.out.println("当前牛腿颜色是:"
        + color + ", 高:" + length);
      // 直接访问外部类的private修饰的成员变量
      System.out.println("本牛腿所在奶牛重:" + weight);  //①
    }
  }
  public void test()
  {
    CowLeg cl = new CowLeg(1.12 , "黑白相间");
    cl.info();
  }
  public static void main(String[] args)
  {
    Cow cow = new Cow(378.9);
    cow.test();
  }
}
</span>

 在上述中非静态内部类的成员可以访问外部类的private成员,但反过来就不成立了。非静态内部类的成员只在非静态内部类范围内是可知的,并不能被外部类直接使用。如果外部类需要访问非静态内部类的成员,则必须显式创建非静态内部类对象来调用访问其实例成员。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
<span style="font-family:Comic Sans MS;font-size:18px;">package com.test;
public class Outer
{
  private int outProp = 9;
  class Inner
  {
    private int inProp = 5;
    public void acessOuterProp()
    {
      // 非静态内部类可以直接访问外部类的private成员变量
      System.out.println("外部类的outProp值:"
        + outProp);
    }
  }
  public void accessInnerProp()
  {
    // 外部类不能直接访问非静态内部类的实例变量,
    // 下面代码出现编译错误
    // System.out.println("内部类的inProp值:" + inProp);
    // 如需访问内部类的实例变量,必须显式创建内部类对象
    System.out.println("内部类的inProp值:"
      + new Inner().inProp);
  }
  public static void main(String[] args)
  {
    // 执行下面代码,只创建了外部类对象,还未创建内部类对象
    Outer out = new Outer();   //①
    out.accessInnerProp();
  }
}
</span>

 注意:非静态内部类中不能有静态方法、静态成员变量、静态初始化块。

 静态内部类

 如果使用static来修饰一个内部类,则这个内部类就属于外部类本身,而不属于外部类的某个对象,因此使用static修饰的内部类被称为类内部类,有的地方也称为静态内部类。静态内部类可以包含静态成员,也可以包含非静态成员。根据静态成员不能访问非静态成员的规则,静态内部类不能访问外部类的实例成员,只能访问外部类的类成员。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<span style="font-family:Comic Sans MS;font-size:18px;">package com.test;
public class StaticInnerClassTest
{
  private int prop1 = 5;
  private static int prop2 = 9;
  static class StaticInnerClass
  {
    // 静态内部类里可以包含静态成员
    private static int age;
    public void accessOuterProp()
    {
      // 下面代码出现错误:
      // 静态内部类无法访问外部类的实例变量
      System.out.println(prop1);
      // 下面代码正常
      System.out.println(prop2);
    }
  }
}
</span>

 匿名内部类

 使用匿名内部类可以创建那种只需要一次使用的类,并且创建匿名内部类时会立即创建一个该类的实例,但是也需要注意一下规则

 1.匿名内部类不能是抽象类,因为系统在创建匿名内部类时,会立即创建匿名内部类的对象,因此不允许将匿名内部类定义成为抽象类

 2.匿名内部类不能定义构造器,由于匿名内部类没有类名,所以无法定义构造器 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
<span style="font-family:Comic Sans MS;font-size:18px;">package com.test;
interface Product
{
  public double getPrice();
  public String getName();
}
public class AnonymousTest
{
  public void test(Product p)
  {
    System.out.println("购买了一个" + p.getName()
      + ",花掉了" + p.getPrice());
  }
  public static void main(String[] args)
  {
    AnonymousTest ta = new AnonymousTest();
    // 调用test()方法时,需要传入一个Product参数,
    // 此处传入其匿名实现类的实例
    ta.test(new Product()
    {
      public double getPrice()
      {
        return 567.8;
      }
      public String getName()
      {
        return "AGP显卡";
      }
    });
  }
}
</span>

下面给大家总结以下内部类的共性编辑

(1)、内部类仍然是一个独立的类,在编译之后内部类会被编译成独立的.class文件,但是前面冠以外部类的类名和$符号 。
(2)、内部类不能用普通的方式访问。内部类是外部类的一个成员,因此内部类可以自由地访问外部类的成员变量,无论是否是private的 。
(3)、内部类声明成静态的,就不能随便的访问外部类的成员变量了,此时内部类只能访问外部类的静态成员变量 。

标签:

相关文章

热门资讯

玄元剑仙肉身有什么用 玄元剑仙肉身境界等级划分
玄元剑仙肉身有什么用 玄元剑仙肉身境界等级划分 2019-06-21
男生常说24816是什么意思?女生说13579是什么意思?
男生常说24816是什么意思?女生说13579是什么意思? 2019-09-17
沙雕群名称大全2019精选 今年最火的微信群名沙雕有创意
沙雕群名称大全2019精选 今年最火的微信群名沙雕有创意 2019-07-07
超A是什么意思 你好a表达的是什么
超A是什么意思 你好a表达的是什么 2019-06-06
华为nova5pro和p30pro哪个好 华为nova5pro和华为p30pro对比详情
华为nova5pro和p30pro哪个好 华为nova5pro和华为p30pro对比详情 2019-06-22
返回顶部