浅谈Java内部类——静态内部类

2024-11-29 15:50:35

　　今天来说说Java中的最后一种内部类——静态内部类

　　所谓的静态内部类，自然就是用static修饰的内部类，那用static修饰过后的内部类，跟一般的内部类相比有什么特别的地方呢？

　　首先，它是静态的，这就意味着它的创建不依赖于外部类，创建内部类的实例不需要像普通内部类一样先创建外部类实例才能创建。

　　其次，有优势必然有劣势，它不能像普通内部类一样无限制的访问外部类的方法和成员变量，只能访问静态成员变量和静态方法。

　　话不多说，先来看个栗子：

public class StaticInnerClass {

  //外部类的非静态成员
  private int numA = 1;

  //外部类的静态成员
  private static int numB = 2;

  //静态内部类
  static class Inner {
    //内部类的非静态成员
    private int numC = 3;
    //内部类的静态成员
    private static int numD = 4;

    public void printInner(){
      System.out.println("printInner");
      System.out.println(numB);//访问外部类的静态成员
      System.out.println(numC);//访问内部类的非静态成员
      System.out.println(numD);//访问内部类的静态成员
    }
  }

  //外部类的普通成员方法
  public void printOuter(){
    System.out.println("printOuter");
  }

  public static void main(String[] args) {
    StaticInnerClass outer = new StaticInnerClass();
    outer.printOuter();
    Inner inner = new StaticInnerClass.Inner();
    inner.printInner();
    System.out.println(StaticInnerClass.numB);
    System.out.println(Inner.numD);
  }
}

　　输出如下：

printOuter
printInner
2
3
4
2
4

　　看起来，内部类跟外部类的使用上是差不多的，更像是一个暂存在外部类中的一个类，跟外部类并没有什么太多本质上的联系，但是创建的时候需要使用Outer.Inner的方式来定义，就像给类加了一个命名空间一样。

　　再举个栗子来看看静态内部类和非静态内部类的区别：（知乎上看到的一段话，觉得比喻比较形象）

如果把类比喻成鸡蛋，内部类为蛋，,外部类是蛋壳。那么静态类相当于熟鸡蛋，就算蛋壳破碎（外部类没有实例化），蛋黄依然完好（内部类可以实例化）；而非静态类相当于生鸡蛋，蛋壳破碎（无实例化），蛋黄也会跟着xx（不能实例化）。

　　至于原因？其实就是因为非静态内部类中保存有外部类的指针，所以可以无限制访问外部类的所有属性，而静态内部类则没有，所以静态内部类无法访问外部类的非静态成员和方法，仅仅是借用一下它的壳而已。

　　再来看一个栗子：

public class Caculate {

  //定义一个pair类来将两个数捆绑
  static class Pair{
    private int first;
    private int second;

    public Pair(int first, int second) {
      this.first = first;
      this.second = second;
    }

    public int getFirst() {
      return first;
    }

    public int getSecond() {
      return second;
    }
  }

  //获取一个int数组中的最大和最小值
  public static Pair getMaxMin(int[] values){
    int max = Integer.MIN_VALUE;
    int min = Integer.MAX_VALUE;
    for (int i:values){
      if (min > i) min = i;
      if (max < i) max = i;
    }
    return new Pair(min,max);
  }

  public static void main(String[] args){
    int[] list = {1,3,5,2,77,23,25};
    Caculate.Pair pair = Caculate.getMaxMin(list);
    System.out.println(pair.getFirst());
    System.out.println(pair.getSecond());
    System.out.println(pair.first);
    System.out.println(pair.second);
  }
}

　　这里getMaxMin里需要一次返回两个值，所以用了一个Pair类来将两个数捆绑到一起，而因为这个类只在Caculate类中使用，而且两者并没有依赖关系，所以这里使用静态内部类是最合适的。

　　静态内部类还有很多适用的场景，这就需要大家在今后的使用中慢慢体会了。

　　至此，本篇讲解完毕，欢迎大家继续关注。

以上就是浅谈Java内部类——静态内部类的详细内容，更多关于Java 静态内部类的资料请关注我们其它相关文章！

Java单例模式实现静态内部类方法示例

Singleton是众多设计模式中最容易理解的一种,也是众多设计模式中较为重要的一种设计模式.接下来我们看看具体介绍. Singleton模式实现的重点在于将构造函数私有化(private),并通过提供静态公有函数(public synchronized static xxx getInstance)来获取定义在类中的静态私有成员(private static xxx instance),通过一个简单的判断静态实例是否为空来控制这个类只能够new一次,即控制了一个类只能有单个实例,一般的实现如下
Java编程中静态内部类与同步类的写法示例

java静态内部类将某个内部类定义为静态类,跟将其他类定义为静态类的方法基本相同,引用规则也基本一致.不过其细节方面仍然有很大的不同.具体来说,主要有如下几个地方要引起各位程序开发人员的注意. (一)一般情况下,如果一个内部类不是被定义成静态内部类,那么在定义成员变量或者成员方法的时候,是不能够被定义成静态成员变量与静态成员方法的.也就是说,在非静态内部类中不可以声明静态成员. (二)一般非静态外部类可以随意访问其外部类的成员变量以及方法(包括声明为private的方法),但是
Java静态内部类实现单例过程

这篇文章主要介绍了Java静态内部类实现单例过程,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下枚举实现单例线程安全,调用效率高,不能延时加载,可以天然的防止反射和反序列化调用 public enum SingletonFactory { //枚举元素本身就是单例 INSTANCE; //添加自己需要的操作 public SingletonObject getInstance(){ return new SingletonObject();
java 内部类（匿名类，匿名对象，静态内部类）详解及实例

内部类的介绍定义在另外一个类中的类,叫内部类成员内部类 1..new 创建成员内部类必须先创建外部类的实例,然后通过.new 创建内部类的对象 2..this 可以通过外部类的类名.this去访问外部类的所有属性和方法. public class Test1 { String name = "asnd"; public static void main(String[] args) { Test1 test1 = new Test1(); Inner mInner = test1.
深入浅析Java中Static Class及静态内部类和非静态内部类的不同

java中的类可以是static吗?答案是可以.在java中我们可以有静态实例变量.静态方法.静态块.类也可以是静态的. java允许我们在一个类里面定义静态类.比如内部类(nested class).把nested class封闭起来的类叫外部类.在java中,我们不能用static修饰顶级类(top level class).只有内部类可以为static. 静态内部类和非静态内部类之间到底有什么不同呢?下面是两者间主要的不同. (1)内部静态类不需要有指向外部类的引用.但非静态内部
Java内部类应用之静态内部类应用示例

本文实例讲述了Java内部类应用之静态内部类.分享给大家供大家参考,具体如下: 一点睛如果使用static来修饰一个内部类,则这个内部类就属于外部类本身,而不属于外部类的某个对象.因此使用static修饰的内部类被称为类内部类,也称为静态内部类. static关键字不可修饰外部类,但可修饰内部类. 二实战--静态内部类不能访问外部类的实例成员,只能访问外部类的类成员 1 点睛静态内部类可以包含静态成员,也可以包含非静态成员.根据静态成员不能访问非静态成员的规则,静态内部类不能访问外部类的
Java中的静态内部类详解及代码示例

1. 什么是静态内部类在Java中有静态代码块.静态变量.静态方法,当然也有静态类,但Java中的静态类只能是Java的内部类,也称为静态嵌套类.静态内部类的定义如下: public class OuterClass { static class StaticInnerClass { ... } } 在介绍静态内部类之前,首先要弄清楚静态内部类与Java其它内部类的区别. 2. 内部类什么是内部类?将一个类的定义放在另一个类的内部,就是内部类.Java的内部类主要分为成员内部类.局部内部类.
浅谈Java内部类——静态内部类

今天来说说Java中的最后一种内部类--静态内部类所谓的静态内部类,自然就是用static修饰的内部类,那用static修饰过后的内部类,跟一般的内部类相比有什么特别的地方呢? 首先,它是静态的,这就意味着它的创建不依赖于外部类,创建内部类的实例不需要像普通内部类一样先创建外部类实例才能创建. 其次,有优势必然有劣势,它不能像普通内部类一样无限制的访问外部类的方法和成员变量,只能访问静态成员变量和静态方法. 话不多说,先来看个栗子: public class StaticInnerClass
浅谈java 面对对象(抽象继承接口多态)

什么是继承? 多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要继承那个类即可. 多个类可以称为子类,单独这个类称为父类.超类或者基类. 子类可以直接访问父类中的非私有的属性和行为. 通过 extends 关键字让类与类之间产生继承关系. class SubDemo extends Demo{} //SubDemo是子类,Demo是父类继承有什么好处? •提高代码的复用性. •让类与类之间产生了关系,是多态的前提. 继承的特点 1.Java只支
浅谈Java面向对象之内部类

目录内部类访问外部对象访问内部对象局部内部类匿名内部类静态内部类内部类内部类是定义在另一个类中的类,例如 TalkingClock 类中内嵌了 TimePrinter 类: class TalkingClock{ private int interval; private boolean beep; public TalkingClock(int interval, boolean beep){} public void start(){} public class TimePr
浅谈Java中static和非static的区别

关于static和非static变量的区别 1. static 修饰的变量称为类变量或全局变量或成员变量,在类被加载的时候成员变量即被初始化,与类关联,只要类存在,static变量就存在.非static修饰的成员变量是在对象new出来的时候划分存储空间,是与具体的对象绑定的,该成员变量仅为当前对象所拥有的. 2. static修饰的变量在加载的时候先于main方法加载在内存中的数据共享区-------方法区,而非static的变量在加载的时候,是要创建变量才加载在堆内存中的. 3. 一个stat
浅谈Java中各种修饰符与访问修饰符的说明

JAVA中的类只能是public 或者package的.这是符合逻辑的:人们定义类的初衷就是为了让别人用的.倘若是private,别人怎么调用?但是有一个内部类可以被定义为private.严格上说,内部类,算不得上是一种光明正大的类,内部类在某种意义上是类这个王国里的特务和地下工作者.特务和地下工作者为王国起了不少作用,但是几乎从来不敢在公众场合抛投露面.就算要露面,也要在主人(class)的同意下,向导(Interface)的引导下,才敢战战兢兢的走出来.下面是常规的一些类的修饰符和访问修饰符
浅谈java Properties类的使用基础

Properties类继承自HashTable,通常和io流结合使用.它最突出的特点是将key/value作为配置属性写入到配置文件中以实现配置持久化,或从配置文件中读取这些属性.它的这些配置文件的规范后缀名为".properties".表示了一个持久的属性集. 需要注意几点: 无论是key还是value,都必须是String数据类型. 虽然继承自HashTable,但它却没有使用泛型. 虽然可以使用HashTable的put方法,但不建议使用它,而是应该使用setProperty()
浅谈Java中的class类

Class 类是在Java语言中定义一个特定类的实现.一个类的定义包含成员变量,成员方法,还有这个类实现的接口,以及这个类的父类.Class类的对象用于表示当前运行的 Java 应用程序中的类和接口. 比如:每个数组均属于一个 Class 类对象,所有具有相同元素类型和维数的数组共享一个Class 对象.基本的 Java 类型(boolean, byte, char, short,int, long, float 和 double) 和 void 类型也可表示为 Class 对象. 以下示例使用
浅谈Java中对类的主动引用和被动引用

本文研究的主要是Java中类的主动引用和被动引用,具体介绍如下. 主动引用,这里介绍的是主动引用的五种场景 1.遇到new,getstatic,putstatic,invokestatic这4条字节码指令时,类如果没初始化就会被初始化,创建对象,读取或设置静态字段,调用静态方法. 2.反射 3.子类初始化前会先初始化父类 4.包含main方法的类,虚拟机启动时会先初始化该类 5.使用jdk的动态语言支持时(不明) 被动引用: class SuperClass{ static{ syso("sup
浅谈java 单例模式DCL的缺陷及单例的正确写法

1 前言单例模式是我们经常使用的一种模式,一般来说很多资料都建议我们写成如下的模式: /** * Created by qiyei2015 on 2017/5/13. */ public class Instance { private String str = ""; private int a = 0; private static Instance ins = null; /** * 构造方法私有化 */ private Instance(){ str = "hell
浅谈JAVA并发之ReentrantLock

1. 介绍结合上面的ReentrantLock类图,ReentrantLock实现了Lock接口,它的内部类Sync继承自AQS,绝大部分使用AQS的子类需要自定义的方法存在Sync中.而ReentrantLock有公平与非公平的区别,即'是否先阻塞就先获取资源',它的主要实现就是FairSync与NonfairSync,后面会从源码角度看看它们的区别. 2. 源码剖析 Sync是ReentrantLock控制同步的基础.它的子类分为了公平与非公平.使用AQS的state代表获取锁的数量 ab

浅谈Java内部类——静态内部类

相关推荐

随机推荐