Free java class decompiler software for linux

RJCE allows all methods or variables of user defined classes to be altered at runtime. These alterations are then applied to a single instance, a collection of instances (i.e. list, set or map), or an entire class.

This helps you to test your application in an interactive way; altering running programs helping a trial and error approach to programming; testing code and saving it when it’s correct. Long running algorithms, such as simulations, can also easily be refined without the need for restarts or lose of data.

RJCE can be used to write a program from within itself ensuring high coupling between testing and development, with no delay before the outcome of any alterations.

RJCE allows scripts to run from within your application, allowing users to configure or extend an application dynamically, bypassing normal language access rules controlled by public, private and protected. This can be done by easily instatiating an instance of CodeEditorFrame from the rom.gui package.

RJCE permits faster development of applications by allowing easy migration from scripts to Java programs.

Class::Declare is a Perl module created to declare classes with public, private and protected attributes and methods.

SYNOPSIS

package My::Class;

use strict;
use warnings;
use base qw( Class::Declare );

__PACKAGE__->declare(

public => { public_attr => 42 } ,
private => { private_attr => Foo } ,
protected => { protected_attr => Bar } ,
class => { class_attr => [ 3.141 ] }
static => { static_attr => { a => 1 } } ,
restricted => { restricted_attr => string } ,
abstract => abstract_attr ,
friends => main::trustedsub ,
new => [ public_attr , private_attr ] ,
init => sub { # object initialisation
...
1;
} ,
strict => 0

);

sub publicmethod {
my $self = __PACKAGE__->public( shift );
...
}

sub privatemethod {
my $self = __PACKAGE__->private( shift );
...
}

sub protectedmethod {
my $self = __PACKAGE__->protected( shift );
...
}

sub classmethod {
my $self = __PACKAGE__->class( shift );
...
}

sub staticmethod {
my $self = __PACKAGE__->static( shift );
...
}

sub restrictedmethod {
my $self = __PACKAGE__->restricted( shift );
...
}

sub abstractmethod { __PACKAGE__->abstract }

1;

...

my $obj = My::Class->new( public_attr => fish );

MOTIVATION

One of Perls greatest strengths is its flexible object model. You can turn anything (so long as its a reference, or you can get a reference to it) into an object. This allows coders to choose the most appropriate implementation for each specific need, and still maintain a consistent object oriented approach.
A common paradigm for implementing objects in Perl is to use a blessed hash reference, where the keys of the hash represent attributes of the class. This approach is simple, relatively quick, and trivial to extend, but its not very secure. Since we return a reference to the hash directly to the user they can alter hash values without using the classs accessor methods. This allows for coding "short-cuts" which at best reduce the maintainability of the code, and at worst may introduce bugs and inconsistencies not anticipated by the original module author.

On some systems, this may not be too much of a problem. If the developer base is small, then we can trust the users of our modules to Do The Right Thing. However, as a modules user base increases, or the complexity of the systems our modules are embedded in grows, it may become desirable to control what users can and cant access in our module to guarantee our codes behaviour. A traditional method of indicating that an objects data and methods are for internal use only is to prefix attribute and method names with underscores. However, this still relies on the end user Doing The Right Thing.

Class::Declare provides mechanisms for module developers to explicitly state where and how their class attributes and methods may be accessed, as well as hiding the underlying data store of the objects to prevent unwanted tampering with the data of the objects and classes. This provides a robust framework for developing Perl modules consistent with more strongly-typed object oriented languages, such as Java and C++, where classes provide public, private, and protected interfaces to object and class data and methods.

Scriptol is an object oriented programming language designed to deliver the programmer from hardware or software constraints and let him or her concentrate only on the problem to formulate as a program.

Scriptol Compilers is universal, and allows building dynamic Web pages (with PHP as the backend), writing scripts, and building binary applications. It is compatible with Java and C++ libraries. Examples of use with PHP, Java, and GTK are included.

How to install the Java extension for Php or C++

1) Installing Java for Php
Search for the java path, example:
c:jdk1.4

Search for the php extensions path, example:
c:phpextensions

The extension directory must hold these files:
php_java.dll
php_java.jar

Set these lines into php.ini (in the Windows directory)
extension_dir = c:phpextensions
extension=php_java.dll

Search for the [java] section in php.ini - java.class.path must be assigned the path of all jar or class files including php_java.jar, separated by a semi-colon. (You can use a dot to designate the current path for yours jar or class file) - java.home

must be assigned the path of Java. - java.library
must be assigned the path of jvm.dll. - java.library.path
must be assigned the path of php extensions, that hold php_java.dll and php_java.jar and the path of any Java class you want to use.

- If these classes are inside jar files, the jar filenames are a part of the path.
- If several paths are required, they are separated by semicolons and enclosed in double quotes.

Example:
[Java]
java.class.path = "c:phpextensionsphp_java.jar;c:myclasses"
java.home = "c:jdk1.4"
java.library = "c:jdk1.4jrebinclientjvm.dll"
java.library.path = "c:phpextensions;c:jdk1.4jrelib"

2) Installing Java for Scriptol C++
- The jvm.dll must be in the path.
- The jvm.lib, jni.h, jni_md.h files must be in the directory of the source.
- The JAVA_HOME variable must be assigned the path of the JDK (ex: c:jdl1.4).
- See the README file if you encounter problems...

Java::JCR::Nodetype is a Perl module that can load the JCR node type class wrappers.

SYNOPSIS

use Java::JCR::Nodetype;

This loads the Perl classes mapped to the javax.jcr.nodetype package.
You might notice the odd letter case of this package differs from that of the node type class (Java::JCR::Nodetype::NodeType). This has to do with the way the package was imported. This may be corrected in the future.

Java for C++ is a tool to generate C++-wrapper-classes for existing Java-classes. This tool reads a list of Java class names and creates source code for C++-classes to wrap them.
The implementation of the wrapper classes uses JNI (Java Native Interface) to call the "real" Java classes.
The C++-API to use these wrapper classes is very close to the API of the original Java classes. So developers of C++-software can use Java-classes as if they have been implemented in C++.
Enhancements:
- A problem where null values for method arguments, method return values, or field values caused some generated code to crash was fixed.
- Updating is strongly encouraged.

Java::Import is Perl module to use Java classes in Perl.

SYNOPSIS

use Java::Import qw(
some.package.SomeClass
);

my $instance = new some.package.SomeClass();
$instance->someMethod();

my $ret_val = some::package::SomeClass::someStaticMethod();
$ret_val->someMethod();

$ret_val2 = $instance->someOtherMethod($ret_val);
$ret_val2->someMethod();

my $java_array_ref $instance->someMethod2();
foreach my $obj ( @$java_array_ref ) {
$obj->someMethod();
}

The purpose of this module is to provide a simple method for using Java classes from a Perl program while using the latest in Open Source Java Technology. Thus, this module makes great use of the GNU Compiler Tools for Java in its implimentation.

Java::Import::Examples is an example of how to use Java::Import to call into Java classes.

Making RMI calls from Perl

One nice thing about Java is the extremely straight forward manner in which it allows you to make calls to remote objects residing on distant servers. Many people use this ability as a point of integration between their system and a posible third party or legacy system. Unfortunatly, for the most part the ability to make calls to these remote objects is something that only other Java applications can do without making a big fuss about it. However, we can now do this from Perl.

Assume that I have a RMI server from which I can get data from in the form of simple Java Beans. One method of doing this is to use the GCJ::Cni library and natively compile and wrap a set of Java Classes which can then be used from my Perl script. However, there is an easier way.

Lets begin by descriping the Java interfaces that well be working with. We first have the Remote Interface that we will be interacting with:

import java.rmi.*;
public interface RemoteInterface extends Remote {
public SomeBean getMessage(String seedMessage) throws RemoteException;
}
And we also have the bean we will be asking for:
import java.io.*;
public class SomeBean implements Serializable {
private String value;
public SomeBean() {}
public void setValue ( String _value ) { ... }
public String getValue ( ) { ... }
}
As far as any Perl client program is concerned this is all we need to know about.
Now all there is left to do is write a client:
use Java::Import qw(
java.rmi.Naming
);

my $remote_interface = java::rmi::Naming->lookup(jstring("//localhost/Home"));
my $bean = $remote_interface->getMessage(jstring("Hi there"));
print $bean->getValue(), "n";

Thats all there is. Notice that all we had to tell Java::Import about was java.rmi.Naming, this is because it was the only class we used by name in our Perl code, every other Java class (the objects held by $bean and $remote_interface) was returned by some other method call originating from java.rmi.Naming.

In order to run this example we have to make sure everything is in its place. We start by compiling the client code. Assuming that we have been given a Stub class file (RemoteObject_Stub.class) we can do the following:

gcj -C SomeBean.java RemoteInterface.java
fastjar -cvf client.jar SomeBean.class RemoteInterface.class RemoteObject_Stub.class

Making sure our server is reachable we can then run the client code:

CLASSPATH=client.jar perl client.pl

Thats it, you should then see the message returned by your server.