Java编程中静态内部类与同步类的写法示例

java静态内部类
将某个内部类定义为静态类,跟将其他类定义为静态类的方法基本相同,引用规则也基本一致。不过其细节方面仍然有很大的不同。具体来说,主要有如下几个地方要引起各位程序开发人员的注意。
    (一)一般情况下,如果一个内部类不是被定义成静态内部类,那么在定义成员变量或者成员方法的时候,是不能够被定义成静态成员变量与静态成员方法的。也就是说,在非静态内部类中不可以声明静态成员。
    (二)一般非静态外部类可以随意访问其外部类的成员变量以及方法(包括声明为private的方法),但是如果一个内部类被声明为static,则其在访问包括自身的外部类会有诸多的限制。静态内部类不能访问其外部类的非静态成员变量和方法。
    (三)在一个类中创建非静态成员内部类的时候,有一个强制性的规定,即内部类的实例一定要绑定在外部类的实例中。然后要在一个外部类中定义一个静态的内部类,不需要利用关键字new来创建内部类的实例。即在创建静态类内部对象时,不需要其外部类的对象。
    java在实现LinkedList时使用了如下内部类:

public class LinkedList<E>
  extends AbstractSequentialList<E>
  implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
  ........
  private static class Entry<E> {
E element;
Entry<E> next;
Entry<E> previous;
Entry(E element, Entry<E> next, Entry<E> previous) {
  this.element = element;
  this.next = next;
  this.previous = previous;
}
  }
  private Entry<E> addBefore(E e, Entry<E> entry) {
Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
newEntry.previous.next = newEntry;
newEntry.next.previous = newEntry;
size++;
modCount++;
return newEntry;
  }
  ........
}

这里即静态内部类的典型用法


java同步工具类

/**
 * 需要启动多个线程把接口数据分批导入目标,要求
 * 每次执行的时候必须保证前一次任务已结束,处理这个需求的方式有很多种,其实质即
 * 线程间同步问题,正好这两天我也在关注线程同步相关的东东,jdk提供了不少的线程
 * 同步工具类,CountDownLatch:一个同步辅助类,在完成一组正在其他线程中执行的
 * 操作之前,它允许一个或多个线程一直等待。
 * 用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法,所以在当前计数到达零之前,
 * await 方法会一直受阻塞。之后,会释放所有等待的线程,await 的所有后续调用都将立即返回。
 * 这种现象只出现一次——计数无法被重置(这点很重要哦)。如果需要重置计数,请考虑使用 CyclicBarrier。
 * 下面是一个简单的例子来模拟该需求,当然可能因为为了模拟场景,会有一些不合理的地方,这里主要阐述
 * CountDownLatch同步,关于CountDownLatch的源码将在后面来分析,其主要涉及AbstractQueuedSynchronizer
 * 这个类,他的类容相对比较复杂
 * **/ 

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.CountDownLatch; 

public class Driver {
 static List<Integer> strList = null;
 int k = 0;
 static {
 //模拟数据
 strList = new ArrayList<Integer>();
 for (int i = 0; i < 50; i++) {
  strList.add(i);
 }
 } 

 public static void main(String args[]) {
 boolean isEnd = true;
 //为了验证正确性,只执行20次
 int count=0;
 Driver d = new Driver();
 while (isEnd && strList.size() > 0&&count<20) {
  CountDownLatch startSignal = new CountDownLatch(1);
  final CountDownLatch doneSignal = new CountDownLatch(5);
  for (int i = 0; i < 5; ++i)
  {
  new Thread(d.new Worker(startSignal, doneSignal,i)).start();
  }
  //计数减1 子线程Worker可以执行
  startSignal.countDown();
  try {
  new Thread(new Runnable() {
   Random r = new Random();
   @Override
   public void run() {
   try {
    //主线程阻塞 知道所有子线程将doneSignal清零
    doneSignal.await();
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   while(strList.size()<=0){
    int pos = r.nextInt(1000);
    strList.clear();
    for (int i = pos; i < pos + 50; i++) {
    strList.add(i);
    }
   }
   }
  }).start();
  isEnd = true;
  } catch (Exception e) {
  e.printStackTrace();
  }
  count++;
 }
 } 

 class Worker implements Runnable {
 private final CountDownLatch startSignal;
 private final CountDownLatch doneSignal;
 private int i; 

 Worker(CountDownLatch startSignal, CountDownLatch doneSignal,int i) {
  this.startSignal = startSignal;
  this.doneSignal = doneSignal;
  this.i=i; 

 } 

 public void run() {
  try {
  // 等待主线程执行countDown
  startSignal.await();
  doWork();
  //计数减1
  doneSignal.countDown();
  } catch (InterruptedException ex) {
  } // return;
 } 

 void doWork() {
  synchronized (strList) {
  int start=(i)*(50/5);
  int end=(i+1)*(50/5);
  for (int i = start; i < end; i++) {
   System.out.println(strList.get(i) + "---" + "已被删除");
  }
  }
 }
 }
}
时间: 2015-09-20

Java中的静态内部类详解及代码示例

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

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单例模式实现静态内部类方法示例

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

java单例模式实现的方法

1.最基本的单例模式 /** * @author LearnAndGet * @time 2018年11月13日 * 最基本的单例模式 */public class SingletonV1 { private static SingletonV1 instance = new SingletonV1();; //构造函数私有化 private SingletonV1() {} public static SingletonV1 getInstance() { return instance; }

java引用jpython的方法示例

本文实例讲述了java引用jpython的方法.分享给大家供大家参考,具体如下: import java.util.ArrayList; import java.util.List; import org.python.core.PyException; import org.python.core.PyInteger; import org.python.core.PyObject; import org.python.util.PythonInterpreter; public class

java生成缩略图的方法示例

本文实例讲述了java生成缩略图的方法.分享给大家供大家参考,具体如下: package com.util; import java.awt.image.BufferedImage; import java.io.File; import java.io.IOException; import javax.imageio.ImageIO; /** * 生成压缩图 * */ public class ImageScale { private int width; private int heigh

Java使用反射调用方法示例

本文实例讲述了Java使用反射调用方法.分享给大家供大家参考,具体如下: 一 代码 import java.util.*; import java.io.*; import java.lang.reflect.*; public class ExtendedObjectPoolFactory { // 定义一个对象池,前面是对象名,后面是实际对象 private Map<String, Object> objectPool = new HashMap<>(); private Pr

thinkPHP框架实现类似java过滤器的简单方法示例

本文实例讲述了thinkPHP框架实现类似java过滤器的简单方法.分享给大家供大家参考,具体如下: 写java web代码的时候,可以定义过滤器,对控制器进行过滤,可以实现权限验证等等 在thinkphp中也可以通过继承父类的方法,实现类似的需求 父类代码 <?php /** * Created by PhpStorm. * User: xieyicheng * Date: 2014/12/11 * Time: 14:43 */ namespace Admin\Controller; use

Java编程倒计时实现方法示例

实现Java编程中倒计时的方法有许多,下面我们通过三个示例来简单了解下它的实现过程. 1.简易方式实现 /** * @see * @author Al_assad yulinying_1994@outlook.com * @date 2016年10月18日 上午3:10:13 * @version V1.0 * Description: 倒计时简易实现,只用单线程 */ import java.util.*; import java.util.concurrent.*; public class

Java私有构造器使用方法示例

构造器作为Java类的一个特殊的成员同样可以设置关键字来控制其访问权限.在大多数情况下,我们一般把构造器设置为公有成员,即public的,在默认情况下,如果不写任何关键字,其访问权限也是public.这样,在我们新建一个类的对象的时候,构造器会创建对象后被自动调用,发生在其他类成员被设置为默认初始值之后,当然如果有字段初始器和初始化块的话,构造器的调用会发生在此之后.构造器的主要作用是在new将对象的引用返回之前初始化对象. 言归正传,什么叫私有构造器.所谓私有构造器,就是用private关键字

java运行shell脚本方法示例

现在通过CommandHelper.execute方法可以执行命令,该类实现 复制代码 代码如下: package javaapplication3;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;/** * * @author chenshu */public class CommandHelper {    //default time out, in mill

java system类使用方法示例 获取系统信息

常用的方法: 复制代码 代码如下: long currentTimeMillis();  获取当前时间的毫秒值 void exit();终止当前正在运行的 Java 虚拟机. 复制代码 代码如下: public static void Method(){     long l = System.currentTimeMillis();     System.out.println(l); System.exit(); } 描述系统属性信息:Properties System.getPropert