• Post Reply Bookmark Topic Watch Topic
  • New Topic
programming forums Java Mobile Certification Databases Caching Books Engineering Micro Controllers OS Languages Paradigms IDEs Build Tools Frameworks Application Servers Open Source This Site Careers Other Pie Elite all forums
this forum made possible by our volunteer staff, including ...
Marshals:
  • Campbell Ritchie
  • Tim Cooke
  • paul wheaton
  • Jeanne Boyarsky
  • Ron McLeod
Sheriffs:
  • Paul Clapham
  • Liutauras Vilda
  • Devaka Cooray
Saloon Keepers:
  • Tim Holloway
  • Roland Mueller
Bartenders:

Question about inheritance

 
Greenhorn
Posts: 11
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
Hi. I'm currently working on a final project for AP Computer Science 1 and have question about inheritance. If the superclass were to have try and catches, will the subclass inherit those characteristics? (Code provided below). If this is possible, could someone show me how to make

FilesoundFile = new File("C:\\WINNT\\Media\\notify.wav");

into a method or somehow other classes able to change this file root so different songs can be played through different classes. I could copy and paste this code to each class but I don't want to increase the size of the code.
Thank for helping me. I will provide you my final project in return for your help.


public class Sound
{
private static final intEXTERNAL_BUFFER_SIZE = 128000;



public static void main(String[] args)
{
/*
We check that there is exactely one command-line
argument.
If not, we display the usage message and exit.
*/

/*
Now, that we're shure there is an argument, we
take it as the filename of the soundfile
we want to play.
*/


FilesoundFile = new File("C:\\WINNT\\Media\\notify.wav");


/*
We have to read in the sound file.
*/
AudioInputStreamaudioInputStream = null;
try
{
audioInputStream = AudioSystem.getAudioInputStream(soundFile);
}
catch (Exception e)
{
/*
In case of an exception, we dump the exception
including the stack trace to the console output.
Then, we exit the program.
*/
e.printStackTrace();
System.exit(1);
}

/*
From the AudioInputStream, i.e. from the sound file,
we fetch information about the format of the
audio data.
These information include the sampling frequency,
the number of
channels and the size of the samples.
These information
are needed to ask Java Sound for a suitable output line
for this audio file.
*/
AudioFormataudioFormat = audioInputStream.getFormat();

/*
Asking for a line is a rather tricky thing.
We have to construct an Info object that specifies
the desired properties for the line.
First, we have to say which kind of line we want. The
possibilities are: SourceDataLine (for playback), Clip
(for repeated playback)and TargetDataLine (for
recording).
Here, we want to do normal playback, so we ask for
a SourceDataLine.
Then, we have to pass an AudioFormat object, so that
the Line knows which format the data passed to it
will have.
Furthermore, we can give Java Sound a hint about how
big the internal buffer for the line should be. This
isn't used here, signaling that we
don't care about the exact size. Java Sound will use
some default value for the buffer size.
*/
SourceDataLineline = null;
DataLine.Infoinfo = new DataLine.Info(SourceDataLine.class,
audioFormat);
try
{
line = (SourceDataLine) AudioSystem.getLine(info);

/*
The line is there, but it is not yet ready to
receive audio data. We have to open the line.
*/
line.open(audioFormat);
}
catch (LineUnavailableException e)
{
e.printStackTrace();
System.exit(1);
}
catch (Exception e)
{
e.printStackTrace();
System.exit(1);
}

/*
Still not enough. The line now can receive data,
but will not pass them on to the audio output device
(which means to your sound card). This has to be
activated.
*/
line.start();

/*
Ok, finally the line is prepared. Now comes the real
job: we have to write data to the line. We do this
in a loop. First, we read data from the
AudioInputStream to a buffer. Then, we write from
this buffer to the Line. This is done until the end
of the file is reached, which is detected by a
return value of -1 from the read method of the
AudioInputStream.
*/
intnBytesRead = 0;
byte[]abData = new byte[EXTERNAL_BUFFER_SIZE];
while (nBytesRead != -1)
{
try
{
nBytesRead = audioInputStream.read(abData, 0, abData.length);
}
catch (IOException e)
{
e.printStackTrace();
}
if (nBytesRead >= 0)
{
intnBytesWritten = line.write(abData, 0, nBytesRead);
}
}

/*
Wait until all data are played.
This is only necessary because of the bug noted below.
(If we do not wait, we would interrupt the playback by
prematurely closing the line and exiting the VM.)

Thanks to Margie Fitch for bringing me on the right
path to this solution.
*/
line.drain();

/*
All data are played. We can close the shop.
*/
line.close();

/*
There is a bug in the jdk1.3/1.4.
It prevents correct termination of the VM.
So we have to exit ourselves.
*/
System.exit(0);
}


private static void printUsageAndExit()
{
out("SimpleAudioPlayer: usage:");
out("\tjava SimpleAudioPlayer <soundfile>");
System.exit(1);
}


private static void out(String strMessage)
{
System.out.println(strMessage);
}
}
 
Ranch Hand
Posts: 118
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator

Originally posted by James Dark:
[If the superclass were to have try and catches, will the subclass inherit those characteristics?



Subclasses inherit non-private state and methods (which may encapsulate try/catch blocks), but not the try/catch blocks by themselves.
 
Greenhorn
Posts: 12
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
While, the first thing I would do is to create a method run() for the Sound class, move all the things you are doing in main(...) to run(), and then have main do "new Sound().run()".

Why? Cause now you have an object and can start taking advantage of Object-Oriented features.

Next, add a method


Next, change all the references to the above into something like:



Now, if someone wants to change the soundfile being played, they can extend your class, and override the one method
 
There is no beard big enough to make me comfortable enough with my masculinity to wear pink. Tiny ad:
We need your help - Coderanch server fundraiser
https://coderanch.com/wiki/782867/Coderanch-server-fundraiser
reply
    Bookmark Topic Watch Topic
  • New Topic