В Java нужно указать тип элемента массива, многоточие и имя параметра.

В C# нужно указать модификатор params, тип самого массива и имя параметра.

public class A { public int f(int ... a) { return a.length; }

public static void main(String[] args) { A a = new A();

System.out.println ( a.f(new int[]{9, 0}) ); System.out.println ( a.f(1, 2, 3, 4) ); } }

using System;

public class A { public int f(params int[] a) { return a.Length; }

public static void Main { A a = new A();

Console.WriteLine ( a.f(new int[]{9, 0}) ); Console.WriteLine ( a.f(1, 2, 3, 4) ); } }

В Java требуется указывать некоторые типы исключений, возникновение которых возможно при работе метода, в заголовке метода.

Точнее, все исключения делятся на два вида — проверяемые (checked) и непроверяемые (unchecked). Непроверяемыми считаются исключения, возникновение которых может быть непреднамеренно — обращение к методу или полю по ссылке, равной null, превышение ограничений на размер стека или занятой динамической памяти, и пр. Проверяемые исключения предназначены для передачи сообщений о возникновении специфических ситуаций и всегда явно создаются в таких ситуациях.

Непроверяемое исключение должно иметь класс, наследующий java.lang.Error, если оно обозначает серьезную ошибку, которая не может быть обработана в рамках обычного приложения, или java.lang.RuntimeException, если оно может возникать при нормальной работе виртуальной машины Java. Если класс исключения не наследует одному из этих классов, оно считается проверяемым.

Все классы проверяемых исключений, возникновение которых возможно при работе метода, должны быть описаны в его заголовке после ключевого слова throws.

Если некоторый метод вызывает другой, способный создать проверяемое исключение типа T, то либо этот вызов должен быть в рамках try-блока, для которого имеется обработчик исключений типа T или более общего типа, либо вызывающий метод тоже должен указать тип T или более общий среди типов исключений, возникновение которых возможно при его работе.

В C# исключения, возникновение которых возможно при работе метода, никак не описываются.

public void m(int x) throws MyException { throw new MyException(); }

public void n(int x) throws MyException { m(x); }

public void k(int x) { try { m(x); } catch(MyException e) { ... } }

В Java все параметры операций передаются по значению.

Поскольку все типы, кроме примитивных, являются ссылочными, значения таких типов — ссылки на объекты. При выполнении операции можно изменить состояние объекта, переданного ей в качестве параметра, но не ссылку на него.

В C# можно определить параметры операций, передаваемые по ссылке, и выходные параметры операций.

Параметры, передаваемые по ссылке, помечаются модификаторов ref. Выходные параметры помечаются модификатором out.

При вызове операции значения этих параметров должны быть помечены так же.

public class A { public void f (int a, ref int b, out int c) { c = b - a; b += a; }

public static void Main() { A a = new A(); int n = 3, m = 0;

Console.WriteLine ("n = " + n + " , m = " + m); a.f(1, ref n, out m); Console.WriteLine ("n = " + n + " , m = " + m); } }

В Java все классы (но не интерфейсы!) считаются наследниками класса java.lang.Object.

Примитивные типы не являются его наследниками, в отличие от своих классов-оберток.

В C# все классы, структурные, перечислимые и делегатные типы (но не интерфейсы!) рассматриваются как наследники класса System.Object, на который обычно ссылаются как на object.

При этом, однако, типы значений (перечислимые и структурные типы, наследники System.ValueType) преобразуются к типу object с помощью упаковки, строящей каждый раз новый объект.

Структурный тип может реализовывать один или несколько интерфейсов, но не может наследовать классу или другому структурному типу.

@interface SimpleMethodAnnotation {}

@interface SimpleParameterAnnotation{}

@interface ComplexClassAnnotation {

int id(); String author() default "Victor Kuliamin"; String date(); }

@interface AdditionalMethodAnnotation {

String value() default ""; }

@ComplexClassAnnotation ( id = 126453, date = "23.09.2005" ) public class A { @SimpleMethodAnnotation public void m() { ... }

@SimpleMethodAnnotation @AdditionalMethodAnnotation ( value = "123" ) public void n (@SimpleParameterAnnotation int k) { ... } }

class SimpleParameterAttribute : Attribute {}

class ComplexClassAttribute : Attribute { public int id; public String author = "Victor Kuliamin"; public String date; }

class AdditionalMethodAttribute : Attribute { public String value = ""; }

[ComplexClassAttribute ( id = 126453, date = "23.09.2005" )] public class A { [SimpleMethodAttribute] public void m() { ... }

[SimpleMethodAttribute, AdditionalMethodAttribute (value = "123")] public void n ([SimpleParameterAttribute] int k) { ... } }

В Java аннотации могут помечать также пакеты (т.е. использоваться в директиве декларации пакета, к которому относится данный файл), декларации локальных переменных и константы перечислимых типов.

В C# могут быть описаны глобальные атрибуты, помечающие сборку, в рамках кода которой они встречаются. Такие атрибуты помещаются вне описаний пространств имен.

Также атрибутами могут помечаться отдельные методы доступа к свойствам, индексерам и событиям.

Аннотационный тип декларируется с модификатором @interface и неявно наследует интерфейсу java.lang.annotation.Annotation.

Такой тип не может иметь типовых параметров или явным образом наследовать другому типу.

Атрибутный тип описывается как класс, наследующий System.Attribute или его наследнику.

Такой тип не может иметь типовых параметров.

Свойства аннотационного типа описываются как абстрактные методы без параметров, с возможным значением по умолчанию.

При определении значений свойств аннотации через запятую перечисляются пары <имя свойства> = <значение>.

Помимо свойств, в аннотационном типе могут быть описаны константы (public static final поля) и вложенные типы, в том числе аннотационные.

Свойства атрибутного типа могут быть именованными параметрами и позиционными параметрами.

Позиционные параметры определяются при помощи конструкторов атрибутного типа.

Именованные параметры определяются как доступные для чтения и записи нестатические поля и свойства атрибутного типа.

При определении значений свойств атрибута сначала через запятую перечисляются значения позиционных параметров, а затем пары <имя именованного параметра> = <значение>.

В атрибутном типе могут быть описаны такие же элементы, как и в обычном классе.

Ниже приведен пример использования позиционного параметра.

class ClassAttribute : Attribute { public ClassAttribute(int id) { this.id = id; }

int id; public string value; }

[ClassAttribute(4627, value = "")] public class A { ... }

Свойство аннотационного типа может иметь примитивный тип, тип String, Class, экземпляр шаблонного типа Class, перечислимый тип, аннотационный тип или быть массивом элементов одного из перечисленных типов.

Свойство атрибутного типа может иметь один из типов bool, byte, char, double, float, int, long, short, string, object, System.Type, перечислимый тип или быть массивом элементов одного из таких типов.

У атрибутов может указываться цель, к которой они привязываются. Для атрибутов, помещаемых вне рамок пространств имен, указание такой цели — assembly — обязательно.

[assembly : MyAttribute ( id = 4627, author = "Victor Kuliamin" )]

В C# принято соглашение, согласно которому окончание Attribute в именах атрибутных типов может отбрасываться при использовании атрибутов такого типа.

Поэтому, имея атрибутный тип ClassAttribute, можно использовать в атрибутах как полное имя ClassAttribute, так и сокращенное Class.

В последнем случае компилятор будет пытаться найти атрибутный тип с именем Class или с именем ClassAttribute. При этом возможна неоднозначность — оба таких типа могут существовать в рамках сборки и доступных библиотек. Для ее разрешения можно использовать точное имя атрибутного типа с префиксом @. Увидев атрибут @Class, компилятор будет искать атрибутный тип в точности с именем Class.

public class A { public static <T> String getTypeName (T a) { if(a == null) return "NullType"; else return a.getClass().getName(); }

public static void main(String[] args) { String y = "ABCDEFG";

System.out.println( getTypeName(y) ); System.out.println ( getTypeName(y.length()) ); System.out.println ( A.<Character>getTypeName (y.charAt(1)) ); } }

public class A { public static string getTypeName<T> (T a) { if(a == null) return "NullType"; else return a.GetType().FullName; }

public static void Main() { string y = "ABCDEFG";

Console.WriteLine( getTypeName(y) ); Console.WriteLine ( getTypeName(y.Length) ); Console.WriteLine ( getTypeName<char>(y[1]) ); } }

В Java в качестве типовых аргументов могут использоваться только ссылочные типы.

Примитивный тип не может быть аргументом шаблона — вместо него нужно использовать соответствующий класс-обертку.

В C# любой тип может быть аргументом шаблона.

В Java типовые аргументы являются элементами конкретного объекта — они фактически представляют собой набор дополнительных параметров конструктора объекта или метода, если речь идет о шаблонном методе. Поэтому статические элементы шаблонного типа являются общими для всех экземпляров этого типа с разными типовыми аргументами.

В C# каждый экземпляр шаблонного класса, интерфейса или структурного типа с определенными аргументами имеет свой набор статических элементов, которые являются общими для всех объектов такого полностью определенного типа.

public class A<T> { public static int c = 0; public T t; }

public class B { public static void main (String[] args) { A.c = 7;

System.out.println( A.c ); } }

public class A<T> { public static int c = 0; public T t; }

public class B { public static void Main() { A<string>.c = 7;

Console.WriteLine( A<int>.c ); Console.WriteLine( A<string>.c ); } }

В C# можно определить и использовать шаблонные делегатные типы.

public delegate bool Predicate<T> (T value);

public class I { public bool m(int i) { return i == 0; }

public void f() { Predicate<int> pi = m; Predicate<string> ps = delegate(string s) { return s == null; }; } }

В Java это можно сделать двумя способами.

Первый — определить класс-наследник java.lang.Thread и перегрузить в этом классе метод public void run(). Этот метод, собственно, и будет выполняться в виде отдельного потока.

Другой способ — определить класс, реализующий интерфейс java.lang.Runnable и его метод void run(). После чего построить объект класса Thread на основе объекта только что определенного класса.

В обоих случаях для запуска выполнения потока нужно вызвать в объекте класса Thread (в первом случае — его наследника) метод void start().

В C# также можно использовать два способа. С помощью первого можно создать обычный поток, с помощью второго — поток, которому при запуске нужно передать какие-то данные.

Для этого нужно определить метод, который будет выполняться в рамках потока. Этот метод должен иметь тип результата void. Список его параметров в первом случае должен быть пустым, во втором — состоять из одного параметра типа object.

В первом варианте на основе этого метода создается делегат типа System.Threading.ThreadStart, во втором — типа System.Threading. ParameterizedThreadStart.

Этот делегат передается в качестве аргумента конструктору объекта класса System.Thread.

Поток запускается выполнением метода Start() у объекта класса Thread в первом случае, или метода Start(object) во втором.

class T extends Thread { int id = 0; public T(int id) { this.id = id; }

public void run() { System.out.println ("Thread " + id + " is working"); } }

public class A { public static void main(String[] args) { Thread th1 = new T(1), th2 = new T(2), th3 = new Thread( new Runnable() { public void run() { System.out.println ("Runnable is working"); } });

th1.start(); th2.start(); th3.start(); } }

using System; using System.Threading;

class T { int id; public T(int id) { this.id = id; }

public void m() { Console.WriteLine ("Thread " + id + " is working"); } }

public class A { static void m() { Console.WriteLine ("Nonparameterized thread" + " is working"); }

static void m(object o) { Console.WriteLine ("Thread with object " + o + " is working"); }

public static void Main() { Thread th1 = new Thread( new ThreadStart(m)), th2 = new Thread( new ThreadStart(new T(1).m)), th3 = new Thread( new ParameterizedThreadStart(m));

th1.Start(); th2.Start(); th3.Start(2); } }