Visual J
Visual J#With Visual Studio, Microsoft introduced the Visual J++ programming language and development tool. Visual J++ provided Java-based application development on the Microsoft Windows platform. Programs and components developed with Visual J++ executed on the Microsoft Java Virtual Machine. Visual J#, however, is quite different because it provides for Java-based programs to be compiled into .NET components and applications using MSIL. Therefore, the J# programming language is really like C# or Visual Basic .NET, but the programming language syntax is that of the Java programming language. J# still has all the benefits of the Java programming language as a simplified object-oriented programming language (no pointers, and so on). It is based on JDK 1.1.4.
Using the Visual J# programming language, existing Java developers can do the following:
Hello WorldA simple Hello World J# application looks pretty much like a typical Java application. The only difference is the use of the .NET Framework class library (System.Console.WriteLine) instead of the typical Java System.out.println. Java supports the notion of namespaces through packages, and that has been incorporated into J# for .NET namespaces. Also, Java provides the capability of using external class libraries with the import keyword. This has also been utilized with J# as well. (Note: J# requires a ".*" to be attached to the namespace.) package hks; import System.*; public class HelloWorld { public static void main() { Console.WriteLine("Hello World in J#"); } } J# programs are stored with the .jsl extension. To compile a J# application, use the .NET J# compiler, vjc.exe. vjc HelloWorld.jsl CommentsIn addition to the single-line and multiline comments that are similar to those of C#, J# also supports and extends the traditional Javadoc-style comments. (For non-Java programmers, Javadoc-style comments are special comments similar to XML comments in C#, used to automatically generate HTML documentation from Java programs.) package hks; import System.*; public class Comments { public static void main() { // A Simple Comment /* A multi line comment */ Console.WriteLine("Hello World in J#"); } } Data TypesTable 3.3 shows how the Visual J# types map to the corresponding .NET Framework types. Table 3.3. Visual J# Data Types
EnumerationsJ# doesn't support the creation of enumerations. However, the language does provide the capability to utilize enumerations that have been already defined in the .NET Framework or any custom .NET assemblies. Enumerations are treated as reference types as well. ArraysAs shown in the program that follows , using arrays is very similar to C#. Notice the get_Length() method used to get an array's length, as properties are not supported in J#. package hks; import System.*; public class UseArrays { public static void main() { String[] days_of_week = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" }; for (int i=0;i<days_of_week.get_Length();i++) { Console.WriteLine(days_of_week[i]); } } } Variables and ConstantsConstants in J# are prefixed by the final keyword. All the other mechanisms of creating new value types and reference types are similar to those of C#. package hks; import System.*; public class UseVariables { public static void main() { final String HELLO_WORLD = "Hello World"; String message = HELLO_WORLD + " in VJ#"; MyClass mc = new MyClass(message); mc.Print(); } } public class MyClass { private String message; public MyClass(String message) { this.message = message; } public void Print() { Console.WriteLine(message); } } ExpressionsBasic expressions in J# are very similar to those in C#. package hks; import System.*; public class UseExpressions { public static void main() { int a = 10; int b = 10; int result = a*10; boolean check = (a==b); Console.WriteLine(result); Console.WriteLine(check); } } StatementsStatements in J# are very similar to those in C#. package hks; import System.*; public class UseStatements { public static void main() { String[] message = {"Hello","World","in","VJ#"}; for (int i=0;i<message.get_Length();i++) { Console.Write(message[i]+" "); } int a = 10; int b = 10; if (a<b) { Console.WriteLine("a<b"); } else { Console.WriteLine("a>=b"); } } } ClassesConstructs such as class definition, abstract classes, inheritance, and so on in J# are all very similar to C# (Listing 3.17). However, properties are not supported within the Java programming language; this is carried on with J#. But J# does support properties using the property accessor methods (set_, get_). Listing 3.17 Using Classes (Visual J#) package hks; import System.*; public class Useclasses { public static void main() { Person hs = new Person("Hitesh","Seth"); Person jd = hs; jd.set_FirstName("John"); jd.set_LastName("Doe"); Console.WriteLine(hs.GetFullName()); } } public class Person { private String sFirstName, sLastName; public Person(String FirstName, String LastName) { this.sFirstName = FirstName; this.sLastName = LastName; } public void set_FirstName(String FirstName) { this.sFirstName = FirstName; } public String get_FirstName() { return sFirstName; } public void set_LastName(String LastName) { this.sLastName = LastName; } public String get_LastName() { return sLastName; } public String GetFullName() { return sFirstName +"."+sLastName; } } Similar to C#, J# also supports single inheritance, including overriding base class methods (Listing 3.18). However, unlike C#, all nonprivate methods can be overridden by a derived class. In essence, then, J# methods behave like virtual methods. Listing 3.18 Inheriting Classes (Visual J#) package hks; import System.*; public class UseInheritance { public static void main() { FullPerson hs = new FullPerson("Hitesh","K","Seth"); Console.WriteLine(hs.GetFullName()); Object oHs = hs; if (oHs instanceof Person) { Console.WriteLine("I am still a Person"); } } } public class Person { public String FirstName, LastName; public Person(String FirstName, String LastName) { this.FirstName = FirstName; this.LastName = LastName; } public String GetFullName() { return FirstName + "." + LastName; } } public class FullPerson extends Person { public String MiddleInitial; public FullPerson(String FirstName, String MiddleInitial, String LastName) { super(FirstName,LastName); this.MiddleInitial = MiddleInitial; } public String GetFullName() { return FirstName + "." + MiddleInitial + "." + LastName; } } Abstract classes are supported in a way similar to C# (Listing 3.19). Listing 3.19 Using Classes (Visual J#) package hks; import System.*; public class UseAbstractClasses { public static void main() { Person hs = new Person("Hitesh","Seth"); Console.WriteLine(hs.GetFullName()); } } public abstract class Abstract { protected String FirstName, LastName; public Abstract(String FirstName, String LastName) { this.FirstName = FirstName; this.LastName = LastName; } abstract public String GetFullName(); } public class Person extends Abstract { public Person(String FirstName, String LastName) { super(FirstName, LastName); } public String GetFullName() { return FirstName+"."+LastName; } } InterfacesWith constructs very similar to C#, the J# programming language also supports multiple inheritance using Interfaces (Listing 3.20). Actually, the simple mechanism of interface was in some sense introduced by Java and adopted by C#. Listing 3.20 Using Interfaces (Visual J#) package hks; import System.*; public class UseInterfaces { public static void main() { Person hs = new Person(); hs.set_Name("Hitesh Seth"); hs.set_Address("1 Executive Driver, City, NJ 08520"); Console.WriteLine(hs.GetName()); Console.WriteLine(hs.GetAddress()); } } public interface IName { public String GetName(); } public interface IAddress { public String GetAddress(); } public class Person implements IName, IAddress { private String name, address; public Person() { } public void set_Name(String value) { name = value; } public void set_Address(String value) { address = value; } public String GetName() { return name; } public String GetAddress() { return address; } } Exception HandlingException handling has always been supported in the Java programming language, and that capability is easily reused with the .NET exception model as well. package hks; import System.*; public class UseExceptions { public static void main() { try { int a = 10; int b = 10; int c = a/(a-b); } catch (System.Exception ex) { Console.WriteLine("Exception Caught"); Console.WriteLine(ex.get_Message()); } } } Custom exceptions are supported in J#, again, this is very similar to C# (Listing 3.21). Listing 3.21 Creating Custom Exceptions (Visual J#) package hks; import System.*; public class UseCustomExceptions { public static void main() { try { Discount big_discount = new Discount(56); } catch (TooBigDiscountException ex) { Console.WriteLine("Exception Caught"); Console.WriteLine(ex.get_Message()); } } } public class Discount { private int percent; public Discount(int percent) throws TooBigDiscountException { this.percent = percent; if (percent > 50) throw new TooBigDiscountException("Discount > 50%"); } } public class TooBigDiscountException extends System.Exception { public TooBigDiscountException(String msg) { super(msg); } } Delegates and EventsBecause the Java programming language has no built-in support for delegates and events, the J# implementation provides a set of extensions for creating this capability. Delegates are tagged with a special comment /** @delgate */ before its definition and so are events (using /** @event */ ). Also, the class implementing the events needs to keep a reference to all the listeners assigned for the particular events by creating an ArrayList or a similar collection. After the listeners have been assigned, they are invoked using the Invoke method (Listing 3.22). Listing 3.22 Using Delegates and Events (Visual J#) package hks; import System.*; import System.Collections.*; /** @delegate */ public delegate void EventHandler(); public class Button { ArrayList listeners = new ArrayList(); public static void main() { Button button = new Button(); button.add_OnClick(new EventHandler(Button_OnClick)); button.Click(); } /** @event */ public void add_OnClick(EventHandler listener) { listeners.Add(listener); } /** @event */ public void remove_OnClick(EventHandler listener) { listeners.Remove(listener); } public void Click() { Object [] olisteners = listeners.ToArray(); for (int i = 0;i < olisteners.length ;i++) { ((EventHandler)(olisteners[i])).Invoke(); } } public static void Button_OnClick() { Console.WriteLine("Button Clicked"); } } |
