static
Kotlin'de anahtar kelime yok .
static
Kotlin'de bir Java yöntemini temsil etmenin en iyi yolu nedir ?
static
Kotlin'de anahtar kelime yok .
static
Kotlin'de bir Java yöntemini temsil etmenin en iyi yolu nedir ?
Yanıtlar:
İşlevi "tamamlayıcı nesneye" yerleştirirsiniz.
Java kodu şöyle:
class Foo {
public static int a() { return 1; }
}
Olacak
class Foo {
companion object {
fun a() : Int = 1
}
}
Daha sonra Kotlin kodunun içinden kullanabilirsiniz.
Foo.a();
Ancak Java kodunun içinden, şu şekilde adlandırmanız gerekir:
Foo.Companion.a();
(Bu da Kotlin içinden çalışır.)
Biti belirtmek Companion
istemiyorsanız, bir @JvmStatic
ek açıklama ekleyebilir veya tamamlayıcı sınıfınızı adlandırabilirsiniz.
Gönderen docs :
Tamamlayıcı Nesneler
Sınıf içindeki nesne bildirimi tamamlayıcı anahtar kelimeyle işaretlenebilir:
class MyClass { companion object Factory { fun create(): MyClass = MyClass() } }
Tamamlayıcı nesnenin üyeleri, niteleyici olarak yalnızca sınıf adı kullanılarak çağrılabilir:
val instance = MyClass.create()
...
Ancak,
@JvmStatic
ek açıklama kullanıyorsanız, JVM'de tamamlayıcı nesnelerin üyelerini gerçek statik yöntemler ve alanlar olarak oluşturabilirsiniz . Daha fazla ayrıntı için Java ile birlikte çalışabilirlik bölümüne bakın.
@JvmStatic
Ek açıklama eklemek şöyle görünür
class Foo {
companion object {
@JvmStatic
fun a() : Int = 1;
}
}
ve hem Java hem de Kotlin'den erişilebilen gerçek bir Java statik fonksiyonu olarak mevcut olacaktır Foo.a()
.
Sadece Companion
ad için beğenilmezse , tamamlayıcı nesne için aşağıdaki gibi açık bir ad da sağlayabilirsiniz:
class Foo {
companion object Blah {
fun a() : Int = 1;
}
}
bu da Kotlin'den aynı şekilde çağırmanıza izin verecek, ancak java gibi Foo.Blah.a()
(Kotlin'de de çalışacak).
fun a(): Int { return 1 }
ya da olacakfun a(): Int = 1
fun a() = 1
.
Factory
, tamamlayıcı nesnenin adıdır - ancak bu ne için kullanılabilir? Hiçbir fikrim yok, ama bunun adanmış bir soru yarattı yüzden ilgi: stackoverflow.com/q/45853459/221955 .
Dokümanlar , statik işlevlere yönelik gereksinimlerin çoğunu paket düzeyi işlevlerle çözmenizi önerir . Bunlar, kaynak kod dosyasındaki bir sınıfın dışında bildirilir. Bir dosyanın paketi, paket anahtar sözcüğüyle bir dosyanın başında belirtilebilir.
deklarasyon
package foo
fun bar() = {}
kullanım
import foo.bar
alternatif olarak
import foo.*
Artık işlevi şu şekilde çağırabilirsiniz:
bar()
veya import anahtar sözcüğünü kullanmıyorsanız:
foo.bar()
Paketi belirtmezseniz, işleve kökten erişilebilir.
Sadece java ile deneyiminiz varsa, bu biraz garip görünebilir. Bunun nedeni kotlin'in kesinlikle nesneye yönelik bir dil olmamasıdır. Sınıfların dışındaki yöntemleri desteklediğini söyleyebilirsiniz.
Düzenleme: Belgeleri, artık paket düzeyinde işlevler önerme konusundaki cümleyi içermeyecek şekilde düzenlediler. Bu , yukarıda belirtilen orijinal.
class FooPackage
, tüm üst düzey özellik ve işlevlere sahip bir a oluşturur ve tüm referanslarınızı bunlara uygun şekilde yönlendirir. Jetbrains'den daha fazla bilgi.
bar()
dosya adının önemli olmadığını, BarUtils.kt
ya da herhangi bir şeyi adlandırabileceğinizi açıklığa kavuşturmak istedim , o zaman metnin dediği gibiimport <package name>.bar
A. Eski Java Yolu:
companion object
Statik bir yöntemi / değişkeni kapsayacak şekilde a bildirme
class Foo{
companion object {
fun foo() = println("Foo")
val bar ="bar"
}
}
Kullanım:
Foo.foo() // Outputs Foo
println(Foo.bar) // Outputs bar
B. Yeni Kotlin yolu
Bir dosya üzerinde sınıf olmadan doğrudan dosya üzerinde bildir .kt
.
fun foo() = println("Foo")
val bar ="bar"
İsimlerimethods/variables
ile kullanın . ( İçe aktardıktan sonra )
Kullanım:
foo() // Outputs Foo
println(bar) // Outputs bar
INSTANCE
anahtar kelimeye sahip olmalıdır :Foo.INSTANCE.sayFoo()
static CLASS
sadece bir çözüm istemiyorsanız bu çözüm tercih edilir static methdos
. Çünkü, tamamlayıcı nesnelerle yine de ana sınıfı başlatabilirsiniz.
val
statik değil static final
Java ile eşdeğer
Statik yapmak için val / var / yöntemini temsil eden nesneyi kullanın . Singleton sınıfı yerine nesne de kullanabilirsiniz. Bir sınıfın içinde statik yapmak istiyorsanız tamamlayıcıyı kullanabilirsiniz
object Abc{
fun sum(a: Int, b: Int): Int = a + b
}
Java'dan aramanız gerekirse:
int z = Abc.INSTANCE.sum(x,y);
Kotlin'de INSTANCE'ı görmezden gelin.
object objectName {
fun funName() {
}
}
Statik yöntem için tamamlayıcı nesneyi iletmeniz gerekir, çünkü kotlin'in statik anahtar sözcüğü yoktur - Tamamlayıcı nesnenin üyeleri, niteleyici olarak yalnızca sınıf adı kullanılarak çağrılabilir:
package xxx
class ClassName {
companion object {
fun helloWord(str: String): String {
return stringValue
}
}
}
Kotlin'de statik uygulamak için 2 yol vardır
Önce sınıfın altında bir tamamlayıcı nesne oluşturun
Örneğin:
class Test{
companion object{
fun isCheck(a:Int):Boolean{
if(a==0) true else false
}
}
}
bu işlevi şu adla
Test.Companion.isCheck(2)
Kullanabileceğimiz başka bir yol da bir nesne sınıfı yapmaktır
object Test{
fun isCheck(a:Int):Boolean{
if(a==0) true else false
}
}
Mutlu Kodlama!
Test.Companion.isCheck(2)
) IDE uyarıları gösterir ve söyler Companion reference is redundant
. İndirgenebilir Test.isCheck(2)
ve indirgenmiş form java eşdeğerine daha yakındır.
Kotlin'in statik anahtar kelimesi yok. Java için kullandın
class AppHelper {
public static int getAge() {
return 30;
}
}
ve Kotlin için
class AppHelper {
companion object {
fun getAge() : Int = 30
}
}
Java Çağrısı
AppHelper.getAge();
Kotlin Çağrısı
AppHelper.Companion.getAge();
Bence mükemmel çalışıyor.
Yukarıdaki cevaplara bir şeyler eklemek istiyorum.
Evet, işlevleri kaynak kod dosyalarında (sınıf dışında) tanımlayabilirsiniz. Ancak, sınıf içinde Companion Object kullanarak statik fonksiyonlar tanımlamanız daha iyidir, çünkü Kotlin Uzantılarını kullanarak daha fazla statik fonksiyon ekleyebilirsiniz .
class MyClass {
companion object {
//define static functions here
}
}
//Adding new static function
fun MyClass.Companion.newStaticFunction() {
// ...
}
Companion Object içindeki herhangi bir fonksiyonu çağıracağınız için yukarıda tanımlanan fonksiyonu çağırabilirsiniz.
Bu 2 yıldan biraz eski olmasına rağmen ve çok sayıda harika cevabı olmasına rağmen, "statik" Kotlin alanlarının eksik olmasının başka yollarını görüyorum. Kotlin-Java static
birlikte çalışma için örnek bir kılavuz :
Senaryo 1: Kotlin'de Java için statik bir yöntem oluşturma
Kotlin
@file:JvmName("KotlinClass") //This provides a name for this file, so it's not defaulted as [KotlinClassKt] in Java package com.frybits class KotlinClass { companion object { //This annotation tells Java classes to treat this method as if it was a static to [KotlinClass] @JvmStatic fun foo(): Int = 1 //Without it, you would have to use [KotlinClass.Companion.bar()] to use this method. fun bar(): Int = 2 } }
Java
package com.frybits; class JavaClass { void someFunction() { println(KotlinClass.foo()); //Prints "1" println(KotlinClass.Companion.bar()); //Prints "2". This is the only way to use [bar()] in Java. println(KotlinClass.Companion.foo()); //To show that [Companion] is still the holder of the function [foo()] } //Because I'm way to lazy to keep typing [System.out], but I still want this to be compilable. void println(Object o) { System.out.println(o); } }
Michael Anderson'ın cevabı bundan daha fazla derinlik sağlar ve bu senaryo için kesinlikle referans verilmelidir.
Bir sonraki senaryo, Java'nın KotlinClass.foo()
statik bir işlev istemediğiniz durumlar için çağrı yapmaya devam etmesi için Kotlin'de statik alanlar oluşturmayı ele alır .
Senaryo 2: Kotlin'de Java için statik değişken oluşturma
Kotlin
@file:JvmName("KotlinClass") //This provides a name for this file, so it's not defaulted as [KotlinClassKt] in Java package com.frybits class KotlinClass { companion object { //This annotation tells Kotlin to not generate the getter/setter functions in Java. Instead, this variable should be accessed directly //Also, this is similar to [@JvmStatic], in which it tells Java to treat this as a static variable to [KotlinClass]. @JvmField var foo: Int = 1 //If you want something akin to [final static], and the value is a primitive or a String, you can use the keyword [const] instead //No annotation is needed to make this a field of [KotlinClass]. If the declaration is a non-primitive/non-String, use @JvmField instead const val dog: Int = 1 //This will be treated as a member of the [Companion] object only. It generates the getter/setters for it. var bar: Int = 2 //We can still use [@JvmStatic] for 'var' variables, but it generates getter/setters as functions of KotlinClass //If we use 'val' instead, it only generates a getter function @JvmStatic var cat: Int = 9 } }
Java
package com.frybits; class JavaClass { void someFunction() { //Example using @JvmField println(KotlinClass.foo); //Prints "1" KotlinClass.foo = 3; //Example using 'const val' println(KotlinClass.dog); //Prints "1". Notice the lack of a getter function //Example of not using either @JvmField, @JvmStatic, or 'const val' println(KotlinClass.Companion.getBar()); //Prints "2" KotlinClass.Companion.setBar(3); //The setter for [bar] //Example of using @JvmStatic instead of @JvmField println(KotlinClass.getCat()); KotlinClass.setCat(0); } void println(Object o) { System.out.println(o); } }
Kotlin'in en önemli özelliklerinden biri, üst düzey işlevler ve değişkenler oluşturabilmenizdir. Bu, static
Java'da işlevler / alanlar olarak kullanılabilen sabit alanların ve işlevlerin "sınıfsız" listelerini oluşturmayı mükemmelleştirir .
Senaryo 3: Kotlin'de üst düzey alanlara ve işlevlere Java'dan erişme
Kotlin
//In this example, the file name is "KSample.kt". If this annotation wasn't provided, all functions and fields would have to accessed //using the name [KSampleKt.foo()] to utilize them in Java. Make life easier for yourself, and name this something more simple @file:JvmName("KotlinUtils") package com.frybits //This can be called from Java as [KotlinUtils.TAG]. This is a final static variable const val TAG = "You're it!" //Since this is a top level variable and not part of a companion object, there's no need to annotate this as "static" to access in Java. //However, this can only be utilized using getter/setter functions var foo = 1 //This lets us use direct access now @JvmField var bar = 2 //Since this is calculated at runtime, it can't be a constant, but it is still a final static variable. Can't use "const" here. val GENERATED_VAL:Long = "123".toLong() //Again, no need for @JvmStatic, since this is not part of a companion object fun doSomethingAwesome() { println("Everything is awesome!") }
Java
package com.frybits; class JavaClass { void someFunction() { println(KotlinUtils.TAG); //Example of printing [TAG] //Example of not using @JvmField. println(KotlinUtils.getFoo()); //Prints "1" KotlinUtils.setFoo(3); //Example using @JvmField println(KotlinUtils.bar); //Prints "2". Notice the lack of a getter function KotlinUtils.bar = 3; //Since this is a top level variable, no need for annotations to use this //But it looks awkward without the @JvmField println(KotlinUtils.getGENERATED_VAL()); //This is how accessing a top level function looks like KotlinUtils.doSomethingAwesome(); } void println(Object o) { System.out.println(o); } }
Java'da "statik" alanlar olarak kullanılabilecek bir diğer dikkat çekici nokta Kotlin'dir. object
sınıflarıdır. Bunlar, ilk kullanımda tembel olarak başlatılan sıfır parametreli singleton sınıflarıdır. Onlar hakkında daha fazla bilgiyi burada bulabilirsiniz: https://kotlinlang.org/docs/reference/object-declarations.html#object-declarations
Bununla birlikte, singleton'a erişmek için INSTANCE
, olduğu gibi başa çıkmak için hantal olan özel bir nesne yaratılır Companion
. static
Java'da bu temiz hissi vermek için ek açıklamaları nasıl kullanacağınız aşağıda açıklanmıştır :
Senaryo 4:
object
Sınıfları kullanmaKotlin
@file:JvmName("KotlinClass") //This provides a name for this file, so it's not defaulted as [KotlinClassKt] in Java package com.frybits object KotlinClass { //No need for the 'class' keyword here. //Direct access to this variable const val foo: Int = 1 //Tells Java this can be accessed directly from [KotlinClass] @JvmStatic var cat: Int = 9 //Just a function that returns the class name @JvmStatic fun getCustomClassName(): String = this::class.java.simpleName + "boo!" //Getter/Setter access to this variable, but isn't accessible directly from [KotlinClass] var bar: Int = 2 fun someOtherFunction() = "What is 'INSTANCE'?" }
Java
package com.frybits; class JavaClass { void someFunction() { println(KotlinClass.foo); //Direct read of [foo] in [KotlinClass] singleton println(KotlinClass.getCat()); //Getter of [cat] KotlinClass.setCat(0); //Setter of [cat] println(KotlinClass.getCustomClassName()); //Example of using a function of this 'object' class println(KotlinClass.INSTANCE.getBar()); //This is what the singleton would look like without using annotations KotlinClass.INSTANCE.setBar(23); println(KotlinClass.INSTANCE.someOtherFunction()); //Accessing a function in the object class without using annotations } void println(Object o) { System.out.println(o); } }
Kısa yapmak için, "tamamlayıcı nesne" yi Kotlin statik dünyasına girmek için kullanabilirsiniz :
companion object {
const val TAG = "tHomeFragment"
fun newInstance() = HomeFragment()
}
ve sabit bir alan oluşturmak için kodda olduğu gibi "const val" kullanın . ancak Mockito kullanarak birim testinde zorluklar yarattığı için statik sınıflardan kaçınmaya çalışın.
Java statik yönteminin kotlin eşdeğerine tam dönüşümü böyle olacaktır. Örneğin burada util sınıfı, hem java hem de kotlin'e eşdeğer olacak bir statik yönteme sahiptir. @JvmStatic kullanımı önemlidir.
Java kodu:
class Util{
public static String capitalize(String text){
return text.toUpperCase();}
}
Kotlin kodu:
class Util {
companion object {
@JvmStatic
fun capitalize(text:String): String {
return text.toUpperCase()
}
}
}
Sadece bir tamamlayıcı nesne oluşturmanız ve işlevi içine koymanız gerekir
class UtilClass {
companion object {
// @JvmStatic
fun repeatIt5Times(str: String): String = str.repeat(5)
}
}
Yöntemi bir kotlin sınıfından çağırmak için:
class KotlinClass{
fun main(args : Array<String>) {
UtilClass.repeatIt5Times("Hello")
}
}
veya İçe aktarmayı kullanma
import Packagename.UtilClass.Companion.repeatIt5Times
class KotlinClass{
fun main(args : Array<String>) {
repeatIt5Times("Hello")
}
}
Bir java sınıfından yöntemi çağırmak için:
class JavaClass{
public static void main(String [] args){
UtilClass.Companion.repeatIt5Times("Hello");
}
}
veya yönteme @JvmStatic ek açıklama ekleyerek
class JavaClass{
public static void main(String [] args){
UtilClass.repeatIt5Times("Hello")
}
}
veya her ikisine de yönteme @JvmStatic ek açıklama ekleyerek ve java'da statik içe aktarma yaparak
import static Packagename.UtilClass.repeatIt5Times
class JavaClass{
public static void main(String [] args){
repeatIt5Times("Hello")
}
}
Java için:
public class Constants {
public static final long MAX_CLICK_INTERVAL = 1000;}
Eşdeğer Kotlin kodu:
object Constants {
const val MAX_CLICK_INTERVAL: Long = 1000}
Yani Java statik yöntemleri eşdeğer için Kotlin nesne sınıfıdır.
Android için tek bir etkinlikten gerekli tüm etkinliğe bir dize kullanma. Java'daki statik gibi
public final static String TEA_NAME = "TEA_NAME";
Kotlin'de eşdeğer yaklaşım:
class MainActivity : AppCompatActivity() {
companion object {
const val TEA_NAME = "TEA_NAME"
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
}
}
Değere ihtiyaç duyulan bir başka faaliyet:
val teaName = MainActivity.TEA_NAME
Michael Anderson'ın yanıtı dışında, projemde diğer iki yolla kodlama yapıyorum.
tüm değişkenleri bir sınıfa beyazlayabilirsiniz. Const adlı bir kotlin dosyası oluşturdu
object Const {
const val FIRST_NAME_1 = "just"
const val LAST_NAME_1 = "YuMu"
}
Kotlin ve java kodlarında kullanabilirsiniz
Log.d("stackoverflow", Const.FIRST_NAME_1)
Kotlin'in dahili fonksiyonunu kullanarak Ext adında bir kotlin dosyası yarattı code Aşağıdaki kod Ext dosyasındaki tüm kodlardır
package pro.just.yumu
/**
* Created by lpf on 2020-03-18.
*/
const val FIRST_NAME = "just"
const val LAST_NAME = "YuMu"
Kotlin kodunda kullanabilirsiniz
Log.d("stackoverflow", FIRST_NAME)
Java kodunda kullanabilirsiniz
Log.d("stackoverflow", ExtKt.FIRST_NAME);
Bunları doğrudan dosyalara yazın.
Java dilinde (çirkin):
package xxx;
class XxxUtils {
public static final Yyy xxx(Xxx xxx) { return xxx.xxx(); }
}
Kotlin'de:
@file:JvmName("XxxUtils")
package xxx
fun xxx(xxx: Xxx): Yyy = xxx.xxx()
Bu iki kod parçası derlemeden sonra eşitlenir (derlenmiş dosya adı bile, derlenmiş dosya adını file:JvmName
kontrol etmek için kullanılır ve paket adı bildiriminden hemen önce konulmalıdır).
@JVMStatic
Ek Açıklama Kullan
companion object {
// TODO: Rename and change types and number of parameters
@JvmStatic
fun newInstance(param1: String, param2: String) =
EditProfileFragment().apply {
arguments = Bundle().apply {
putString(ARG_PARAM1, param1)
putString(ARG_PARAM2, param2)
}
}
}
Bir sınıf öğrenciniz olsun . Ve birine sahip statik yöntemini getUniversityName () & tek statik olarak adlandırılan alan totalStudent .
Sınıfınızdaki tamamlayıcı nesne bloğunu bildirmelisiniz .
companion object {
// define static method & field here.
}
Sonra sınıfın benziyor
class Student(var name: String, var city: String, var rollNumber: Double = 0.0) {
// use companion object structure
companion object {
// below method will work as static method
fun getUniversityName(): String = "MBSTU"
// below field will work as static field
var totalStudent = 30
}
}
Sonra bu statik yöntemi ve bu şekilde alanları kullanabilirsiniz.
println("University : " + Student.getUniversityName() + ", Total Student: " + Student.totalStudent)
// Output:
// University : MBSTU, Total Student: 30
Kotlin'de statik bir anahtar kelime yok. kotlin docs, DRY'yi takip etmek istiyorsanız paket seviyesi işlevlerini kullanmanızı önerir. .Kt uzantılı bir dosya oluşturun ve yönteminizi içine yerleştirin.
package p
fun m(){
//fun body
}
derleme m sonra bir imzası olacak kamu statik nihai boşluk
ve
import p.m
☺
Companion Objects tarafından Kotlin'de statik işlevsellik elde edebilirsiniz
Bir arkadaşı nesne sınıfının dışında ilan edilemez.
class MyClass{
companion object {
val staticField = "This is an example of static field Object Decleration"
fun getStaticFunction(): String {
return "This is example of static function for Object Decleration"
}
}
}
Tamamlayıcı nesnenin üyeleri, niteleyici olarak yalnızca sınıf adı kullanılarak çağrılabilir:
Çıktı:
MyClass.staticField // This is an example of static field Object Decleration
MyClass.getStaticFunction() : // This is an example of static function for Object Decleration
Bir çok insan doğru nesnelerden bahseder, ki bu doğrudur. Ancak, bildiğiniz gibi, herhangi bir nesne türünü de kullanabilirsiniz (sınıf yerine object anahtar sözcüğünü kullanarak),
object StringUtils {
fun toUpper(s: String) : String { ... }
}
Java'daki herhangi bir statik yöntem gibi kullanın:
StringUtils.toUpper("foobar")
Kotlin'de bu tür bir desen işe yaramaz, güçlü yanlarından biri statik yöntemlerle dolu sınıflara duyulan ihtiyaçtan kurtulmasıdır. Kullanım durumunuza bağlı olarak bunun yerine genel, genişletme ve / veya yerel işlevleri kullanmak daha uygundur. Çalıştığım yerde genellikle global uzantı işlevlerini adlandırma kuralına sahip ayrı, düz bir dosyada tanımlıyoruz: [className] Extensions.kt yani, FooExtensions.kt. Ancak daha tipik olarak, işlevleri kendi sınıflarında veya nesnelerinde ihtiyaç duydukları yerde yazarız.
Java ile aşağıdaki şekilde yazabiliriz
class MyClass {
public static int myMethod() {
return 1;
}
}
Kotlin'de aşağıdaki şekilde yazabiliriz
class MyClass {
companion object {
fun myMethod() : Int = 1
}
}
bir arkadaşı Kotlin'de statik olarak kullanılır.
Kotlin belge sağlayıcısı bunu yapmanın üç yolu, birincisi sınıfta paket olmadan işlevi tanımlamaktır:
package com.example
fun f() = 1
ikincisi @JvmStatic ek açıklaması kullanmaktır:
package com.example
class A{
@JvmStatic
fun f() = 1
}
ve üçüncüsü, tamamlayıcı nesneyi kullanın:
package com.example
clss A{
companion object{
fun f() = 1
}
}
Bir işleve veya bir özelliğin, örneklerinden ziyade bir sınıfa bağlanması gerekiyorsa, bunu bir tamamlayıcı nesnenin içinde bildirebilirsiniz:
class Car(val horsepowers: Int) {
companion object Factory {
val cars = mutableListOf<Car>()
fun makeCar(horsepowers: Int): Car {
val car = Car(horsepowers)
cars.add(car)
return car
}
}
}
Tamamlayıcı nesne tek bir öğedir ve üyelerine doğrudan kapsayıcı sınıfın adı üzerinden erişilebilir
val car = Car.makeCar(150)
println(Car.Factory.cars.size)
Sen kullanabilirsiniz Companion Nesneleri - kotlinlang
İlk önce bu Arabirimi oluşturarak gösterilebilir
interface I<T> {
}
O zaman bu arayüzün içinde bir işlev yapmalıyız:
fun SomeFunc(): T
Sonra bir sınıfa ihtiyacımız var:
class SomeClass {}
o sınıfın içinde, o sınıfın içinde bir yardımcı nesneye ihtiyacımız var:
companion object : I<SomeClass> {}
bu Yardımcı Nesnenin içinde o eski SomeFunc
işleve ihtiyacımız var , Ama aşırı sürmemiz gerekiyor:
override fun SomeFunc(): SomeClass = SomeClass()
Sonunda tüm bu işin altında, bu Statik fonksiyona güç verecek bir şeye ihtiyacımız var, bir değişkene ihtiyacımız var:
var e:I<SomeClass> = SomeClass()