Vom Java-Enwickler zum VB.NET-Experten in 21 Minuten

• Klassen, Interfaces, Enums: CamelCase
• Methoden, lokale Variablen, Felder: mixedCamelCase
• Konstanten, Enum-Werte: UPPER_CASE

• Klassen, Strukturen, Namensräume: CamelCase
• Interfaces: ICamelCase
• Private Methoden, lokale Variablen, Felder: mixedCamelCase
• Öffentliche Methoden, Properties: CamelCase
• Konstanten, Enum-Werte: CamelCase

import java.io.*;

package org.foo.bar;

// ...

Imports System.IO

Namespace Foo.Bar
    ' ...
End Namespace

/**
 * ...
 */

''' <summary>
''' ...
''' </summary>

int
short
long
boolean
char
byte
double
float
(n/a)
java.math.BigInteger

Integer
Short
Long
Boolean
Char
SByte
Double
Single
Decimal (128 bit)
System.Numerics.BigInteger

String
Object
Class

String
Object
Type

null
true, false
"abc"
'D'
0xFF
2.9f
3.14159265
123456L

Nothing
True, False
"abc"
"D"c
&HFF
2.9!
3.14159265
123456L

Foo foo;
Foo foo = new Foo();


int i = 42;

Dim foo As Foo
Dim foo As Foo = new Foo()
Dim foo As new Foo()        ' etwas kürzer
Dim foo = new Foo()         ' mit Typinferenz per "Option Infer On", sonst Typ Object
Dim i As Integer = 42       ' ohne Typinferenz
Dim i = 42                  ' mit Typinferenz per "Option Infer On", sonst Typ Object

final
static final

ReadOnly        ' Darf im Konstruktor gesetzt werden
Const

int[] numbers;
int[][] numbers;
int[][][] numbers;



int[] numbers = new int[6];

numbers[0]
numbers[5]

new int[] {1, 2, 4, 8}

Dim numbers() As Integer
Dim numbers()() As Integer      ' "Ausgefranstes" mehrdimensionales Array
                                ' ("Array von Arrays")
Dim numbers()()() As Integer    ' "Ausgefranstes" mehrdimensionales Array
                                ' ("Array von Arrays von Arrays")
Dim numbers(,) As Integer       ' "Rechteckiges" mehrdimensionales Array
                                ' (Ein zusammenhängender Block)
Dim numbers(,,) As Integer      ' "Rechteckiges" mehrdimensionales Array
                                ' (Ein zusammenhängender Block)

Dim numbers(5) As Integer       ' ACHTUNG: Zahl gibt letzten Index an,
                                           nicht Anzahl der Elemente

numbers(0)
numbers(5)

New Integer() {1, 2, 4, 8}
{1.5, 2, 9.9, 18}               ' Mit Typinferenz (hier: Double-Array,
                                ' da Double der dominante Typ ist)

+, -, *
/ (float)
/ (int)
%

Math.pow(x, y)

+, -, *
/
\
Mod

x ^ y

=
+=, -=, *=
/= (float)
/= (int)
(n/a)
++, --

=
+=, -=, *=
/=
\=
<<=, >>=
(n/a)

+
+=

&
&=

&&
||
!

AndAlso (short-circuit evaluation, wie in Java), And
OrElse (short-circuit evaluation, wie in Java), Or
Not

&, |
~
^
<<, >>
>>>

And, Or
Not
Xor
<<, >>
(n/a)

>, <
==
!=
a.equals(b)
!a.equals(b)
==
!=

>, <
=       ' Werte
<>      ' Werte
=       ' Objekte
<>      ' Objekte
Is      ' Referenz-Gleichheit von Objekten
IsNot   ' Referenz-Ungleichheit von Objekten

condition ? a : b

If(condition, a, b)

new
o instanceof Foo

New
TypeOf o Is Foo

(Foo) bar
bar instanceof Foo ? (Foo) bar : null
*.valueOf()

DirectCast(bar, Foo)
TryCast(bar, Foo)       ' "Nothing" als Fallback
CType(bar, Foo)         ' mit Konversion

' Zusätzlich Kurzformen von "CType" für Standardtypen:
CBool(bar), CByte(bar), CChar(bar), CDate(bar), CDbl(bar), CDec(bar), CInt(bar),
CLng(bar), CObj(bar), CSByte(bar), CShort(bar), CSng(bar), CStr(bar), CUInt(bar),
CULng(bar), CUShort(bar)

for (Foo foo : bar) {
}

for (int i = 1; i <= n; i++) {
}

for (int i = n; i >= 0; i -= 2) {
}

while (condition) {
}

do {
} while (condition);

do {
} while (!condition);

continue
break

For Each foo In bar
Next

For i As Integer = 1 To n
Next

For i As Integer = n To 0 Step -2
Next

While condition
End While

Do
Loop While condition

Do
Loop Until condition

Continue For, Continue Do, Continue While, ...
Exit For, Exit Do, Exit While, ...

if (condition) {
} else if (condition) {
} else {
}

If condition Then  ' Then ist optional bei mehrzeiligem If
ElseIf condition Then
Else
End If

switch (number) {
case 1:
    // ...
    break;
default:
    // ...
}

Select Case number
    Case 1 To 5
        Debug.WriteLine("Between 1 and 5, inclusive")
    Case 6, 7, 8
        Debug.WriteLine("Between 6 and 8, inclusive")
    Case 9 To 10
        Debug.WriteLine("Equal to 9 or 10")
    Case Else
        Debug.WriteLine("Not between 1 and 10, inclusive")
End Select

throw new Exception("")

Throw New Exception("")

try {
} catch (Exception e) {
} finally {
}

Try
Catch e As Exception
Finally
End Try

IllegalArgumentException
NullPointerException
UnsupportedOperationException
IOException

ArgumentException, ArgumentNullException, ArgumentOutOfRangeException
NullReferenceException
NotSupportedException, NotImplementedException
IOException

try (Resource resource = new Resource()) {
}

Using resource As New Resource()
End Using

class
interface
extends
implements
enum



final
abstract (Klasse)


this
super

Foo.class
foo.getClass()

Class       ... End Class
Interface   ... End Interface
Inherits                       (muss in nächste Zeile oder mit : getrennt werden)
Implements                     (muss in nächste Zeile oder mit : getrennt werden)
Enum        ... End Enum       (keine Konstruktoren/Methoden)
Module      ... End Module     (entspricht Klasse mit nur statischen Methoden)
Structure   ... End Structure  (Value Type: copy-on-assignment, keine Vererbung)

NotInheritable
MustInherit
Partial         (Klasse, die auf mehrere Dateien verteilt ist)

Me
MyBase

GetType(Foo)
foo.GetType()

Foo<T>
Foo<K, V>

Foo(Of T)
Foo(Of K, V)

Foo<? extends Bar>
Foo<? super Bar>

Foo(Of Out Bar)
Foo(Of In Bar)

public Foo() {
    super();
}

public Foo() {
    this(42);
}

Public Sub New()
    MyBase.New()
End Sub

Public Sub New()
    Me.New(42)
End Sub

public
private
protected
(default)

Public
Private
Protected
Friend

abstract
static
final
(default)

@Override

MustOverride
Shared
NotOverridable (default)
Overridable

Overrides

public int name(double a, String b) {
    return 1;
}

Public Function Name(ByVal a As Double, ByVal b As String) As Integer
    Return 1
End Function

public void bla() {
}

Public Sub Bla()
End Sub

foo.bar()
new Foo()

foo.Bar()  oder kürzer:  foo.Bar
New Foo()  oder kürzer:  New Foo

...

public double calcSum(double... args) {
}

ParamArray

Public Function CalcSum(ByVal ParamArray args() As Double) As Double
End Function

Public Function MyFun(ByVal s As String, Optional ByVal b As Boolean = False) As Integer
End Function

{ x -> x + 1 }

{ x ->
    return x + 2
}

Closure



&methodName

Function(x) x + 1

Function(x)
    Return x + 2
End Function

Func(Of T, TResult)
Func(Of T1, T2, T3, TResult)
Func(Of Integer, Boolean)

AddressOf MethodName

public class Foo {
    private int bar;

    public int getBar() {
        return this.bar;
    }

    public void setBar(int bar) {
        this.bar = bar;
    }
}

' Kurzform (automatisch implementiert):

Public Class Foo
    Public Property Bar As Integer
End Class

' Langform (erlaubt custom Getter und Setter):

Public Class Foo
    Private bar As Integer

    Public Property Bar() As Integer
        Get
            Return bar
        End Get
        Set(ByVal value As Integer)
            bar = value
        End Set
    End Property
End Class

public class Foo {
    private int bar;

    public int getBar() {
        return this.bar;
    }
}

Public Class Foo
    Private bar As Integer

    Public ReadOnly Property Bar() As Integer
        Get
            Return bar
        End Get
    End Property
End Class

public class Foo {
    private int bar;

    public void setBar(int value) {
        this.bar = value;
    }
}

Public Class Foo
    Private bar As Integer

    Public WriteOnly Property Bar() As Integer
        Set(ByVal value As Integer)
            bar = value
        End Set
    End Property
End Class

Dim bob = New With {.Name = "Uncle Bob", .Age = 42}
Dim bob = New With {Key .Name = "Uncle Bob", .Age = 42}  
                   'Key Properties werden für Equals mit einbezogen

Person bob = new Person();
bob.setAge(42);
bob.setName("Bob");

Dim bob As New Person {.Age = 42, .Name = "Bob"}


Dim bob As New Person
With bob
    .Age = 42
    .Name = "Bob"
End With

.hashCode()
.equals(o)
.toString()

.GetHashCode()
.Equals(o)
.ToString()

Comparable
Comparator
Closeable
Serializable

IComparable
IComparer
IDisposable
ISerializable

Iterable<T>
Iterator<T>
.iterator()
Collection<T>
List<T>
ArrayList<T>
LinkedList<T>
Set<T>
HashSet<T>
HashMap<K, V>

IEnumerable(Of T)
IEnumerator(Of T)
.GetEnumerator()
ICollection(Of T)
IList(Of T)
List(Of T)
LinkedList(Of T)
ISet(Of T)
HashSet(Of T)
Dictionary(Of K, V)

New Dictionary(Of Integer, String) From {{0, "Sunday"}, {1, "Monday"}}
New List(Of String) From {"Sunday", "Monday"}

.any {}
.every {}
.collect {}
.findAll {}

.Any(Function(it) condition)    ' ergibt Boolean
.All(Function(it) condition)    ' ergibt Boolean
.Select(Function(x) result)     ' ergibt neue Collection
.Where(Function(it) condition)  ' ergibt neue Collection

Dim customersForRegion = From cust In customers Where cust.Region = region

System.out.println()

System.Console.WriteLine()

Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        // do something
    }
});
thread.start();

Private Shared Sub DoWork()
    ' do something
End Sub

Dim thread As New Thread(AddressOf DoWork)
thread.Start()

synchronized (obj) {
}

SyncLock obj
End SyncLock

java.lang.StringBuilder
java.util.Date
java.io.File
java.io.InputStream, OutputStream

System.Text.StringBuilder
System.DateTime
System.IO.File (statische Methoden)
System.IO.Stream

public class EventSource {
    private ListenerHandler<LogonListener> listeners;

    public EventSource() {
        super();
        this.listeners = new ListListenerHandler<LogonListener>();
    }

    public void addLogonListener(LogonListener listener) {
        this.listeners.add(listener);
    }

    public void removeLogonListener(LogonListener listener) {
        this.listeners.remove(listener);
    }

    public void causeEvent() {
        this.listeners.notifyAll(new Notifier<LogonListener>() {
            @Override
            public void performNotification(LogonListener listener) {
                listener.logonCompleted("e");
            }
        });
    }

    public interface LogonListener {
        public void logonCompleted(String userName);
    }
}

Public Class EventSource
    Public Event LogonCompleted(ByVal userName As String)

    Public Sub CauseEvent()
        RaiseEvent LogonCompleted("e")
    End Sub
End Class

void testEvents() {
    EventSource obj = new EventSource();
    LogonHandler eventHandler = new LogonHandler();
    obj.addLogonListener(eventHandler);
    obj.causeEvent();
    obj.removeLogonListener(eventHandler);
    obj.causeEvent();
}

private class EventHandler implements LogonListener {
    @Override
    public void logonCompleted(String userName) {
        System.out.println("User logon: " + userName);
    }
}

Sub TestEvents()
    Dim obj As New EventSource()
    AddHandler obj.LogonCompleted, AddressOf EventHandler
    obj.CauseEvent()
    RemoveHandler obj.LogonCompleted, AddressOf EventHandler
    obj.CauseEvent()
End Sub


Sub EventHandler(ByVal userName As String)
    Console.WriteLine("User logon: " & userName)
End Sub

Public Class EventDemo
    WithEvents obj As New EventSource()    

    Public Sub TestEvents()
        obj.CauseEvent()
    End Sub

    Sub EventHandler(ByVal userName As String) Handles obj.LogonCompleted
        Console.WriteLine("User logon: " & userName)
    End Sub
End Class

@Foo(true)

<Foo(True)>

Imports System.Runtime.CompilerServices

<Extension()>
Public Shared Sub Print(ByVal aString As String)
    Console.WriteLine(aString)
End Sub

Public Shared Operator +(ByVal a As Foo, ByVal b As Foo) As Foo
    Return '...
End Operator

native

Declare

Declare Function getUserName Lib "advapi32.dll" Alias "GetUserNameA" ( _
    ByVal lpBuffer As String, ByRef nSize As Integer) As Integer