Title: Java 6
Author: Arthur Griffith
SKU: 33858
ISBN: 1-934743-59-3
Release Date: 2008-02-29
Duration: 7 hrs / 92 lessons
Captions: Available on CD and Online University
Compatibility: Vista/XP/2000, OS X, Linux
QuickTime 7, Flash 8
Title Description:
Introduction
The Contents of This Course (03:29)
A Briefing on Java 6 (06:19)
Java Types (06:04)
Constructors (03:39)
Static (03:23)
Import (05:12)
Swing Components
Main Window (07:26)
The Box Layout Manager (06:27)
XY Layout (03:12)
Dialogs (05:00)
Choosing Files (05:16)
Choosing Colors (04:57)
Check Boxes & Radio Buttons (04:18)
Text Fields & Areas (04:59)
Combo Box (03:03)
Tables (05:58)
Progress Bar (05:55)
Sliders & Spinners (05:55)
Icons (03:54)
User Interface
Menu (03:50)
Components in a Menu (04:15)
The Look & Feel (04:07)
Tool Bars (03:55)
Tool Bars & Menus (02:51)
Tool Tips (02:17)
Generics
Introduction to Generics (05:41)
Types/Methods/Unbound (03:31)
Parametric Binding (04:14)
Wildcards & Nesting (04:30)
Collections
Collection Frameworks (03:06)
Collection Interfaces (05:39)
Simple Collection Examples (03:34)
The Set Collections (03:52)
Comparitor (03:20)
The Map Collections (04:53)
The Queue Collections (06:20)
Copying Collections (03:30)
Concurrency (04:47)
Deployment
Building a JAR File (04:39)
Configuring a JAR File (03:34)
Signing a JAR File (05:09)
Web Start Applications (04:46)
Annotation (04:30)
The java.lang Package
Fundamental Language Classes (03:43)
java.lang.annotation (02:52)
java.lang.instrument (06:20)
java.lang.ref (03:41)
java.lang.reflect (04:08)
java.lang.management (06:40)
The java.util Package
java.util.zip (05:49)
java.util.jar (05:14)
java.util.logging Pt.1 (04:10)
java.util.logging Pt.2 (07:26)
java.util.regex (06:11)
java.util.prefs (04:39)
A few special activities
Timers (06:04)
Assistive technologies (03:43)
Keyboard Access (07:36)
Printing Text (03:58)
Printing Graphics (06:15)
Printing Components (03:41)
A Splash Screen (07:21)
The System Tray (04:43)
The Browser & Email (04:28)
Unicode/UTF/ASCII (05:41)
Internationalization (07:01)
Enum (05:16)
Calendar & Clock Arithmetic (06:24)
Annotation Examples (04:32)
Concurrency
A Thread Object (04:07)
A Runnable Object (04:41)
Interference & Synchronizing (03:21)
Synchronizing & Locking (04:08)
Interrupts & Joins (03:48)
Starvation/Deadlock/Livelock (04:19)
Volatile & Atomic (02:55)
An Immutable Class (03:08)
Networking
Reading From a URL (04:20)
Internet Communications (06:07)
A TCP Client & Server Pt.1 (03:52)
A TCP Client & Server Pt.2 (03:48)
A UDP Client & Server Pt.1 (03:52)
A UDP Client & Server Pt.2 (04:29)
I/O
Streams (04:57)
Serialization (03:47)
The Console Class (04:06)
The File Class (04:34)
NIO (05:29)
Wrapup
Gotcha Pt.1 (03:48 )
Gotcha Pt.2 (04:33)
Wrapup (02:55)
Credits
About this Author (02:34)
Megaupload:
Part1
Part2
Part3
RapidShare:
Part1
Part2
Part3
Join files by HJSplit
Read more ...
Author: David Hughes
Paperback: 525 pages
Publisher: Jones and Bartlett Publishers, Inc.; 1 edition (November 25, 2002)
Language: English
ISBN-10: 0763717614
ISBN-13: 978-0763717612
Format: pdf
Details:
Our decision to use Java was based on a number of factors. First, we recognized Java as a pure object-oriented language, as opposed to C++, which is a hybrid, and thus does not allow the programmer to fall back into procedural habits. Further, it has a relatively clear and common syntax that can be understood without having to learn a large class hierarchy. Finally, Java has compilers available on a great many platforms that are inexpensive, not overly resource hungry, and the code is platform-independent. All of these things make Java ideal for a first university course.
Megaupload
Rapidshare Read more ...
Title: Java: Introduction to the Java Programming Language
Author: Arthur Griffith
SKU: 33459
ISBN: 1932072578
Release Date: 2003-10-10
Duration: 8 hrs / 92 lessons
Work Files: Yes
Captions: No
Compatibility: Vista/XP/2000, OS X, Linux
QuickTime 7, Flash 8
Title Description:
Introduction
Course Introduction (03:13)
What is Java? (05:44)
What You Will Need (04:08 )
A Few Important Words (03:34)
The Command Line Installation (05:31)
Course Overview (04:10)
Two Programs Named Howdy
The Source Code of Howdy (05:21)
Compiling and Running Howdy (02:58)
The Source Code of a Howdy Window (04:05)
Compiling and Running Howdy Window (02:24)
Adding Exits to Howdy Window (03:25)
Drawing Text in a Window
Font Anatomy (04:02)
Positioning Text Version pt. 1 (05:29)
Positioning Text Version pt. 2 (06:06)
Positioning Text Version pt. 3 (04:35)
Garbage Collection (03:47)
Selecting Fonts (05:33)
Selecting Colors (07:03)
A Few Language Fundamentals
The Arithmetic Data Types (06:03)
More Fundamental Data Types (03:43)
Operators (06:40)
The String Class (06:05)
Arrays (03:28)
If and Conditionals (04:53)
Looping (05:20)
Listing Fonts (03:44)
Classes, Data, and Access
Methods/Arguments/Returns (03:31)
Fundamental Inheritance (05:50)
The Sun Documentation (07:52)
The Creation of an Object (04:00)
More About Constructors (03:52)
Access (04:58 )
Drawing and Painting
Drawing Rectangles (03:54)
Filling Rectangles (03:50)
Drawing and Filling Circles (03:37)
The Rounded Rectangle (05:54)
Drawing and Filling Arcs (04:34)
Inventing a Shape of Your Own (04:26)
Rectangle with a Beveled Edge (06:10)
Simple Color Shading (03:57)
The Checkerboard and Shading Problems (05:27)
Two Checkerboard and Shading Solutions (06:33)
Graphic Files
Loading a Graphic File from Disk (05:03)
Displaying a Graphic Image (04:52)
Loading a Graphic File from the Internet (04:07)
Scaling Images (04:27)
Drawing in Memory (05:01)
Picture Checkerboard Problem (03:17)
Picture Checkerboard Solution (04:41)
Simple Animation
Threads (04:44)
A Simple Thread Example (04:34)
A Simple Animation (06:46)
Overcoming the Flicker Problem (05:01)
Pong Program One (05:56)
Pong Program Two (06:46)
The Switch and Case Statement (05:22)
The Doomed Vessel (05:39)
Introduction to Applets
Applet Fundmentals (05:51)
The Constructor and Init (05:10)
An Applet is a Creature of the Internet (03:57)
Creating a Production Applet (04:41)
Animated Applet Structure (03:52)
One Bouncing Ball (05:54)
Random (04:06)
One Hundred Bouncing Balls (06:39)
The Autumn Leaves Applet (07:11)
Responding to the Mouse
Java Interfaces (07:21)
A Simple Mouse Clicker (04:59)
Moving an Object in a Window (03:53)
Dragging an Object in a Window (05:43)
Dragging a Returning Object in a Window (03:55)
Components
Components and the AWT (04:37)
Placing Buttons in Panel (04:44)
Listening to Buttons in a Panel (03:56)
Poking Text into a Label (03:54)
A Choice is for Making a Selection (05:00)
A List is for Making a Selections (06:28 )
A Text Field is for Typing (05:23)
Toggles Turn On and Off (06:00)
Placing Components in a Window
Containers and Layout Managers (05:53)
The Border Layout Manager (04:28 )
The Grid Layout Manager (03:40)
The GridBag Layout Manager pt. 1 (04:58 )
The GridBag Layout Manager pt. 2 (04:12)
The Card Layout Manager (04:25)
The XY Layout Manager (06:55)
Dialogs and Menus
A Non-Modal Dialog (03:48 )
A Modal Dialog (05:10)
A Messaging Dialog (07:26)
A Menu on a Frame (06:59)
Wrap Up
Command Line Options for Javac (05:18 )
Command Line Options for Java (04:55)
http://rapidshare.com/files/123774628/v.T.c.J.Intron.2.the.J.Progg.Langg-virTuAlZin.part1.rar
http://rapidshare.com/files/123759558/v.T.c.J.Intron.2.the.J.Progg.Langg-v
Free download here:http://depositfiles.com/en/files/3128075
We'll start by writing the MIDlet and a Form that will display the system properties related to MMA capabilities, as shown in Listing 1. Use your favorite editor (Notepad will also suffice) to edit the code. Remember to save files under
Listing 1. Our main MIDlet class: MobileVideoApp
package com.srijeeb.jme;
import javax.microedition.lcdui.*;
import javax.microedition.media.*;
import javax.microedition.midlet.MIDlet;
public class MobileVideoApp extends MIDlet {
private Display display;
private PropertyForm form;
public MobileVideoApp() {
form = new PropertyForm("Mobile Video App",this);
}
public void startApp() {
display = Display.getDisplay(this);
display.setCurrent(form);
}
public void pauseApp() {
}
public void destroyApp(boolean unconditional) {
}
public Display getDisplay() {
return display;
}
}
I won't be explaining such methods as startApp(), pauseApp(), or destroyApp(), because these are generic for any MIDlet application, and they require no special attention for writing our example mobile media application. PropertyForm is a class that we have extended from the javax.microedition.lcdui.Form class. Listing 2 shows PropertyForm's important sections.
Listing 2. PropertyForm code for displaying MMA-specific properties
package com.srijeeb.jme;
import javax.microedition.lcdui.*;
import javax.microedition.media.*;
public class PropertyForm extends Form
implements CommandListener {
private final static Command CMD_EXIT =
new Command("Exit", Command.EXIT, 1);
private MobileVideoApp parentMidlet = null;
protected PropertyForm(String in, MobileVideoApp parentMidlet_) {
super(in);
this.parentMidlet = parentMidlet_;
initComponents();
}
public void initComponents() {
append(JMEUtility.getImage("/images/banner.png"));
append(JMEUtility.getImage("/images/separator.png"));
append(getStringItem("version", "microedition.media.version"));
append(JMEUtility.getImage("/images/separator.png"));
append(getStringItem("Audio Capture", "supports.audio.capture"));
append(JMEUtility.getImage("/images/separator.png"));
append(getStringItem("Video Capture", "supports.video.capture"));
append(JMEUtility.getImage("/images/separator.png"));
append(getStringItem("Recording", "supports.recording"));
append(JMEUtility.getImage("/images/separator.png"));
append(getStringItem("Audio Enc", "audio.encodings"));
append(JMEUtility.getImage("/images/separator.png"));
append(getStringItem("Video Enc", "video.encodings"));
append(JMEUtility.getImage("/images/separator.png"));
append(getStringItem("Video Snp Enc", "video.snapshot.encodings"));
append(JMEUtility.getImage("/images/separator.png"));
append(getStringItem("Stream Cont", "streamable.contents"));
append(JMEUtility.getImage("/images/separator.png"));
append(JMEUtility.getImage("/images/separator.png"));
append(getSupportedProtocols());
append(JMEUtility.getImage("/images/separator.png"));
append(getSupportedContentTypeForHttp());
addCommand(CMD_EXIT);
setCommandListener(this);
}
private StringItem getStringItem(String name, String propertyName) {
String value = System.getProperty(propertyName);
return new StringItem("[" + name + "]", value);
}
private StringItem getSupportedProtocols() {
return new StringItem("[Protocols]",
concatArray(Manager.getSupportedProtocols(null)) );
}
private StringItem getSupportedContentTypeForHttp() {
return new StringItem("[Content http]",
concatArray(Manager.getSupportedContentTypes("http")) );
}
public void commandAction(Command c, Displayable d) {
if (c == CMD_EXIT) {
parentMidlet.destroyApp(true);
parentMidlet.notifyDestroyed();
}
}
public String concatArray(String[] list) {
String ret = "";
if ( list != null && list.length > 0 ) {
for ( int i=0; i < list.length; i++ ) {
ret += list[i];
if ( i < (list.length-1)) {
ret += "|";
}
}
}
return ret;
}
}
You will have noticed the use of the JMEUtility class in Listing 2. This is a small class that I have written to perform some utility tasks -- loading images, showing error messages and so on. It's not that important in the context of our article; you can find out more by examining JMEUtility.java, which is part of the source code supplied with this article. For the time being, assume that once we call JMEUtility.getImage(String), it loads the image mentioned in the parameter and caches it. The next time the same method call occurs, it returns the same image from the cache. (The reasons for caching the image have to do with design patterns and best practices for mobile application development, and are outside the scope of this article.)
Our main intention in Listing 2 is to retrieve the MMA-related properties from the device and display them in a form. Effectively, if we call System.getProperty(propertyName), the mobile device should return the value for the particular property passed in the parameter. For example, if we call System.getProperty("supports.recording"), it will return a value of true for the Nokia 3230.
The important property names related to MMAPI are as follows:
microedition.media.version: The version of the MMAPI specification that is implemented.supports.audio.capture: Is audio capture supported? The string returned is eithertrueorfalse.supports.video.capture: Is video capture supported? The string returned is eithertrueorfalse.supports.recording: Is recording supported? The string returned is eithertrueorfalse.audio.encodings: The string returned specifies the supported audio-capture formats.video.encodings: The string returned specifies the supported video-capture formats.video.snapshot.encodings: The string returned specifies the video snapshot formats for thegetSnapshot()method inVideoControl.streamable.contents: The string returned specifies the supported streamable content types.
You may encounter some confusion when trying to reconcile some of the property values mentioned above with what you observe on a real device. For example: the Nokia 3230 and the Nokia 6600 both return true for both the supports.video.capture and the supports.recording properties. So it seems that both devices will support video recording. But there is a catch. If supports.recording returns true, you can record media using at least one player type -- at least one, but not necessarily all. The Nokia 6600 supports the recording of audio, but not the recording of video. But the Nokia 3230 also supports video recording.
You might also have noticed two other method calls in Listing 2: getSupportedProtocols() and getSupportedContentTypeForHttp(). Let's take a look at these in more detail.
Inside the getSupportedProtocol() method, we have queried the Manager class (javax.microedition.media.Manager) to return the protocols it can handle to retrieve media. A Manager.getSupportedProtocols(null) call will return all the supported protocols by the manager. The actual method call looks like this:
public static java.lang.String[] getSupportedProtocols(java.lang.String content_type)
Here, if the given content type is video/mpeg, then the supported protocols that can be used to play back MPEG video will be returned. If null is passed in as the content type, all the supported protocols for this implementation will be returned.
Inside the getSupportedContentTypeForHttp() method, we have queried the Manager class to return the supported content types it can handle for the HTTP protocol. The Manager.getSupportedContentTypes("http") call will return all the supported content types that can be delivered over the HTTP protocol to the player created by this Manager. The actual method call looks like this:
public static java.lang.String[] getSupportedContentTypes(java.lang.String protocol)
For example, if the given protocol is http, then the supported content types that can be played back with the HTTP protocol will be returned.
Now it's time to compile and test our code snippet using the Wireless Toolkit. But before doing so, if you are creating and coding the example from scratch (that is, if you have not downloaded the source supplied with this article), then you need to copy two images (banner.png and separator.png) from the supplied source and put them into the
Many mobile phones today support the Mobile Media API (MMAPI) under JSR-135. Using MMAPI, you can easily develop robust and useful Java mobile video applications. In this two-part article, JavaWorld contributor Srijeeb Roy shows you how to develop and test a mobile video application using JSR-135. In Part 1 you will learn how to capture and record video content using JME (Java Micro Edition). In Part 2 you will learn how to store your video content on a server using the Generic Connection Framework (GCF) over the HTTP protocol.
Multimedia processing using MMAPI can be considered in two parts:
- Data delivery protocol handling
- Data content handling
Data delivery protocol handling involves reading data from a source (from a capture device or a file, for instance) into a media-processing system. Data content handling involves processing the media data (that is, parsing or decoding it) and rendering the media to an output device -- to a video display, for example.
MMAPI provides two high-level classes to help you with these tasks. The javax.microedition.media.protocol.DataSource class deals with data delivery protocol handling, and the javax.microedition.media.Player interface deals with data content handling. To help the developer, a Manager class (javax.microedition.media.Manager) creates Players from DataSources, locators, and InputStreams.
Before you continue to the hands-on portion of this article, you should download and install a JDK version 1.5 or later (1.6 or later if you're using Windows Vista) and the Sun Java Wireless Toolkit. I used Sun Java Wireless Toolkit 2.5.1 for CLDC Early Access while writing this article.
Once you've installed these packages, open the Wireless Toolkit. You will see a screen that looks like the one below.
Figure 1. Sun Java Wireless Toolkit first screen
Now click the New Project icon or choose File -> New Project. In the New Project pop-up menu, enter MobileVideoApp as the a project name and com.srijeeb.jme.MobileVideoApp as the MIDlet class name, as shown in Figure 2. Alternately, you can unzip the source code supplied along with this article in the
Figure 2. Creating a new project
Once you click Create Project, a window will pop up where you can edit the project settings. You need to change the settings on the API Selection page to match our target platform. Change the Target Platform drop-down option to JTWI. Make sure that the profile is set to MIDP 2.0 and the configuration is checked as CLDC 1.0. Also, make sure the Mobile Media API (JSR 135) checkbox is checked in the Optional area. The screen will look like Figure 3. Click OK to move on.
Figure 3. API Selection screen
Determining the MMAPI-related features supported by a mobile device
Before going further, it is worth mentioning that not all Java-enabled mobile devices support JSR-135, and a few that do support it don't support video recording. To help you discover the features of a mobile device related to media processing, MMAPI has provided few system properties that you can query using the System.getProperty() method.
Let's begin by trying to determine the features that the mobile device we'll be executing our code on supports. For this example, I will compare results from two mobile handsets: the Nokia 3230 and the Nokia 6600. The specifications for both mobile phones claim that they support JSR-135.
