MagPortal.com   Clustify - document clustering
 Home  |  Newsletter  |  My Articles  |  My Account  |  Help 
Similar Articles
JavaWorld
October 2001
Jeff Friesen
Object-oriented language basics, Part 7 This final installment of Java 101's object-oriented programming series explores Java's support for polymorphism and investigates how abstract classes accommodate generalities in class hierarchies. mark for My Articles similar articles
JavaWorld
October 2001
Java 101 study hall Brush up on Java terms, learn tips and cautions, and enter the first Java 101 reader challenge mark for My Articles similar articles
JavaWorld
August 2001
Jeff Friesen
Object-oriented language basics, Part 5 Every Java class has a superclass. In the absence of an extends keyword, Object is that superclass. Object takes center stage as this article presents its 11 methods... mark for My Articles similar articles
JavaWorld
November 2001
Jeff Friesen
Class and object initialization An exploration of class and object initialization, which introduces the strange concepts of the <clinit> and <init> methods... mark for My Articles similar articles
JavaWorld
May 2001
Jeff Friesen
Object-oriented language basics, Part 2 In this article, you'll gain an understanding about fields, parameters, and local variables and learn to declare and access fields and methods... mark for My Articles similar articles
JavaWorld
April 2001
Geoff Friesen
Object-oriented language basics, Part 1 An introduction to object-oriented programming and how to declare classes and create objects from those classes... mark for My Articles similar articles
JavaWorld
February 2002
Jeff Friesen
Classes within classes As with fields and methods, Java allows classes to be members of other classes. This article explores Java's support for class nesting... mark for My Articles similar articles
JavaWorld
September 2002
Jeff Friesen
Packages organize classes and interfaces Professional Java developers organize frequently used classes and interfaces in class libraries for later reuse. Learn what constitutes a package, how to create a package of classes and interfaces, how to import packaged classes and interfaces into a program, and more. mark for My Articles similar articles
JavaWorld
January 2001
Wm. Paul Rogers
Thanks type and gentle class Confusing the concepts of object and class deserves an askance look. Failing to distinguish between type and class, however, typically goes unnoticed. Yet the battle to separate implementation and interface concerns requires type-oriented thinking... mark for My Articles similar articles
JavaWorld
June 2001
Jeff Friesen
Object-oriented language basics, Part 3 The author explores composition and demonstrates its value in object-oriented programming. Composition and inheritance are design consepts related in a manner similar to both sides of the same coin... mark for My Articles similar articles
JavaWorld
May 2, 2003
Jeff Friesen
Datastructures and algorithms, Part 1 After presenting basic datastructure and algorithm concepts, this article focuses on the array datastructure and associated algorithms. The article concludes with the assertion that Java's arrays are objects. mark for My Articles similar articles
JavaWorld
July 2001
Jeff Friesen
Object-oriented language basics, Part 4 The author shows how to use inheritance to create layered objects, and compares and contrasts inheritance with composition... mark for My Articles similar articles
JavaWorld
December 2001
Jeff Friesen
Trash talk, Part 1 One feature that distinguishes Java from other computer languages is its garbage collection abilities. In this article, This article introduces garbage collection and shows how Java's optional support for it affects your programs... mark for My Articles similar articles
JavaWorld
August 1, 2003
Allen Holub
Why extends is evil Improve your code by replacing concrete base classes with interfaces mark for My Articles similar articles
JavaWorld
October 2002
Jeff Friesen
Java's character and assorted string classes support text-processing Text-processing is one of the more frequent activities in which computer programs engage. Java supports that activity via the Character, String, StringBuffer, and StringTokenizer classes. This article explores each class and introduces you to an assortment of those classes' methods. mark for My Articles similar articles
JavaWorld
July 2000
Jacob Weintraub
Learn how to store data in objects In this second installment of Java 101, Jacob Weintraub delves into storing data in Java and the various ways you can use that data. Specifically, he examines how objects store data and how you can pass data to objects in method calls... mark for My Articles similar articles
JavaWorld
October 3, 2003
Dawid Weiss
Discover new dimensions of scripted Java This article presents an extension to BeanShell that turns scripts into real Java classes that support inheritance, Java reflection, method overriding, and so on. The extension is designed to be fully transparent to the Java application using it. mark for My Articles similar articles
JavaWorld
November 2000
Geoff Friesen
Applications, applets, and hybrids This article establishes our bearings and sets sail to the land of applications, applets, and hybrids (an unusual category of Java programs)... mark for My Articles similar articles
JavaWorld
June 13, 2003
Jeff Friesen
Datastructures and algorithms, Part 2 This article concludes a two-part series that explores two important computer science topics: datastructures and algorithms. mark for My Articles similar articles
JavaWorld
September 2000
Bruce Eckel
Everything is an object, Part 1 This two-part article, excerpted from Chapter 2 in Thinking in Java 2nd. ed., moves you to the point where you can write your first Java program. Bruce Eckel gives an overview of the essentials... mark for My Articles similar articles
JavaWorld
April 2001
Piet Jonas
Secure type-safe collections A framework that overcomes the standard Java Collections Framework's main problem: its containers lack the ability to restrict themselves to storing objects of a specific type. The solution uses reflection, wrapper classes, and a collection of static factory methods... mark for My Articles similar articles
JavaWorld
February 2002
Anders Eliasson
Implement Design by Contract for Java using dynamic proxies The Design by Contract (DBC) theory can dramatically raise software quality and reusability levels by forcing you to think in terms of contracts. Contracts formally specify the responsibility relationship between a client (class user) and a supplier (class). Additionally, DBC clearly separates specification (what) from implementation (how). This article explains DBC's importance in object-oriented development and describes a DBCProxy framework that achieves DBC transparently in Java using dynamic proxy classes. mark for My Articles similar articles
JavaWorld
August 2002
Guy Gur-Ari
Empower RMI with TRMI Transparent Remote Method Invocation (TRMI) extends RMI to simplify the creation of distributed applications by allowing centralized RemoteException handling and by allowing any interface to be used remotely. This article tours TRMI's inner workings. mark for My Articles similar articles
JavaWorld
September 2001
Wm. Paul Rogers
Maximize flexibility with interfaces and abstract classes Most introductory Java texts take an implementation-centric stab at how to use interfaces and abstract classes. However, few provide a clear design distinction for choosing between these two similar object-oriented constructs... mark for My Articles similar articles
JavaWorld
March 2002
Jeff Friesen
Exceptions to the programming rules, Part 1 Learn about exceptions and how to handle them in C, C++, and Java. Learning how to handle exceptions in various languages gives you an appreciation for why exception handling works the way it does in Java... mark for My Articles similar articles
JavaWorld
August 2001
Bill W. Davis
Dynamically extend Java applications Do you want to write programs that can be extended without source code changes? The techniques described in this article show you how to use interfaces and dynamic class loading to create highly extensible systems... mark for My Articles similar articles
JavaWorld
October 2000
Robert Nielsen
Understanding constructors To learn Java, you must understand constructors. Because constructors share some characteristics with methods, it is easy for the Java beginner to confuse them. However, constructors and methods have important differences... mark for My Articles similar articles
JavaWorld
February 2003
Laurence Vanhelsuwe
Unwrap the package statement's potential The package statement is a very powerful Java language feature. Yet most Java programmers, even experienced ones, fail to correctly exploit this power. Intrigued? Read on and see how a simple language feature can have massive repercussions downstream. mark for My Articles similar articles
JavaWorld
February 2002
David Geary
Take control with the Proxy design pattern The Proxy design pattern in Java lets you substitute a proxy for an object. In that capacity, proxies prove useful in many situations, ranging from Web services to Swing icons... mark for My Articles similar articles
JavaWorld
February 2001
Geoff Friesen
Non-object-oriented language basics, Part 3 This exploration of Java's non-object-oriented language entities wraps up with a tour of statements. It provides an in-depth discussion on those source code constructs and demonstrates their proper use through a large example program... mark for My Articles similar articles
JavaWorld
December 2001
David Geary
Decorate your Java code The Decorator design pattern lets you attach responsibilities to objects at runtime. This pattern proves more flexible than inheritance, which is static... mark for My Articles similar articles
JavaWorld
July 2001
Michael Cymerman
Device programming with MIDP, Part 3 This article explores the methods of communication between the MIDlet and the world at large. Using the APIs contained in Java 2, Micro Edition's Mobile Information Device Profile (MIDP), developers can interact with external systems... mark for My Articles similar articles
JavaWorld
February 2001
Oliver Enseling
iContract: Design by Contract in Java The Design by Contract technique stresses the importance of explicitly specifying the constraints that hold before and after a software component executes. The iContract Java language extension implements Design by Contract for Java. mark for My Articles similar articles
JavaWorld
November 2001
Letters to the Editor Should you enable assertions in a production system? What's the difference between Jxta and Jini? Do access modifiers prevent inheritance? Is MVC a design pattern? mark for My Articles similar articles
JavaWorld
February 2001
Brian Goetz
Design for performance, Part 2: Reduce object creation Many common Java performance problems stem from class design decisions made early in the design process, long before most developers even start thinking about performance. The author discusses some techniques for reducing temporary object creation... mark for My Articles similar articles
JavaWorld
March 2002
James Carman
Write once, persist anywhere Most J2EE applications strive to abstract the database tier by employing the Data Access Object design pattern. This article shows you a DAO pattern framework that you can reuse on all your projects, regardless of object type... mark for My Articles similar articles
JavaWorld
July 2000
Todd M. Greanier
Flatten your objects The Java Serialization API is used by many other Java APIs (like RMI and JavaBeans) to persist objects beyond the duration of a running virtual machine. This article tries to demystify the secrets of the Java Serialization API. mark for My Articles similar articles
JavaWorld
July 25, 2003
David Geary
Make your apps fly Allocating numerous objects can degrade your application's performance. This article shows how to implement the Flyweight design pattern to greatly reduce the number of objects your application creates, which decreases your app's memory footprint and increases performance. mark for My Articles similar articles
JavaWorld
June 13, 2003
Camerlengo & Johnson
Make the Java-Oracle9i connection This article provides Java programmers with techniques for utilizing Oracle9i's new object-oriented features such as inheritance, custom constructors, dynamic dispatch, array descriptors, and mapping strategies from a Java class hierarchy to an Oracle type hierarchy without using traditional object-relational (O/R) mapping strategies. mark for My Articles similar articles
JavaWorld
November 2001
Michael C. Daconta
Practice makes perfect One pitfall stumbled on while porting an Extensible User Interface Language (XUL) game to Java and two pitfalls sent in by readers... mark for My Articles similar articles
JavaWorld
September 2001
Wally Flint
Access control for partial exposure With Java's built-in access control, you can't expose fields and methods to some classes in a package, while hiding them from others in the same package... mark for My Articles similar articles
JavaWorld
April 2001
Wm. Paul Rogers
Reveal the magic behind subtype polymorphism A careful examination of polymorphism reveals that polymorphic behavior is best understood in terms of type, rather than as dependent on overriding implementation inheritance. That understanding allows developers to fully take advantage of polymorphism... mark for My Articles similar articles
JavaWorld
January 2001
Gregg Sporar
Retrofit existing applications with RMI Partitioning an existing application so it is distributed across multiple CPUs is easy using Java's Remote Method Invocation (RMI). However, RMI must be carefully introduced into existing source code... mark for My Articles similar articles
JavaWorld
January 2002
Jeff Friesen
Trash talk, Part 2 This article explores the Reference Objects API, an API that allows your programs to interact with the garbage collector in limited ways... mark for My Articles similar articles
JavaWorld
July 2001
Tarak Modi
Clean up your wire protocol with SOAP, Part 4 Here's a framework based on the dynamic proxy classes in the Java 2 Platform, Version 1.3. This framework will make creating SOAP clients just as easy and intuitive as creating SOAP services... mark for My Articles similar articles
JavaWorld
February 2001
Robert Nielsen
Learn Java from Ben Franklin While Benjamin Franklin never wrote a line of Java code, his techniques for better writing can be applied to writing Java. Anyone with at least a basic grasp of Java can use Franklin's learning methods... mark for My Articles similar articles
JavaWorld
November 2001
Wm. Paul Rogers
J2SE 1.4 premieres Java's assertion capabilities, Part 1 J2SE (Java 2 Platform, Standard Edition) 1.4 adds a simple assertion facility to Java. This article, the first in a two-part series, covers the mechanics of using the new assertion facility... mark for My Articles similar articles
JavaWorld
May 2001
Thierry Manfe
Embed Java code into your native apps Embedding Java code into a Unix application developed in C or C++ can create problems related to GUIs or threads synchronization. Here's a solution that relies on a good understanding of the Unix APIs and robust software architecture... mark for My Articles similar articles
JavaWorld
October 2001
David Geary
Amaze your developer friends with design patterns Design patterns are proven techniques for implementing robust, malleable, reusable, and extensible object-oriented software. This article introduces design patterns to Java developers and explores Strategy, Composite, and Decorator -- three common, yet powerful, design patterns in the JDK... mark for My Articles similar articles
JavaWorld
October 2000
Bruce Eckel
Everything is an object, Part 2 Eckel takes you through name visibility and using components from other libraries; the static keyword; and comments and embedded documentation. By the end, you should be able to build your first Java program... mark for My Articles similar articles