Son kullanma tarihi geçmiş, bayatlamış bir tarayıcı kullanıyorsanız, Mercedes kullanmak yerine tosbağaya binmek gibi... Web sitelerini düzgün görüntüleyemiyorsanız eh, bi' zahmet tarayıcınızı güncelleyiniz. Modern Web standartlarını karşılayan bir tarayıcı alternatifine göz atın.
JavaKotlin'de controller sınıfına model sınıfını nasıl bağlayabiliriz?
Hocam kendi başıma çalışıyorum da. Basitçe bir sınıf ve o sınıfı kontrol eden bir sınıf tasarımı. Direkt MVC demek ne kadar mantıklı olur bilemem tabi. Spring ile şu an alakası yoktur. Tabi İngilizce seviyem, sizi sizden alabilir ve cringe olabilirsiniz.
Controller diger modelleri hukmeden birisi gibi degil de trafigi yonlendiren bir yapidir MVC'de. Yani model alir, o modeli process edecek kimse ona gorevi delege eder ve sonucu return eder.
Ornegin sen "islem" diye bir "String" alan tutmussun. Eger OOP yapacaksan bunun Enum, Interface ya da sealed class olmasi gerekir.
Kotlin'in null safety ozelliklerinden faydalanman icin de bunlari nullable yapmamalisin. Bir hesaplama isleminden bahsedebilmemiz icin en az 1 parametreye ( 2 parametre zorunlu olmayabilir bazi islemlerde, dogal logaritma gibi ) ve islemin ne olduguna ihtiyacimiz var. O halde bu null olamaz.
Ornegin soyle bir yapi hem OOP hem de MVC acisindan baslangicta ogretici olabilir.
Kod:
sealed class Operation(open val lhs: Int, open val rhs: Int)
class Multiplication(override val lhs: Int, override val rhs: Int) : Operation(lhs, rhs)
class Subtraction(override val lhs: Int, override val rhs: Int) : Operation(lhs, rhs)
// ... diger islemler, log, exp vs.
data class Input(val lhs: Int, val rhs: Int)
data class Calculation(val input: Input, val operation: Operation)
data class Result(val numeric: Int)
class CalculatorController {
fun calculate(calculation: Calculation): Result {
/**
* Calculation -> input model
* Result -> output Model
*/
val op = calculation.operation
// hesap kitap
return Result(10)
}
}
Controller diger modelleri hukmeden birisi gibi degil de trafigi yonlendiren bir yapidir MVC'de. Yani model alir, o modeli process edecek kimse ona gorevi delege eder ve sonucu return eder.
Ornegin sen "islem" diye bir "String" alan tutmussun. Eger OOP yapacaksan bunun Enum, Interface ya da sealed class olmasi gerekir.
Kotlin'in null safety ozelliklerinden faydalanman icin de bunlari nullable yapmamalisin. Bir hesaplama isleminden bahsedebilmemiz icin en az 1 parametreye ( 2 parametre zorunlu olmayabilir bazi islemlerde, dogal logaritma gibi ) ve islemin ne olduguna ihtiyacimiz var. O halde bu null olamaz.
Ornegin soyle bir yapi hem OOP hem de MVC acisindan baslangicta ogretici olabilir.
Kod:
sealed class Operation(open val lhs: Int, open val rhs: Int)
class Multiplication(override val lhs: Int, override val rhs: Int) : Operation(lhs, rhs)
class Substraction(override val lhs: Int, override val rhs: Int) : Operation(lhs, rhs)
// ... diger islemler, log, exp vs.
data class Input(val lhs: Int, val rhs: Int)
data class Calculation(val input: Input, val operation: Operation)
data class Result(val numeric: Int)
class CalculatorController {
fun calculate(calculation: Calculation): Result {
/**
* Calculation -> input model
* Result -> output Model
*/
val op = calculation.operation
// hesap kitap
return Result(10)
}
}
Hocam böyle gidiyorum işte ama sizin kodların her bir noktasını inceleyeceğim. Özellikle null-safety kısmında kafamda karışıyor zaten. Ondan açtım bu konuyu. Normal olarak bir sınıfı, diğer bir sınıfına parametre olarak nasıl yollanıyor diye çözümleri merak ettim.
Swift:
import model.*
import controller.*
fun main()
{
var islemler: String = "2+4+5+5"
var calculator: Calculator = Calculator()
var calculatorController: CalculatorController = CalculatorController(calculator, islemler)
calculatorController.erorCheck()
}
Swift:
package model
class Calculator
{
var number1: Double? = null
var number2: Double? = null
var islem: String? = null
var tempNumber: Double? = null
}
Swift:
package controller
import model.*
class CalculatorController(val calculatorInstance: Calculator, val islemlerInstance: String)
{
var calculator: Calculator = calculatorInstance
var islemler: String = islemlerInstance
var result: Double = 0.0
var noEror:Boolean = false
var harf: String = ""
fun work()
{
// Hata kontroller
erorCheck()
if(noEror)
{
working()
}else
{
println("erorCheck() hatalı")
}
}
fun working()
{
for(i in 0..islemler.length-1)
{
var harf = islemler[i].toString();
if(harf.toDoubleOrNull())
{
temp+=harf
}else
{
}
}
}
fun erorCheck()
{
// 1. indis sayı değil mi?
noEror = checkIndis(islemler[0].toString())
// Sonuncu indis sayı değil mi?
noEror = checkIndis(islemler[islemler.length-1].toString())
if(noEror)
{
println("Başarılı")
}else
{
println("İndis hatası")
}
}
fun checkIndis(indis: String): Boolean
{
if(indis.toDoubleOrNull() != null)
{
return true
}else
{
return false
}
}
fun calculate(): Double
{
var result: Double = 0.0
when(calculator?.islem)
{
"+" -> result = calculator.number1!! + calculator.number2!!
"-" -> result = calculator.number1!! - calculator.number2!!
"*" -> result = calculator.number1!! * calculator.number2!!
"/" -> result = calculator.number1!! / calculator.number2!!
else -> print("hatalı işlem")
}
return result
}
}
Class'larin sadece bir tane sorumlulugu olmali. Fonksiyonlarin da input alip output return etsinler.
Ornegin "errorCheck()" diye bir fonksiyon olmamali.
Bunu "isOperationValid(operation:String) : boolean" seklinde yazabilirsin.
Class'larini da dizayn ederken null safety ve defansif programlama kriterlerini dusunmelisin. Neler null olamaz? Neler private ya da constant olmali?
Son olarak da isimlendirme aciklayici olmali. Fonksiyonu okuyan ne yaptigini, ne aldigini ve ne bekledigini anlamali.
"fun working()" olmamali mesela.
Bunu "fun add(num1,num1)" seklinde yazabilir ya da "fun calculate(operand1, operand2, operation):Result" seklinde jeneriklestirebilirsin.
6 ay sonra bakinca unutacaksin cunku bunlari, "working()" gibi isimlendirmeler hicbir sey ifade etmeyecek.
Controller diger modelleri hukmeden birisi gibi degil de trafigi yonlendiren bir yapidir MVC'de. Yani model alir, o modeli process edecek kimse ona gorevi delege eder ve sonucu return eder.
Ornegin sen "islem" diye bir "String" alan tutmussun. Eger OOP yapacaksan bunun Enum, Interface ya da sealed class olmasi gerekir.
Kotlin'in null safety ozelliklerinden faydalanman icin de bunlari nullable yapmamalisin. Bir hesaplama isleminden bahsedebilmemiz icin en az 1 parametreye ( 2 parametre zorunlu olmayabilir bazi islemlerde, dogal logaritma gibi ) ve islemin ne olduguna ihtiyacimiz var. O halde bu null olamaz.
Ornegin soyle bir yapi hem OOP hem de MVC acisindan baslangicta ogretici olabilir.
Kod:
sealed class Operation(open val lhs: Int, open val rhs: Int)
class Multiplication(override val lhs: Int, override val rhs: Int) : Operation(lhs, rhs)
class Subtraction(override val lhs: Int, override val rhs: Int) : Operation(lhs, rhs)
// ... diger islemler, log, exp vs.
data class Input(val lhs: Int, val rhs: Int)
data class Calculation(val input: Input, val operation: Operation)
data class Result(val numeric: Int)
class CalculatorController {
fun calculate(calculation: Calculation): Result {
/**
* Calculation -> input model
* Result -> output Model
*/
val op = calculation.operation
// hesap kitap
return Result(10)
}
}
Hocam biraz daha anladım ve kolaylaşmaya başlıyor. Ben şey sandım, propertileri sadece sınıfların scopunda tanımlanabilmesi. Meğerse sınıfların constructer diye tanımlanan alanı, propertileri de tanımlamaya olanak sağlıyor. Ben sadece parametre olarak veri gönderildiğini sanıyordum. Sonra öğrendim.
Hocam biraz daha anladım ve kolaylaşmaya başlıyor. Ben şey sandım, propertileri sadece sınıfların scopunda tanımlanabilmesi. Meğerse sınıfların constructer diye tanımlanan alanı, propertileri de tanımlamaya olanak sağlıyor. Ben sadece parametre olarak veri gönderildiğini sanıyordum. Sonra öğrendim.
Aslinda yine parametre olarak veri gonderiyorsun, constructor da bir fonksiyon. OOP dillerde yazdigin her kod aslinda OOP olmayan low level alternatifine donusturuluyor fonksiyon ve variable yardimiyla.
Mesela sunu compile edip ciktisina bakarsan daha ogretici olur:
Kod:
private class Test(x: String) {
private val y: String
init {
this.y = x
}
}
Buradaki "public Test()" fonksiyonu constructor ve String parametre aliyor.
Kotlin de JVM de compile oldugu icin java ciktisi seklinde okuyabiliyorsun, zaten bu yuzden Java ile yazilan her seyi Kotlin ile de yazarsin.
