Java 错误：包括包

我想在命令提示符下运行java代码。获取错误：应为类接口或枚举。当java文件需要在命令提示符下运行时，在java文件中包含PackageClass文件的位置。。 我的java代码是：

import java.io.File;
import java.io.IOException;
import java.io.OutputStream;
import javax.sound.sampled.AudioFileFormat;
import javax.sound.sampled.AudioInputStream;
import java.org.xiph.speex.AudioFileWriter;
import org.xiph.speex.OggSpeexWriter;
import org.xiph.speex.PcmWaveWriter;
import java.org.xiph.speex.RawWriter;
import javax.sound.sampled.AudioFileWriter;



/**
 * Java Speex Command Line Encoder.
 * 
 * Currently this code has been updated to be compatible with release 1.0.3.
 * 
 * @author Marc Gimpel, Wimba S.A. (mgimpel@horizonwimba.com)
 * @version $Revision: 1.5 $
 */

    public  class JSpeexEnc
    {
  /** Version of the Speex Encoder */
  public static final String VERSION = "Java Speex Command Line Encoder v0.9.7 ($Revision: 1.5 $)";
  /** Copyright display String */
  public static final String COPYRIGHT = "Copyright (C) 2002-2004 Wimba S.A.";

  /** Print level for messages : Print debug information */
  public static final int DEBUG = 0;
  /** Print level for messages : Print basic information */
  public static final int INFO  = 1;
  /** Print level for messages : Print only warnings and errors */
  public static final int WARN  = 2;
  /** Print level for messages : Print only errors */
  public static final int ERROR = 3;
  /** Print level for messages */
  protected int printlevel = INFO;

  /** File format for input or output audio file: Raw */
  public static final int FILE_FORMAT_RAW  = 0;
  /** File format for input or output audio file: Ogg */
  public static final int FILE_FORMAT_OGG  = 1;
  /** File format for input or output audio file: Wave */
  public static final int FILE_FORMAT_WAVE = 2;
  /** Defines File format for input audio file (Raw, Ogg or Wave). */
  protected int srcFormat  = FILE_FORMAT_OGG;
  /** Defines File format for output audio file (Raw or Wave). */
  protected int destFormat = FILE_FORMAT_WAVE;

  /** Defines the encoder mode (0=NB, 1=WB and 2=UWB). */
  protected int mode       = -1;
  /** Defines the encoder quality setting (integer from 0 to 10). */
  protected int quality    = 8;
  /** Defines the encoders algorithmic complexity. */
  protected int complexity = 3;
  /** Defines the number of frames per speex packet. */
  protected int nframes    = 1;
  /** Defines the desired bitrate for the encoded audio. */
  protected int bitrate    = -1;
  /** Defines the sampling rate of the audio input. */
  protected int sampleRate = -1;
  /** Defines the number of channels of the audio input (1=mono, 2=stereo). */
  protected int channels   = 1;
  /** Defines the encoder VBR quality setting (float from 0 to 10). */
  protected float vbr_quality = -1;
  /** Defines whether or not to use VBR (Variable Bit Rate). */
  protected boolean vbr    = false;
  /** Defines whether or not to use VAD (Voice Activity Detection). */
  protected boolean vad    = false;
  /** Defines whether or not to use DTX (Discontinuous Transmission). */
  protected boolean dtx    = false;

  /** The audio input file */
  protected String srcFile;
  /** The audio output file */
  protected String destFile;

        public AudioFileFormat.Type[] getAudioFileTypes() {
        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
    }

    //@Override
    public AudioFileFormat.Type[] getAudioFileTypes(AudioInputStream stream) {
        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
    }

    //@Override
    public int write(AudioInputStream stream, AudioFileFormat.Type type, OutputStream out) throws IOException {
        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
    }

  //  @Override
    public int write(AudioInputStream stream, AudioFileFormat.Type type, File file) throws IOException {
        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
    }

  /**
   * Builds a plain JSpeex Encoder with default values.
   */





/**
 *
 * @author Administrator
 */

  /**
   * Command line entrance:
   * <pre>
   * Usage: JSpeexEnc [options] input_file output_file
   * </pre>
   * @param args Command line parameters.
   * @exception IOException
   */

    }

/**
 *
 * @author Administrator
 */
 public JSpeexEnc()
  {
}
    public static void main(final String[] args)
    throws IOException
  {
    JSpeexEnc encoder = new JSpeexEnc();
    if (encoder.parseArgs(args))
{
      encoder.encode();

  }
}


  public boolean parseArgs(final String[] args, String srcFile, String destFile, int complexity, int nframes, boolean vbr, boolean vad, boolean dtx, int sampleRate, int channels, int mode, int quality, float vbr_quality, boolean printlevel, boolean WARN)
  {
    // make sure we have command args
    if (args.length < 2) {
      if (args.length==1 && (args[0].equalsIgnoreCase("-v") || args[0].equalsIgnoreCase("--version"))) {
        version();
        return false;
      }
      usage();
      return false;
    }
    // Determine input, output and file formats
    srcFile = args[args.length-2];
    destFile = args[args.length-1];
    if (srcFile.toLowerCase().endsWith(".wav"))
    {
      srcFormat = FILE_FORMAT_WAVE;
    }
    else 
      {
      srcFormat = FILE_FORMAT_RAW;
    }
    if (destFile.toLowerCase().endsWith(".spx")) {
      destFormat = FILE_FORMAT_OGG;
    }
    else if (destFile.toLowerCase().endsWith(".wav")) {
      destFormat = FILE_FORMAT_WAVE;
    }
    else {
      destFormat = FILE_FORMAT_RAW;
    }
    // Determine encoder options
    for (int i=0; i<args.length-2; i++) {
      if (args[i].equalsIgnoreCase("-h") || args[i].equalsIgnoreCase("--help")) {
        usage();
        return false;
      }
      else if (args[i].equalsIgnoreCase("-v") || args[i].equalsIgnoreCase("--version")) {
        version();
        return false;
      }
      else if (args[i].equalsIgnoreCase("--verbose")) {

        printlevel = DEBUG;
      }
      else if (args[i].equalsIgnoreCase("--quiet")) {
        printlevel = WARN;
      }
      else if (args[i].equalsIgnoreCase("-n") || 
               args[i].equalsIgnoreCase("-nb") ||
               args[i].equalsIgnoreCase("--narrowband")) {
        mode = 0;
      }
      else if (args[i].equalsIgnoreCase("-w") ||
               args[i].equalsIgnoreCase("-wb") ||
               args[i].equalsIgnoreCase("--wideband")) {
        mode = 1;
      }
      else if (args[i].equalsIgnoreCase("-u") ||
               args[i].equalsIgnoreCase("-uwb") ||
               args[i].equalsIgnoreCase("--ultra-wideband")) {
        mode = 2;
      }
      else if (args[i].equalsIgnoreCase("-q") || args[i].equalsIgnoreCase("--quality")) {
        try {
          vbr_quality = Float.parseFloat(args[++i]);
          quality = (int) vbr_quality;
        }
        catch (NumberFormatException e) {
          usage();
          return false;
        }
      }
      else if (args[i].equalsIgnoreCase("-complexity")) {
        try {
          complexity = Integer.parseInt(args[++i]);
        }
        catch (NumberFormatException e) {
          usage();
          return false;
        }
      }
      else if (args[i].equalsIgnoreCase("--nframes")) {
        try {
          nframes = Integer.parseInt(args[++i]);
        }
        catch (NumberFormatException e) {
          usage();
          return false;
        }
      }
      else if (args[i].equalsIgnoreCase("--vbr")) {
        vbr = true;
      }
      else if (args[i].equalsIgnoreCase("--vad")) {
        vad = true;
      }
      else if (args[i].equalsIgnoreCase("--dtx")) {
        dtx = true;
      }
      else if (args[i].equalsIgnoreCase("--rate")) {
        try {
          sampleRate = Integer.parseInt(args[++i]);
        }
        catch (NumberFormatException e) {
          usage();
          return false;
        }
      }
      else if (args[i].equalsIgnoreCase("--stereo")) {
        channels = 2;
      }
      else {
        usage();
        return false;
      }
    }
    return true;
  }

  /**
   * Prints the usage guidelines.
   */
  public static void usage()
  {
    version();
    System.out.println("");
    System.out.println("Usage: JSpeexEnc [options] input_file output_file");
    System.out.println("Where:");
    System.out.println("  input_file can be:");
    System.out.println("    filename.wav  a PCM wav file");
    System.out.println("    filename.*    a raw PCM file (any extension other than .wav)");
    System.out.println("  output_file can be:");
    System.out.println("    filename.spx  an Ogg Speex file");
    System.out.println("    filename.wav  a Wave Speex file (beta!!!)");
    System.out.println("    filename.*    a raw Speex file");
    System.out.println("Options: -h, --help     This help");
    System.out.println("         -v, --version  Version information");
    System.out.println("         --verbose      Print detailed information");
    System.out.println("         --quiet        Print minimal information");
    System.out.println("         -n, -nb        Consider input as Narrowband (8kHz)");
    System.out.println("         -w, -wb        Consider input as Wideband (16kHz)");
    System.out.println("         -u, -uwb       Consider input as Ultra-Wideband (32kHz)");
    System.out.println("         --quality n    Encoding quality (0-10) default 8");
    System.out.println("         --complexity n Encoding complexity (0-10) default 3");
    System.out.println("         --nframes n    Number of frames per Ogg packet, default 1");
    System.out.println("         --vbr          Enable varible bit-rate (VBR)");
    System.out.println("         --vad          Enable voice activity detection (VAD)");
    System.out.println("         --dtx          Enable file based discontinuous transmission (DTX)");
    System.out.println("         if the input file is raw PCM (not a Wave file)");
    System.out.println("         --rate n       Sampling rate for raw input");
    System.out.println("         --stereo       Consider input as stereo");
    System.out.println("More information is available from: http://jspeex.sourceforge.net/");
    System.out.println("This code is a Java port of the Speex codec: http://www.speex.org/");
  }

  /**
   * Prints the version.
     * @param COPYRIGHT
   */
  public static void version(boolean COPYRIGHT)
  {
    System.out.println(VERSION);
    System.out.println("using " + SpeexEncoder.VERSION);

    System.out.println(COPYRIGHT);
  }

  /**
   * Encodes a PCM file to Speex. 
     * @param srcFile
   * @exception IOException
   */
  public void encode(String srcFile)
    throws IOException
  {
    encode(new File(srcFile), new File(destFile));
  }

  /**
   * Encodes a PCM file to Speex. 
   * @param srcPath
   * @param destPath
     * @param channels
     * @param sampleRate
   * @exception IOException
   */
  public void encode(final File srcPath, final File destPath, int channels, int sampleRate, boolean printlevel, boolean DEBUG, String vbr, int nframes, String vbr_quality)
    throws IOException
  {
    byte[] temp    = new byte[2560]; // stereo UWB requires one to read 2560b
    final int HEADERSIZE = 8;
    final String RIFF      = "RIFF";
    final String WAVE      = "WAVE";
    final String FORMAT    = "fmt ";
    final String DATA      = "data";
    final int WAVE_FORMAT_PCM = 0x0001;
    // Display info
    if (printlevel <= INFO) version();
    if (printlevel <= DEBUG) System.out.println("");
    if (printlevel <= DEBUG) System.out.println("Input File: " + srcPath);
    try (DataInputStream dis = new DataInputStream(new FileInputStream(srcPath))) {
        int mode;
        // Prepare input stream
        if (srcFormat == FILE_FORMAT_WAVE) {
            // read the WAVE header
            dis.readFully(temp, 0, HEADERSIZE+4);
            // make sure its a WAVE header
            if (!RIFF.equals(new String(temp, 0, 4)) &&
                    !WAVE.equals(new String(temp, 8, 4))) {
                System.err.println("Not a WAVE file");
                return;
            }
            // Read other header chunks
            dis.readFully(temp, 0, HEADERSIZE);
            String chunk = new String(temp, 0, 4);
            int size = readInt(temp, 4);
            while (!chunk.equals(DATA)) {
                dis.readFully(temp, 0, size);
                if (chunk.equals(FORMAT)) {
                    /*
                    typedef struct waveformat_extended_tag {
                    WORD wFormatTag; // format type
                    WORD nChannels; // number of channels (i.e. mono, stereo...)
                    DWORD nSamplesPerSec; // sample rate
                    DWORD nAvgBytesPerSec; // for buffer estimation
                    WORD nBlockAlign; // block size of data
                    WORD wBitsPerSample; // Number of bits per sample of mono data
                    WORD cbSize; // The count in bytes of the extra size
                    } WAVEFORMATEX;
                    */
                    if (readShort(temp, 0) != WAVE_FORMAT_PCM) {
                        System.err.println("Not a PCM file");
                        return;
                    }
                    channels = readShort(temp, 2);
                    sampleRate = readInt(temp, 4);
                    if (readShort(temp, 14) != 16) {
                        System.err.println("Not a 16 bit file " + readShort(temp, 18));
                        return;
                    }
                    // Display audio info
                    if (printlevel <= DEBUG) {
                        System.out.println("File Format: PCM wave");
                        System.out.println("Sample Rate: " + sampleRate);
                        System.out.println("Channels: " + channels);
                    }
                }
                dis.readFully(temp, 0, HEADERSIZE);
                chunk = new String(temp, 0, 4);
                size = readInt(temp, 4);
            }
            if (printlevel <= DEBUG) System.out.println("Data size: " + size);
        }
        else {
            if (sampleRate < 0) {
                switch (mode) {
                    case 0:
                        sampleRate = 8000;
                        break;
                    case 1:
                        sampleRate = 16000;
                        break;
                    case 2:
                        sampleRate = 32000;
                        break;
                    default:
                        sampleRate = 8000;
                        break;
                }
            }
            // Display audio info
            if (printlevel <= DEBUG) {
                System.out.println("File format: Raw audio");
                System.out.println("Sample rate: " + sampleRate);
                System.out.println("Channels: " + channels);
                System.out.println("Data size: " + srcPath.length());
            }
        }

        // Set the mode if it has not yet been determined
        if (mode < 0) {
            if (sampleRate < 100) // Sample Rate has probably been given in kHz
                sampleRate *= 1000;
            if (sampleRate < 12000)
                mode = 0; // Narrowband
            else if (sampleRate < 24000)
                mode = 1; // Wideband
            else
                mode = 2; // Ultra-wideband
        }
        // Construct a new encoder
        SpeexEncoder speexEncoder = new SpeexEncoder();
        speexEncoder.init(mode, quality, sampleRate, channels);
        if (complexity > 0) {
            speexEncoder.getEncoder().setComplexity(complexity);
        }
        if (bitrate > 0) {
            speexEncoder.getEncoder().setBitRate(bitrate);
        }
        if (vbr) {
            speexEncoder.getEncoder().setVbr(vbr);
            if (vbr_quality > 0) {
                speexEncoder.getEncoder().setVbrQuality(vbr_quality);
            }
        }
        if (vad) {
            speexEncoder.getEncoder().setVad(vad);
        }
        if (dtx) {
            speexEncoder.getEncoder().setDtx(dtx);
        }

        // Display info
        if (printlevel <= DEBUG) {
            System.out.println("");
            System.out.println("Output File: " + destPath);
            System.out.println("File format: Ogg Speex");
            System.out.println("Encoder mode: " + (mode==0 ? "Narrowband" : (mode==1 ? "Wideband" : "UltraWideband")));
            System.out.println("Quality: " + (vbr ? vbr_quality : quality));
            System.out.println("Complexity: " + complexity);
            System.out.println("Frames per packet: " + nframes);
            System.out.println("Varible bitrate: " + vbr);
            System.out.println("Voice activity detection: " + vad);
            System.out.println("Discontinouous Transmission: " + dtx);
        }
        // Open the file writer
        AudioFileWriter writer;
        if (destFormat == FILE_FORMAT_OGG) {
            writer = new OggSpeexWriter(mode, sampleRate, channels, nframes, vbr);
        }
        else if (destFormat == FILE_FORMAT_WAVE) {
            nframes = PcmWaveWriter.WAVE_FRAME_SIZES[mode-1][channels-1][quality];
            writer = new PcmWaveWriter(mode, quality, sampleRate, channels, nframes, vbr);
        }
        else {
            writer = new RawWriter();
        }
        writer.open(destPath);
        writer.writeHeader("Encoded with: " + VERSION);
        int pcmPacketSize = 2 * channels * speexEncoder.getFrameSize();
        while (true) {
            dis.readFully(temp, 0, nframes*pcmPacketSize);
            for (int i=0; i<nframes; i++)
                speexEncoder.processData(temp, i*pcmPacketSize, pcmPacketSize);
            int encsize = speexEncoder.getProcessedData(temp, 0);
            if (encsize > 0) {
                writer.writePacket(temp, 0, encsize);
            }
        }
        writer.close();
    }
  }

  /**
   * Converts Little Endian (Windows) bytes to an int (Java uses Big Endian).
   * @param data the data to read.
   * @param offset the offset from which to start reading.
   * @return the integer value of the reassembled bytes.
   */
  protected static int readInt(final byte[] data, final int offset)
  {
    return (data[offset] & 0xff) |
           ((data[offset+1] & 0xff) <<  8) |
           ((data[offset+2] & 0xff) << 16) |
           (data[offset+3] << 24); // no 0xff on the last one to keep the sign
  }

  /**
   * Converts Little Endian (Windows) bytes to an short (Java uses Big Endian).
   * @param data the data to read.
   * @param offset the offset from which to start reading.
   * @return the integer value of the reassembled bytes.
   */
  protected static int readShort(final byte[] data, final int offset)
  {
    return (data[offset] & 0xff) |
           (data[offset+1] << 8); // no 0xff on the last one to keep the sign
  }
}

---

我建议从简单和基础开始学习。这是您的第三个问题@Abimaran Kugathasan先生，为了学习，首先我需要知道如果需要在命令提示符下运行，如何在java中包含包的编码。举个小例子，可能头先java就足够了。要知道如何在Java中包含jar文件中的另一个包，一个简单的示例就足够了。不需要有1000行代码的程序。