Samsung Galaxy S3 Wi-Fi Sorunu

Geçen gün telefonumda enteresan bir şekilde Wi-Fi çalışmamaya başladı. Cihaz stock romlu halindeydi yani herhangi bir custom rom kullanmıyordum. Notification barındaki Wi-Fi simgesi gri renkteydi ve aktif değildi. Ayarlardan Wi-Fi yi kontrol ettiğim zaman ise sürekli “Turning on…” (Wi-Fi açılıyor…) yazısını görüyordum.

Araştırdığım kadarıyla bu durum sık karşılaşılan bir sorunmuş. İnternette yazılan çözümlerin hiçbiri işe yaramadı (pil çıkartıp takmak, cihazı tekrar başlatmak, modemi resetlemek, Wi-Fi Fixer uygulaması vs.) Son çare olarak cihazı Kies ile yedekleyip fabrika ayarlarına geri aldım ve sorun çözüldü.


MMS Streaming

I’ve been searching for a 3rd party library to stream MMS(Microsoft Media Stream) on Android for a while. After spending many hours, I want to share the best solutions I found:


C++ In Details – 2

Functions and Pointers

A pointer variable can be passed as a parameter either by value or by reference.

For the above function;

  • Both p and are pointers
    • q is a value parameter
    • p is a reference parameter
  • The function can change the value of *q, but not the value of q.
  • The function can change both *p and p.
  • Function call is done like that -> example(x, &y);
The Big Three: Destructor, Copy Constructor, operator=

Destructor is called whenever an object goes out of scope or is subjected to a delete. Typically, the only responsibility of the destructor is to free up any resources that were allocated during the use of the object. This includes calling delete for any corresponding news.

Copy constructor is required to construct a news object, initialized to a copy of the same type of object. Copy constructor is called in such cases:

operator= is called when assignment operation is applied two objects after they have both been previously constructed.

For the primitive data types, these big three is provided by default. The main problem occurs when a class has a pointer data member. In this situations, we have to write our destructor, copy constructor and assignment operator. Overloading the assignment operator is also used for avoiding from shallow copy.

By default these big three are provided. But if we have pointer variable in our class, then we must implement these to avoid problems.

Shallow Copy vs Deep Copy

Consider below code:

After this code snippet, lets assume that we write ” second = first ” statement. Now they are pointing to the same memory location. In this situation, if we write “delete [] second;“, array pointed by second is deleted. Because first and second points to the same array, they are now dangling pointers. Therefore, if the probgram later tries to access the memory pointed to by first, either program will access the wrong memory or it will terminate to an error. This case is an example for shallow copy.

On the other hand, consider the following statements:

Now, they point to their own data. If second deletes its memory, there is no effect on first. When two or more pointers have their own data, this situation called as deep copy.

Function Templates

If we want to write code for a type-independent algorithm or data structure, we would prefer to write the code once, rather than recode it for each different type. Lets check the findMax function on below:

Lets test our function for different data types

As you see, our function works well with primitive data types. On the other hand; if the data type is an user defined class, this class must provide operator< and operator= overloadings.

Class Templates

Class templates works much like a function template.

 Operator Overloading

Operator overloading allows us to define the meaning of a built-in operator. Lets define an Employee class which can be used in our above generic function findMax.


C++ In Details – 1

I’ve decided to post my articles in English to reach out more people (and to get more traffic :)). In this article I’m going to touch on some details of C++ programming language.


As you may know, pointer is a variable that stores the address where another object resides. It is the basic mechanism used in many data structures. For example, to store a list of items, we could use an array, but insertion into the middle of the array requires relocation of many items. Instead of store the collection in an array, it’s common to store each item in a separate, noncontiguous piece of memory which is allocated when the program runs. Along with each object is a link to the next object. This is the classic linked list that is discussed in more detail in my upcoming posts.


When declaration of variables, “*” indicates that this variable is a pointer variable. The value of pointer is the address of the object that it points at. In C++, there is no such check is performed to verify pointer assigned a value prior to being used. The use of uninitialized pointers generally crashes programs, because they result in access of memory locations that do not exist. In general, it’s a good idea to provide an initial value, or initializing the pointer to the NULL pointer. Lets look at an example:

We are going to write down a class named IntCell for simulating an integer memory cell.

Then lets write a driver program to test our class:

This driver program output will be “Cell contents: 5”. Now lets write same driver program with using pointers:

As you see we get the same output with using a pointer.

I want to mention about a couple of things about the above example. Firstly, as you notice, the IntCell constructor is explicit. You should make all one-parameter constructors explicit to avoid behind-the-scenes type conversions. Otherwise, there are somewhat lenient rules that will allow type conversions without explicit casting operations. Usually, this is unwanted behavior that destroys strong typing and can lead to hard-to-find bugs. As an example, consider the following code fragment:

The code fragment above constructs an IntCell object obj and then performs an assignment statement. But the assignment statement should not work, because the right side of the assignment operator is not a IntCell object. Instead of this line, obj’s write method should have been used. However C++ have lenient rules. Normally, a one-parameter constructor defines an implicit type conversion, in which a temporary object is created that makes an assignment compatible. In this case, compiler would attempt to convert


Notice that the construction of the temporary can be performed by using the one-parameter constructor. The use of explicit means that a one-parameter constructor cannot be used to generate an implicit temporary. Thus, since IntCell’s constructor is declared as explicit, the compiler will correctly complain that there is a type mismatch.

Secondly, as you have noticed, the read method is declared as constant member function. That means this function will not change the state of its object. That type of functions are called accessor. On the other hand, a member function that changes the state is called as mutator. In our example, write method is clearly a mutator. Adding const keyword to accessor functions is best practice for good programming.

Garbage Collection and delete

In some languages such as Java, when an object is no longer referenced, it is subject to automatic garbage collection. The programmer does not have to worry about it. C++ does not have garbage collection so it is the  programmers responsibility to delete unreferenced objects (through a pointer). Otherwise, the memory that it consumes is lost. This is known as a memory leak. This is why we write “delete m;” on the above example.

Assignment and Comparison of Pointers

Assignment and comparison of pointer variables in C++ is based on the value of the pointer, meaning the memory address that it stores. Thus two pointer variables are equal if they point at the same object. If they dont, they are not equal (even if the objects being pointed at are themselves equal).

Accessing Members of an Object through a Pointer

If a pointer variable points at a class type, then a member of the object being pointed at can be accessed via the -> operator. You can see at the above example.

Other Pointer Operations

C++ allows all sorts of bizarre operations on pointers which are sometimes useful. For example, < is defined. For pointers lhs and rhs , lhs<rhs is true if the object pointed at by lhs is stored at a lower memory location than the rhs pointed at. However, as my Data Structres and Algorithms professor has also said, pointers are dangerous. Therefore you have to be carefull when doing pointer arithmetics or other operations on pointers. Later, we’ll be discussing in more details about pointer operations.

One other important operator is the address-of operator &. This operator returns the memory location here an object resides.

Parameter Passing

Many languages, including C and Java, pass all parameters using call by value in which the actual argument is copied into the formal parameter. However, parameters could be large complex objects for which copying is inefficient. Moreover, sometimes it is useful to be able to change the value being passed in. As a result of this, C++ has three  ways to pass parameters.

  1. Call by constant reference
  2. Call by value
  3. Call by reference

The above function uses these three methods. It returns the average of first n integers in arr, and sets errorFlag to true if n is larger than arr.size() or smaller than 1. Here arr is of type vector<int> and is passed using call by constant reference, n is of type int and is passed using call by value, and errorFlag is type of bool and is passed using call by reference. The parameter-passing decision can be made by considering two issues:

  1. If the formal parameter should be able to change the value of the actual argument, then you must use call by reference.
  2. Otherwise, the value of the actual argument cannot be changed by the formal parameter. If the type is primitive type, use call by value. Otherwise, the type is a class type and would generally be passed using call by constant reference. (However, if the class type is small (such as those that store only a single built-in type) can be passed using call by value instead of call by constant reference.)

In the declaration of average function, errorFlag is passed by reference so that the new value of errorFlag will be reflected in actual argument. arr and wont be changed by the function. arr is passed by constant reference because it is a class type, and making a copy would require too much work. n is passed by value because it is a primitive type and is cheaply copied.

To sum up:

  1. Call by value – is appropriate for small objects that should not be altered by the function.
  2. Call by constant reference – is appropriate for large objects that should not be altered by the function.
  3. Call by reference –  is appropriate for all objects that may be altered by the function.
Return Passing

Objects can also be returned using return by value, return by constant reference, and return by reference. It’s always safe to use return by value, however, if the object being returned is a class type, it may be better to use return by constant reference – to avoid overhead copy. The const here means that the object being returned cannot itself be modified later on. Please note that it is different from the const -which we previously discussed- in the parameter list and that const signifies an accessor.

This is a very tricky part of C++, and many compilers ill fail to give a warning message for errors. Lets look at an example to clarify:

There are two nearly identical functions, to find largest string in an array. Both attempt to return value bu constant reference. The first version, findMax, shows acceptable use: the expression a[maxIndex] indexes a vector that already exists outside of the findMax‘s scope, and will exist long after the function call returns. The second version is wrong. maxValue is a local variable that doesnt exist when the function returns.

Reference Variable

Reference and constant reference variables are commonly used for parameter passing. But they can also be used as local variables or as class data members.

  • If we write down y = 25; , x becomes 25 too.
  • Also if we consider the statement x = 2*x+30; , y becomes updated.

  • On the above example, &x is returned.
  • There is a critical point. Consider in the driver program we write down ” &y = a.addressOfX();” and then “y=25” statements. After this, x becomes 25.
  • This means we have reached the class member x directly. This is a design mistake!!
  • Solution: defining the function in the header file as ” const int& addressOfX();

I’m gonna stop at this point and will continue over the next subjects on my upcoming posts.


Internet Explorer 10 Test Drive

Aşağıdaki adresi yeni keşfettim. Gerçekten ilgi çekici HTML5 uygulamaları mevcut.

Internet Explorer Test Drive

Bir göz atın derim 😉


IntelliJ IDEA Android SDK Sorunu

Bir kaç aydır android programlama ile ilgileniyorum. Google, android plugini  Eclipse için çıkarmıştı bildiğiniz gibi. Bu yüzden android uygulama denemelerimi Eclipse üzerinde gerçekleştiriyordum. Tabi java uygulamaları için de aynı ideyi kullanıyordum. Java Teknolojileri ve Programcıları Derneği’nin Bahçeşehir Üniversitesinde gerçekleştirdiği bir etkinlikte muhabbet arasında IntelliJ IDEA yı da tavsiye edenler olmuştu. Geçenlerde merak edip IntelliJ IDEA Community Edition kurdum ve denedim. İzlenim olarak şunu söyleyebilirim, gerçekten kullanıcı dostu bir ide. Intellisense özelliği Eclipse’e göre çok daha hızlı çalışıyor, bu durumda siz de daha hızlı kod yazıyorsunuz ve sizi kod yazmaya teşvik ediyor. Diğer yandan, izlenimlerime göre, performans olarak Eclipse e göre daha yavaş çalışıyor. Bir projeyi load etmesi biraz uzun sürüyor. Ayrıca bazı forumlarda hafızayı çok kullandığı yönünde de eleştiriler okudum. Çok fazla Eclipse vs IntelliJ IDEA olayına girmeden konuya gireyim.


IntelliJ IDEA aynı zamanda android geliştirmeye de destek veriyor (Araştırdığıma göre Eclipsedeki gibi plugin olarak değil, Ant scriptleri ile bunu sağlıyormuş). Ben de basit bir android uygulaması denemek istedim ve proje oluşturmaya başladım. Sıra android sdknın yerini belirlemeye geldi ve “..Android/android-sdk” classpath ini tanımladım. Ama IntelliJ şu hatayı verdi -> “cannot find any android targets in this sdk”. Ne yaparsam yapayım, bilgisayarımda android sdk kurulu olmasına rağmen, bir türlü intellij android sdkyı görmüyordu. Yabancı forumlarda gezinip araştırdıktan sonra sorunun çözümünü buldum.

  • Android SDK yı kurduğunuz dizine gidin. Android>android-sdk>tools>android.bat ı çalıştırın.
  • Karşınıza gelen emulatör menejerinden Settings kısmına tıklayın
  • Misc başlığı altındaki “Force https://..” ile başlayan kutucuğu işaretleyin.
  • IntelliJ IDEA açıksa tekrar başlatın.

Ayarlar şekildeki gibi olmalı->


Artık IntelliJ IDEA da android-sdk nın yerini belirleyebilirsiniz. Umarım bu sorunla karşılaşanlar için faydalı bir yazı olmuştur.


Java ME 64 bit hatası

Netbeans de basit bir midleti çalıştırırken, Execution failed with error code 1 hatası aldım. Biraz araştırdıktan sonra öğrendim ki sorun jdknın 64-bit olmasından kaynaklanıyor. Nedeni ise mobil cihazlar 32-bit mimariyi destekliyorlar. Çözüm için yapılması gereken 64-bit jdk yı kaldırıp 32-bit jdk kullanmak.


Java’da Abstract Class ve Interface

Bu yazıda javada abstract class ve interface kullanımından bahsedeceğim. Öncelikle bu kavramlardan kısaca bahsetmek istiyorum.

Java’da interface, bir class’ta olması gereken methodları ve dataları tanımlayan yapıdır. İçinde herhangi bir implementasyon barındırmaz, sadece methodların prototype larını yani “ne yapılacağını” gösterirler. Yani interfaceleri bir nevi kılavuz gibi düşünebiliriz. Bir class’ın interface’deki bütün method’ları içerdiğini, gerçekleştirdiğini belirtmesine implementation denir ve ‘implements‘ keyword’üyle kullanılır. Peki ne işe yarar bu interfaceler?

  • Aynı methodları kullanacak olan birden fazla class yazarken işimizi kolaylaştırır
  • Birbiriyle alakası olmayan classları ilişkilendirmemize olanak sağlar
  • Birden fazla interface implement ederek bir anlamda multiple inheritance sağlamış oluruz

Örnekte gördüğümüz üzere Airplane, Bird ve Superman classları Flyer interface ini implement ediyorlar. Böylece 3 class için de ortak olan methodların bodylerini classlarda implement etmiş oluyoruz.  Ayrıca bir class, bir classdan hem türetilip hem de birden fazla interface i implement edebilir. Çünkü interface implement edince class’a eklenen bişey yoktur. Class sadece interfacedeki  methodları ve dataları içereceğini belirtir ve methodların implementasyonlarını sağlar.

Java’da abstract classlar, bazı methodların implementasyonu sağlayan, diğer methodların implementasyonlarını ise subclasslara bırakan classlardır. Bu implement edilmesi alt classlara bırakılan methodlara da abstract method denir. Abstract classlar, subclassların ortak özelliklerini taşırlar. Abstract methodların da subclasslarda kullanımı ortak olup, implementasyonları farklıdır. Örneğin “hacim hesaplama” ortak bir methodken, küp ve küre hacimi hesaplaması farklıdır. Bu yüzden hacim hesaplama methodu abstract olarak tanımlanır ve alt classlar kendilerince bu methodu implement ederler.

Şimdi bütün bu anlattıklarımı bir örnek üzerinden pekiştirelim. Örneğimiz hayvanlar üzerine olacak J Önce abstract olarak Animal classını yazalım. Bu class bütün hayvanlar için bir super class olacak.

Animal classından Spider classını türetelim. Örümceğin 8 bacaklı olduğunu constructorda belirtelim ve abstract method olan eat() methoduna body yazalım.

Şimdi Pet interface i yazalım. Bu interface i evcil hayvanlar implement edecek. Interfacelerin herhangi bir implementasyon içermediğini sadece bir kılavuz olduklarını tekrar hatırlatayım. Evcil hayvanın ismi olur ve oyun oynarlar diyelim.

Daha sonra Cat classını yazalım. Cat classı Animal classını extend edip, Pet interface’ini de implement edecek.

Aynı şekilde Fish class ı da yazalım.

Main methodunu barındıran TestAnimals classını yazalım ve programımızı çalıştıralım.

Ekran çıktımız şu şekilde olacak:



Java’da Method Overriding

Merhaba arkadaşlar. Bu yazıda method overriding nedir, javada method overriding nasıl yapılır konularından bahsedeceğim. Bildiğimiz üzere inheritance ile birlikte, türetilen class türetildiği classın bütün özelliklerini taşır. Genelde bu inherit edilen methodlar düzgün çalışır ama bazen türettiğimiz classa göre o methodları değiştirmek isteyebiliriz. İşte bu işleme “method overriding” deniyor.

Bir örnek üzerinden gidelim. Elimizde “Employee” ve “Manager” classları olsun. Manager classı Employee classından türetilsin ( Manager is an Employee ).

Manager classı Employee classından farklı olarak String tipinde “department” adında bir değişkene sahip ve getDetails() methodu da override edilmiş durumda. Böylece Manager classının kendisine ait bir getDetails() methodu olmuş oluyor ve override edildiği methoda ek olarak Manager’in department değişkenini de geri döndürüyor.

Gördüğünüz gibi kolay bir işlem ama method overriding yaparken bazı temel kurallar var. Bir subclass, parent classın methodunu şu koşullar altında override edebilir:

  • Methodun adı aynı olmalı
  • Methodun return type ı aynı olmalı
  • Argument list aynı olmalı
  • Override edilen method, override edildiği methoddan daha kısıtlı erişime sahip olmamalı.

Son madde biraz karışık oldu ama şöyle açıklayayım. Mesela yukarıdaki örnekte Employee classındaki getDetails() methodu public olarak tanımlanmış. Bu demek oluyor ki Manager classındaki override edilmiş getDetails() methodu protected, private veya default olamaz! Çünkü bu 3 erişim belirleyici methodun erişimini daha kısıtlı hale getirir. Bu yüzden override ettiğimiz getDetails() methodunu da public olarak tanımladık. Bu konuyla ilgili olarak şu yazıma bakmanızı öneririm.

Ayrıca bu noktada super kullanımından da bahsedeyim. Eğer override edeceğimiz methodu tamamen değiştirmek istemiyorsak, sadece geliştirmek ekleme yapmak istiyorsak ( yukarıdaki örnekteki gibi ), ozaman super anahtar sözcüğünü kullanabiliriz. Bu sayede parent class ın methodlarını ya da datalarını çekebiliyoruz. Bir küçük ayrıntı olarak şunu da söyleyeyim, extend ettiğimiz class, başka bir classdan inherit edilmişse o en tepedeki classa da super anahtar sözcüğü ile ulaşabiliyoruz. Kullanımı şu şekilde:


Java Erişim Belirleyicileri

Merhaba arkadaşlar. Paket kavramından bahsettikten sonra bu yazıda da java erişim belirleyicileri konusuna göz atalım. Javada 4 tane erişim belirleme yöntemi var. Bunlar private, default, protected ve public. Bu belirleyicilerle javada erişim kontrolü sağlanmış oluyor. Bir örnek üzerinden anlatmaya çalışacağım.

Elimizde kendi yarattığımız “alpha” ve “beta” isminde iki tane paketimiz olsun.  Alpha paketinin içinde A ve B classları var. A classının foo() adında bir methodu var. Beta paketinde ise C ve D classları var. C classı, A classından inherit edilmiş(türetilmiş) durumda.

Şimdi bahsettiğim 4 belirleyiciyi A classının foo() methodu üzerinde değerlendirmeye başlayalım.

1 – foo() methodu private olarak tanımlanırsa:

A classı kendi methoduna erişebilir. Aynı pakette bulunan B classı A classının foo() methoduna erişemez. A classından inherit edilmiş C classı da foo() methoduna erişemez. Ayrıca D classının da foo() methoduna erişimi sağlanamaz.

2 – Aslında Javada default diye bir access specifier yok. Burda bahsedilen default, boş bırakıp hiçbir specifier kullanmama durumu. Şimdi foo() default olarak tanımlanırsa erişime bir bakalım:

Bu sefer B classı foo() methoduna erişebilir. Yani aynı paketten erişim sağlanabilir. Subclassdan ve dışarıdan erişim sağlanamaz.

3 – Eğer foo() methodu protected olarak tanımlanırsa:

Aynı paketteki B classı ve A classından inherit edilmiş olan C classı, foo() methoduna erişim sağlayabilir. Bunun dışında dışarıdan erişim sağlanamaz.

4 – Son olarak methodu public olarak tanımlarsak erişime bir bakalım:

Bu sefer foo() methoduna heryerden erişim sağlanabiliyor. Adı üstünde public hale geliyor.