Co można powiedzieć o poniższym kodzie?

 class C {
 class B {
 static int x = 10; // 1
 }
 }
 public class A {
 public static void main(String[] args) {
 C.B obj = new C().new B(); // 2
 int i = obj.x + 2; // 3
 }
 }
 

Co można powiedzieć o poniższym kodzie (zamieszczonym w dwóch osobnych plikach)?

 package pakiecik;
 public class A {
 protected int i;
 public int m(A a) {
 a.i++; return i; // 1
 }
 }
 

 package inny;
 import pakiecik.A;
 public class B extends A{
 public static void main(String[] args){
 B b1 = new B(), b2 = new B(); // 2
 b1.i =b1.m(b2); // 3
 }
 }
 

Co można powiedzieć o poniższym kodzie (przy założeniu, że odpowiednie importy zostały wykonane i klasy znajdują się w osobnych plikach)?

 interface I extends Remote {
 default void m() throws RemoteException { System.out.println("A"); } // 1
 }
 
 public class A implements I, Serializable { // 2
 public static void main(String[] args) {
 try {
 LocateRegistry.createRegistry(1099).rebind("A", new A()); // 3
 Thread.sleep(50000);
 } catch (RemoteException|InterruptedException e) {
 }}}
 
 public class B {
 public static void main(String[] args) {
 try {
 ((A) LocateRegistry.getRegistry().lookup("A")).m(); // 4
 } catch (RemoteException | NotBoundException e) {
 }}}
 

Co można powiedzieć o klasie A (zakładając, że wszystkie konieczne importy zostały dokonane)?

 public class A {
 static BufferedReader instream;
 static Socket s1, s2;
 public static void main(String[] args) throws UnknownHostException, IOException {
 new Thread(() -> {
 try { s1 = new ServerSocket(2000).accept();
 instream = new BufferedReader(new
 InputStreamReader(s1.getInputStream()));
 System.out.println(instream.readLine());
 } catch (Exception ex) {
 System.out.println("Exception");
 }}).start();
 s2 = new Socket("localhost", 2000);
 s2.close();
 }
 }
 

Co można powiedzieć o klasie A (zakładając, że wszystkie konieczne importy zostały dokonane)?

 class A {
 public static void main(String[] args) {
 Socket so;
 try {
 so = new Socket("192.168.75.94", 2000); // 1
 ObjectInputStream out = new ObjectInputStream(so.getInputStream());
 Integer i = out.readObject(); // 2
 System.out.println(i); // 3
 } catch (Exception e) {}
 }
 }
 

Co można o powiedzieć o poniższym kodzie (zamieszczonym w trzech osobnych plikach)?

 public class A {
 private A(){} // 1
 }
 

 public class B extends A {
 public B(){ } // 2
 }
 

 public class C {
 public static void main(String[] args) {
 B b = new B(); // 3
 }}
 

Co można powiedzieć o poniższym kodzie?

 class R extends Thread {
 R(Runnable t) {
 new Thread(t).start(); // 1
 }
 public void run() {
 try {
 join();
 } catch (InterruptedException e) {}
 }
 }
 public class A {
 public static void main(String args[]) {
 R r = new R(() -> System.out.println("T")); // 2
 r.start();
 }
 }
 

Co można powiedzieć o poniższym kodzie?

 public class A { // 1
 public U m(U u, T t){ // 2
 if(u.equals(t)) return u;
 else return null;}
 
 public static void main(String[] args) {
 System.out.println((new A()).m("10", "10")); // 3
 }
 }
 

Co można powiedzieć o poniższym kodzie (zakładając, że wykonano wszystkie konieczne importy)?

 public class A { // 1
 Collection c = new LinkedList(); // 2
 public static void main(String[] args) {
 (new A()).c.add(10); // 3
 }
 }
 

Co można powiedzieć o poniższym kodzie?

 import java.util.Random;
 class B {
 public static String s = "Ala";
 }
 class W extends Thread {
 private static Random r = new Random();
 W(String s) {super(s);} // 1
 public void run() {
 while (true) {
 synchronized (B.s) { // 2
 B.s = this.getName()+ // 3
 Long.toString(Math.abs(r.nextLong()), 36);
 System.out.println(B.s);
 }}}
 }
 public class A {
 public static void main(String[] s) {
 new W("A").start(); new W("B").start();
 }
 }
 

Co można powiedzieć o poniższym fragmencie kodu przy danych definicjach klas B, Prod, Cons?

 B b = new B();
 Prod p = new Prod(b);
 Cons c = new Cons(b);
 c.start(); p.start();
 

 class B { double pole = 12.0;}
 class Prod extends Thread {
 private B b = null;
 Prod(B b) {this.b = b; }
 public void run() {
 while(true){
 synchronized(b.pole){
 b.pole = Math.random();
 }}
 }}
 class Cons extends Thread {
 private B b = null;
 Cons(B b) {this.b = b;}
 public void run() {
 while(true){
 synchronized(b.pole){
 System.out.println(b.pole);
 }}
 }}
 

Co można powiedzieć o poniższym kodzie?

 public class A {
 private void m(){ // 1
 private final class B {} // 2
 }
 public static void main(String[] args){
 new A().m(); // 3
 }
 }
 

Co można powiedzieć o poniższym kodzie?

 interface I{
 public void n();
 }
 public class A {
 
 public void m(){}
 
 public void n(I i){
 i.n();
 }
 public static void main(String[] args){
 A a = new A(); // 1
 a.n(()-> {}); // 2
 a.n(A::m); // 3
 }
 }
 

Co można powiedzieć o poniższym kodzie?

 class B extends A {}
 public class A {
 public static void n(A... a){} // 1
 public static void main(String[] args) {
 B[] ab = new B[2];
 A a = new A();
 n(ab); // 2
 n(a,a); // 3
 }
 }
 

Co można powiedzieć o poniższym kodzie?

 public class A {
 void m(int a) { }
 int m(String s){return Integer.parseInt(s);}
 String m(int a){ return Integer.toString(a);}
 }
 

Co można powiedzieć o poniższym kodzie (przy założeniu, że odpowiednie importy zostały wykonane i klasy znajdują się w osobnych plikach)?

 public interface I extends Remote {
 default void m() throws RemoteException { System.out.println("A"); } // 1
 }
 
 public class A extends UnicastRemoteObject implements I { // 2
 public static void main(String[] args) {
 try {
 LocateRegistry.createRegistry(1099).rebind("A", new A()); // 3
 } catch (RemoteException e) {
 }}}
 
 public class B {
 public static void main(String[] args) {
 try {
 ((I) LocateRegistry.getRegistry(1099).lookup("A")).m(); // 4
 } catch (RemoteException | NotBoundException e) {
 }}}