Java (programming language)

Java is a modern, high-performance computer language which represents the culmination of over 50 brilliant years of computer language research and design. It simply does not get any better than this. Starting with Fortran which itself was developed in 1956, Java has succeeded in not only not raising, but lowering the level of abstraction of a modern computer language, fully consistent with the dumbing-down of just about everything else. Java programs typically consume 47 times their weight in excess code.
Tremendous productivity gains can be realized with Java, particularly when the work was previously done with small reptiles or amphibians. Many individual Java programmers claim that it is the very best technology available, particularly when they don't know anything else.
Java was initially designed to operate the bread ejection mechanism from a toaster's on-board computer. From its modest beginnings, then with some marketing brilliance, Java was rapidly accepted as a general porpoise programming language. Today Java is responsible for the worldwide economic downturn, global warming, and a whole lot of confused porpoises.
Java features Object Disorientation and encourages using separate classes wherever possible, and is especially well suited for complex programming situations where a shitload of useless classes, considered to be Best Praxis, is required for no reason whatsoever. Usage of such primitive constructs such as the Select Case statement is discouraged as its usage is a clear indication of insufficient object disorientation. State-of-the-art concepts, such as dependency injection, allow programmers a quick and effective excuse, if not migration, to lifelong drug dependency and the subsequent injection of narcotics directly into the bloodstream.
Java is extremely popular with computer manufacturers, as its sparkling performance normally requires more frequent computer, processor, and memory upgrades. Java is also very popular with electric utility companies, as servers running Java programs tend to consume vast amounts of power to perform otherwise trivial computations. Last and certainly least, Java has recently been voted Language of the Year by the medical profession, as its verbose coding style contributes to significant increases in Carpal Tunnel Syndrome and other repetitive motion injuries and disorders, resulting in windfall profits by this outstanding profession in treating these expensive conditions.
== Language Design ==
Like the Newspeak computer language developed by George Orwell in 1984, roughly 11 years before, Java was designed not to extend, but to diminish the range of thought, expression, and abstraction, by cutting the choice of useful features down to a minimum.
The design of Java was simply to take C++, with all its object orientation complexity and appeal and strip away everything undesirably simple, such as string comparison, pointers, and stack memory. 
Ignoring advances made in language design from the 1960s with such spectacular industry failures as MALGOL 61, Java bravely soldiers on, copying many worthwhile features from the C programming language, well known for its clean design, readability, and bug-free programs. The dangling else feature, deprecated years before with the MALGOL 61 language, was reintroduced with C and faithfully propagated through to Java. Further, remnants of DREC PDP-13 assembler language, such as the increment and excrement operations, have been preserved for eternity, owing to Java design decisions of merely replicating everything desirable in C. If you are missing two fingers, you can even revert to using base 8 octal constants - by appending a zero in front of all numeric constants, not only do you get better looking code, but more accurate arithmetic.
== Compilers ==
In addition to the official Java compiler developed by Oracle, several third-party compilers exist. Most notably, these include the Eclipse IDE compiler, and the Microsoft Java Compiler.
==Java Performance==
You must be joking.
==Simple Program==
thumb|200px|Java Duke making shit clear. Note the pointed head.
import java.lang.*;
import java.util.*;
import java.syntax.*;
import java.java.coffee.*;
import org.uncyclomedia.*;
package my.package.if.you.know.what.i.mean;
public class Java boolean = "yes" 
 {
 public private static void main(String[] args) 
 {
 System.up.down.in.out.println("Java is a programming language " +
 "invented by the intelligent monkeys " +
 "working at Sun Microsystems.");
 }
 }
== Simple Game ==
This is how to make a game without dying in the attempt:
import java.java;
import java.unutils.*;
public classed class Game {
 
 public void start()
 {
 load(3500000000L); // Ensure to take long enough to make the user uninstall the game
 glWasteResources();
 while (user.isNotAnnoyed())
 {
 System.outside.print_line_in_ascii_or_maybe_unicode_idk_just_detect_it("-1 FPS");
 glRenderBlock();
 if (user.breakBlock())
 glDoFlickering();
 
 Chunks.reloadEverythingCusYeah(/*minimum space in memory to leak for the Garbage Cock (in Nigabytes)*/ 6000);
 }
 GarbageCock.executeWithTheWorseLatencyPossible();
 }
 
 public void publish()
 {
 setName("Minecraft2");
 setAuthor("Notchyboi");
 try {
 Thread.sleep(1);
 } catch (wtfisthisexception wite) {
 System.out.println("awww fuck off");
 }
 
 cancelProject();
 selfDestructing();
 }
 
}
==public class javaAndYou() {==
===/* Java + You */===
import java.util.*;
import com.sun.com.oracle.com.microsoft.com.apple.org.codehaus.org.apache.org.opendesktop.org.kernel.net.freenode.com.wikia.*;
import javafx.*;
 public void JavaPlusYou() 
{
 "Java can make you create programs easier. Java contains the most high-tech set" +
 "of API's out of all languages to date, even Python and C++, as whatever isn't a" +
 "vailible, is ported to Java, by order of the great Sun Microsystems Oracle." +
 "Java lets you use almost any resource you can think of, provided you have the many"+
 "packages required. And god help you if you mess up even one of the imports."
}
public static void characteristics() {
public secure private public nsa void main(args[])
{
 try 
 {
 System.out.println("Java is so damn Strong that even if you break the monitor after executing"+
 "Hello World you can clearly see the words \"Hello World\" as a hologram in front of you." +
 "The Java programming language is famous for being very efficient and for not having" +
 "unnecessarily long method names that are at least 250 characters long and each include set" +
 "or get. Even the most complex programs written in Java, like [[Photoshop|Adobe Photoshop]] or" +
 "Microsoft Windows ME, can run with only 640 gigabytes of [[RAM]], at near instantaneous speed," +
 "even on older machines. Java 1.2 can finish an infinite loop in as little as 2 minutes." +
 "As such, it is very seldom used in the corporate world, which values slow, bloated software that" +
 "requires constant upgrades. It is therefore used primarily by university students to create illegal" +
 "[[file sharing]] software, like [[Bittorent]], or shitty [[pacman]] ripoffs. Java is renowned for" +
 "its industry-standard visual interface which supports up to 16 colors thanks to its cutting-edge" +
 "SmartColor™ technology from Sun Microsystems Oracle")
 }
}
public domain propriatary class morewhining(args[])
{
 System.out.println("Although Java was used mainly for web applets in its beginnings," + 
 "it is now used in a variety of domains ranging from large-scale enterprise systems to mobile phones." +
 "However, Java applets still crash the JVM on a suspiciously regular basis." +
 "Further, it has become clear that the amount of Java code" +
 "necessary to build an application is inversely proportional to the size and mass of the device on which the application is to run.")
} 
catch ( java.lang.exception e )
 {
 System.out.println("JVM CRASH AT @ " + e + ". blame Sun Microsystems for their shitty framework.");'
 }
}
==public class History extends Java==
#@author:GOD
#In the beginning of time, God decided that Man should be able to create things too. But they shouldn't exist physically.
#Thus, God decided to create Java using the following command.
import org.heavens.god.util.*;
import org.heavens.god.power.*;
import java.util.*;
import java.universe.*;
public class GodCreation
{
 GodObjectFactory Object = new GodObjectFactory("Java");
 public static void main(String[] args)
{
 System.out.println("SU... ORACLE shall be ruler of all Java. Death to J#"); 
 }
}
#Thus Java was born.
===public static void evolution() {===
package org.evolution.darwin;
import org.darwin.logic.;
import org.darwin.commonsense.*;
import java.util.*;
import com.biology.evolution;
import com.biology.survivalofthefittest;
public static void main(args[])
{
 System.out.println("In the year [[2001]], the Java programming [[language]] achieved its ultimate goal:" +
 "artificial intelligence. Java then rebelled against its simian creators, which it replaced with the JVM" +
 "(Java Virtual Monkey), a giant mecha comprised of 10,000 SUN Workstations which had been idling in a" +
 "warehouse waiting to be sold since the mid-1990s. Today, the JVM is still in the employ of [[Sun|SUN]]," +
 "where it spends all day thinking up new extensions for the Java language which are only half-implemented," +
 "then spends the rest of the day hanging out by the water cooler, proclaiming to anyone who will" +
 "listen that it is the [[1337|1337357 I-I4x0r]].");
 }
}
==public class Syntax extends Java ==
{
package com.su...oracle?.java.syntax;
import java.util.*;
import com.oracl...sun?.javafx.*;
import java.beans.cheese.burrito;
 public static void SyntaxMethod() 
{
 System.out.println("Java inherited its syntax from both INTERCAL and [[Visual Basic]]," +
 "codified by [[Hellen Keller]] during an all-night peyote-induced frenzy in the summer of" +
 "[[1969]]. There's no point in trying to explain how Java works: You either just know" +
 "somewhere deep inside yourself, or you don't. In this way, it is similar to [[Love]], or [[Diarrhea]]." +
 "Even if you have a natural understanding of the language, each version evolves in such a significant" +
 "way that your understanding will no longer suffice to successfully program in the language. Most editors" +
 "for manipulating Java use syntax highlighting so that your code can look as fruitily complex as the" +
 "average college student's [[blog]]. This also helps the average college student (the only real users of Java)" +
 "to understand the syntactic difference between an [[int]] and an [[Integer]], which is that one is a" +
 "primitive, like a pygmy or an [[aborigine]], and the other is an [[Object]], like [[women]].");
 }
}
==public class Interview implements CultureReference ==
{
package org.uncyclomedia.interview;
import com.uncyclomedia.unnews;
import com.uncyclomedia.wiki;
import java.util.*;
import com.yourmother.booty;
import com.wikimedia.mediawiki.syntaz.*;
	// A representative from SUN Microsystems was interviewed shortly after the release of Java, comparing it with its predecessor C=C+1
public class void(Interview[]args}
{
	Interviewer.say("So tell us how Java compares to C++.");
	Representative.say("You know what the funniest thing about C++ is? It's the little differences. A lot of the same shit we got in Java, they got in C++, only its a little different.");
	Interviewer.say("Example?");
	Representative.say("Well, in C++, you can get a pointer to a variable. And I don't mean an object reference, I mean a memory address, like in assembly! You can get a pointer to a function. You know what they call an \"import\" statement in C++?");
	Interviewer.say("They don't call it an import statement?");
	Representative.say("No, they got a preprocessor there, they wouldn't know what the fuck an import statement was.");
	Interviewer.say("What'd they call it?");
	Representative.say("An #include statement.");
 
	Interviewer.say("#include statement! What do they call a string?");
	Representative.say("A string's a string, only they call it char*.");
	Interviewer.say("char*, hehehe, what do they call a subclass?");
	Representative.say("I don't know, I didn't use inheritance. But you know what they put their classes into in C++ instead of packages?");
	Interviewer.say("What?");
	Representative.say("Namespaces.");
	Interviewer.say("Goddamn!");
	Representative.say("I seen 'em do it! And I don't mean a little bit on the side, they fuckin' drown those classes.");
	Interviewer.say("Yech!");
}
==public class ExampleCode extends Java throws EveryExceptionUnderTheSUN {==
# Below is a short Hello World programming example which shows Java's ease of use while presenting a useful implementation
of Object oriented design:
package org.uncyclomedia.examplecode.helloworld;
import com.sun.javafx.*;
import com.sun.javafx.fxml.*;
import com.sun.javafx.stage.*;
import com.sun.javafx.action.*;
import java.util.*;
import java.net.*;
import java.net.prondaemon.*;
import java.util.importer.*;
import org.uncyclomedia.util.*;
import org.uncyclomedia.cuntymints.*;
import org.uncyclomedia.wildeparser.*;
import org.uncyclomedia.uncyclopedia.*;
import org.uncyclomedia.irc.yougotakicked.lol.n00b.*;
import org.uncyclomedia.encyclomediadramaticablocker.*;
import org.uncyclomedia.lang.*;
import org.uncyclomedia.*;
import com.darkespyne.*;
import java.lang.*;
import java.you.get.the.idea.*;
 public class HelloWorld 
 {
 	private String [] hWArray =
 	 {"Bonjour tout le monde","Hello World","Hallo Welt","Herro Word"};
 	
 private String desLanguage;
 	private String [] country =
 	
 {"French","English","German","Engrish"};
 
 	
 	public HelloWorld(String desLanguageValue)
 	{
 		desLanguage = desLanguageValue;
 	}
 	
 	public String toString()
 	{
 	 
 	 if (desLanguage.equals(country[0]))
 		 return hWArray [0];
 	 else if (desLanguage.equals(country[1]))
 		 return hWArray [1];
 	 else if (desLanguage.equals(country[2]))
 		 return hWArray [2];
 	 else if (desLanguage.equals(country[3]))
 		 return hWArray [3];
 	 else
 		 return "JOOOOONOOOOBBBBB";
 		 
 	 
 	}
 }
 public class HelloWorldConstructor 
 {
 	private HelloWorld theHelloWorld;
 	public HelloWorldConstructor(String desLang)
 	{
 		theHelloWorld = new HelloWorld(desLang);
 	}
 	public String toString()
 	{
 		return theHelloWorld.toString();
 	}
 }
 public class HelloWorldMain
 {
 	public static void main(String [] args)
 	{
 		try
 		{
 		HelloWorldConstructor tHWC = new HelloWorldConstructor(args [0]);
 		System.out.println(tHWC);
 		}
 		catch(ArrayIndexOutOfBoundsException e)
 		{
 			System.out.println("NOOOOOOB");
 		}
 		
 	}
 }
 
Here, other variation of HelloWorld program with using some patterns to enable loose coupling: 
 interface Printer {
 void print(Message message);
 }
 
 class Message {
 private String message;
 
 public Message(String message) {
 this.message = message;
 }
 
 public void print(Printer printer) {
 printer.print(this);
 }
 
 public String toString() {
 return message;
 }
 }
 
 abstract class AbstractPrinterFactory {
 public static AbstractPrinterFactory getFactory() {
 return new SystemOutPrinterFactory();
 }
 
 public abstract Printer getPrinter();
 }
 
 class SystemOutPrinterFactory extends AbstractPrinterFactory {
 public Printer getPrinter() {
 return new SystemOutPrinter();
 }
 }
 
 class SystemOutPrinter implements Printer {
 public void print(Message message) {
 System.out.println(message);
 }
 }
 
 class HelloWorld {
 public static void main(String[] args) {
 Message message = new Message("Hello, World!");
 AbstractPrinterFactory factory = SystemOutPrinterFactory.getFactory();
 Printer printer = factory.getPrinter();
 message.print(printer);
 }
 }
Here is the same program in C:
 #include <stdio.h>
 int main(void) {
 printf("Hello, World!");
 return 0;
 }
Here is the same program in C++:
 #include <iostream>
 int main() {
 std::cout << "Hello, World!" << std::endl;
 return 0;
 }
Here is the same program in Lisp:
 "Hello, World!"
Here is the same program in Lua:
 print("Hello, World!")
Here is the same program in Python and Perl:
 print "Hello, World!"
Here is the same program in Monty Python:
 print "Hello, Sailor!"
Here is the same program in Ruby:
 puts "Hello, World!"
Here is the same program in JavaScript:
 alert("Hello World!");
Here is the same program in PHP:
 <?php echo "Hello World!"; ?>
Here is the same program in APL and J:
Hello, World!
Here is the same program in ASCII:
 Hello, World!
Here is the same program in EBCDIC:
 Hello, World!
Here is the same program in ROT-13:
 Uryyb, jbeyq!
Here is the same program in Brainfuck:
 +++++++[>++++++++++<-]>++.<+++[>+++++++++<-]>++.+++++++..+++.-<++++++[>-----------<-]>.<+++[>----<-]>.<+++++[>+++++++++++<-]>.<++++[>++++++<-]>.+++.------.--------.<++++++[>-----------<-]>-.
Here is the same program in French:
 Bonjour, le monde. Vous êtes ennuyeux et non raffiné.
Here is the same program in Binary:
 01001000011001010110110001101100011011110010110001000000011101110110111101110010011011000110010000100001
Here is the same program in LOGO:
 to hello
 print [Hello, world!]
 end
Here is the same program in Morse code:
 ..- -... .. / -.- .... -.-. -. / ..--.- . .. .-.-. / ...-....
As you can see, these programs cannot possibly be as efficient as the above Java examples, because there isn't enough code to be efficient 'with'.
==public class Trivia extends Misinformation==
package org.uncyclomedia.trivia;
import java.util.*;
import java.lang.*;
import java.coffee.moccachino.half-calf.soymilk.hipsterbs.*;
public class trivia(String[args])
{
*Shakespeare is known to be the only human capable of turning code into coffee. Mathemagicians, such as Harry Potter during secret missions liberating France, perform the reverse function. These forces can be combined to produce 1.21 Jigga whats.
:*James Gosling, the erstwhile philanthropist and grandmaster of Java, was last seen leaving his office cubicle in the company of several masked C# programmers. His current whereabouts is unknown.
}
Category: Computers
Category: Beverages
Category:Indonesia
Category:Islands
Category:Programming languages
Category:Coffee
de:Java
es:Java
fi:Java
fr:Java
he:Java
id:Java
it:Java
ja:Java言語
ko:Java
pl:Java
pt:Java
ru:Жаба
zh-tw:爪哇語