static void Main(string[] args)
{
Database database = new Oracle();
database.add();
database.Delete();
Database database2 = new SqlServer();
database2.add();
database2.Delete();
}
static void Main(string[] args)
{
Database database = new Oracle();
database.Add();
database.Delete();
Database database2 = new SqlServer();
database2.Add();
database2.Delete();
Console.ReadLine();
}
static void Main(string[] args)
{
//Database database = new Database();
Database database = new SqlServer();
database.Add();
database.Delete();
Database database1 = new Oracle();
database1.Add();
database1.Delete();
}
static void Main(string[] args)
{
Database database = new Oracle(); // abstract classlar newlenemez.
database.Add();
database.Delete();
Database database2 = new SqlServer(); // abstract classlar newlenemez.
database2.Add();
database2.Delete();
Console.ReadLine();
}
static void Main(string[] args) // Add herkesde aynı fakat delete farklı
{
Database database = new Oracle();
database.Add();
database.Delete();
Database database2 = new SqlServer();
database2.Add();
database2.Delete();
Console.ReadLine();
}
static void Main(string[] args)
{
Database database = new SqlServer();//Abstract classların instance ı yazılırken kendi adına yazılır fakat implemente edildiği sınıfın heap bölgesini kullanırlar.Böylece tamamlanmış metotları kalıtımla olduğu gibi bırakırken abstract metotları override edilerek kullanılır.
database.Add();
database.Delete();
Database databse2 = new Oracle();
databse2.Add();
databse2.Delete();
Console.ReadLine();
}
static void Main(string[] args)
{
//Abstract sınıflar new'lenemez.
Database database = new Oracle();
database.Add();
database.Delete();
Database database1 = new SqlServer();
database1.Add();
database1.Delete();
Console.ReadLine();
}
static void Main(string[] args)
{
Database database = new Oracle(); // İnterface gibi abstract sınıfı newleyemiyoruz.
database.Add();
database.Delete();
Database database1 = new SqlServer();
database1.Add();
database1.Delete();
Console.ReadLine();
}
static void Main(string[] args)
{
//Abstract class için yeni bir üye oluşturulamaz.
Database database = new Oracle();
database.Add();
database.Delete();
Database database2 = new SqlServer();
database2.Add();
database2.Delete();
}
static void Main(string[] args)
{
Oracle oracle = new Oracle();
oracle.Delete();
oracle.Add();
SqlServer sqlServer = new SqlServer();
sqlServer.Delete();
sqlServer.Add();
Console.ReadLine();
}
static void Main(string[] args)
{
//Abstract classlar new'lenmez
//Abstract classlar aynı zamanda bir inheritance'dir(kalıtım)
Database database = new Oracle();
database.Add();
database.Delete();
Database database2 = new SqlServer();
database2.Add();
database2.Delete();
Console.ReadLine();
}
static void Main(string[] args)
{
//interface ve abstractlarla new yapılamıyor
Database oracleDatabase = new Oracle();
oracleDatabase.Add();
oracleDatabase.Delete();
Database sqlDatabase = new SqlServer();
sqlDatabase.Add();
sqlDatabase.Delete();
Console.Read();
}
{//ExorTek(Mehmet Demirel)
static void Main(string[] args)
{
Database sqlServerDatabase = new SqlServer();
sqlServerDatabase.Add();
sqlServerDatabase.Delete();
Console.WriteLine();
Database oracleDatabase = new Oracle();
oracleDatabase.Add();
oracleDatabase.Delete();
Console.ReadLine();
}
static void Main(string[] args)
{
Database database = new Oracle(); //Burada Database'i newleyemeyiz.(abstact classlar newlenmez)
//Yani abstract classlar newlenemez.
database.Add();
database.Delete(); //Oracle'ın delete'i çalışır.
Database database2 = new SqlServer();
database2.Add();
database2.Delete(); //Sql server delete çalışır.
//Abstract classlar bir inheritancedır. SqlServer sadece 1 tane abstractten inherit edilebilir.
//Baska bir class veya abstarctten inherit edilemez. Başka interfaceler varsa onlar implement edilebilir.
}
static void Main(string[] args)
{
//abstract classlar new'lenemez
Database database = new Oracle();
database.Add();
database.Delete();
Database database2 = new SqlServer();
database2.Add();
database2.Delete();
//eklme herkesde aynı delete her class için implanmente edilmesi gereken bir yapıdır.
Console.ReadKey();
}
static void Main(string[] args)
{ //Interfaceler gibi abstrack class larda new lenemez. Alt dalları newlenebilir.
Database database = new SqlServer(); //ayrı ayrı çağırıyoruz burada SqlServer ı çağırdık
database.Add();
database.Delete();
Console.WriteLine("************************************************************");
Database database2 = new Oracle(); //ayrı ayrı çağırıyoruz burada Oracle ı çağırdık
database2.Add();
database2.Delete();
Console.WriteLine("************************************************************");
Console.WriteLine("Her ikisindede Add metodu aynı fakat Delete için\nabstrack çalıştırdığımız için ikisindede delete fonksiyonları\nfarklı olarak çalışmaktadır.");
Console.ReadLine();
}
static void Main(string[] args)
{
// Just like interfaces, you can't create abstract classes as new.
// Database database = new Database();
Database database = new Oracle();
database.Add();
database.Delete();
Database database2 = new Oracle();
database2.Add();
database2.Delete();
Console.ReadLine();
}
static void Main(string[] args)
{
//abstract classlar birer inheritance özelligidir.
//interface gibi abstract class new yapamıyoruz
//Database database = new Database();
//Oracle ve Sql server implemente edebiliriz.
Database databaseOracle = new Oracle();
databaseOracle.Add();
databaseOracle.Delete();
Database databasesql = new SqlServer();
databasesql.Add();
databasesql.Delete();
Console.ReadLine();
}
static void Main(string[] args)
{
// Abstract Classlar interface ile inheritance'ın birleşimine benzer bi yapıdır.
// interface'ler gibi abstract class'lar da kendisinden türetilemez.
Database db = new Oracle(); // new Database yazamazdık yani.
db.Delete();
db.Add();
Database db2 = new SqlServer();
db2.Delete();
db2.Add();
// inheritance class gibidir. sadece 1 abstract classtan inherite edilebilir, birden fazla abstract class veremeyiz yani bi classa.
// classlarla ilgili aynı kuralda burda geçerli istediğimiz kadar interface ekleyebiliriz yani.
}
static void Main(string[] args)
{
//Abstract classlar hem tamamlanmış metodları hem de tamamlanmamış, o class'ı inherit eden class tarafından tanımlanması/içi doldurulması gereken virtual methodlardır.
//Abstract classlar newlenemez/örneklenemez(Bu yönden interfaceler gibidir.)
Database oracle = new Oracle();
Database sql = new SQL();
oracle.Add();
oracle.getAllData();
sql.Add();
sql.getAllData();
Oracle o = new Oracle();
o.Add();
o.getAllData();
Console.Read();
}
static void Main(string[] args)
{
Database databaseSql = new SqlServer();
Database databaseOracle = new Oracle();
}
