Yapıcı Methotlar
YAPICI METHOTLAR
ERİŞİM BELİRTEÇLERİ
AÇIKLAMA:
-----------------------------------------------------------------
Not: Üst seviye sınıflar top level class privite ve protected belirteçlerine sahip olmaz.
public static void main(String[] args) {
rect r1 = new rect();
System.out.println(r1.x);
System.out.println(r1.y);
}
}
class rect{
int x;
int y;
static int type;
static int deg;
static{
//static initializer block
//Statik başlatıcı bloğu
type=32;
deg=48;
}
{
//instance initializer block
//sınıftan bir nesne yaratıldığında...
x=34;
y=48;
}
rect(){
x=1;
}
}
Not: Hem örnek başlatma bloğu hemde varsayılan yapıcı ile bir değer ataması yapılmış ise ilk önce başlatma bloğu daha sonra varsayılan yapıcı çağrılır.
Not: bit top level class (üst seviye sınıf ) static olamz.
static rect(){
}
}
Kural: Java’da yapıcılar statik olmaz.
static void m(){
}
void m2(){
}
}
Kural: Arasındaki fark m de sadece static türdeki değişkenlere ulaşabilirken, m2 de bütün türlere ulaşılabilir.
Not: Birinci kapsamda sadece statik üye elemanlara erişilebilirken ikinci kapsamda tüm üye elemanlara erişilebilir.
Functtion overloading(Fonksyona aşırı yükleme):
public static void main(String[] args) {
//rect r1 = new rect();
//System.out.println(r1.x);
// System.out.println(r1.y);
rect.topla(34, 42);
rect.topla(54, 56);
}
}
class rect{
int x;
int y;
static int type;
static int deg;
static int topla(int a){
return a+1;
}
static int topla(int a,int b){
return a+b;
}
static double topla (double a,int b){
return a+b;
}
}
Not:Aynı işlevi görevi farklı sayıda paremetreyle yapan methotlar oluşturulurken her bir methoda farklı bir isim vermek isim karmaşasına ortaya çıkarır.Java aynı isme sahip birden fazla methot tanımlamasına izin verir.geri dönüş değeri methot imzasına dahil edilmez.
Aynı kapsamda aynı imzaya sahip birden fazla methot olamaz methotların iamzaları birbirinden farklı olmak zorundadır.Methot imzaları methot adı parametre sayısı türleri ve sırasıyla oluşturulur.
Methot imzası methodun protatifi olarak adlandırılır.Aynı isme sahip birden fazla methot olduğu için bir methot çağırım ifadesinin aynı isme sahip methot bildirimlerinden hangisini çalıştıracağı methot bildirimi ile methot çağrımı arasındaki tam uyuma bakarak aranır.örneğin iki int türünden parametreyle tanımlanmış bir methot iki int türünden argüman ile çağırıldığından tam uyum sağlanır.
Parametreler ile argüman arasında gizli tür dönüşümü derleyici tarafından desteklenir(implicitly type conversion) parametre sırası önemlidir bunun yanında parametre adları önemli değildir.
CONSTRUCTOR OVERLOADİNG:
Diğer methotlarda olduğu gibi yapıcı methotlarda aşırı yüklenebilir.Aynı zamanda varsayılan yapıcı overload edilebilir yani tekrar tanımlanabilir.
class rect{
int x;
int y;
rect(int x,int y){
this.x=x;
this.y=y;
}
rect(int x){
this.x=y=x;
}
//identity:kimlik
//identify:tanımlamak
}
Java Örnekleri - Stack Uygulanması:
Aşağıdaki örnekte giren elemanları ve pop () yığından elemanları almak için yöntem için kullanıcı tanımlı push () yöntemini oluşturarak yığını nasıl uygulanacağını gösterir.
ÖRNEK:
public static void main(String[] args) {
MyStack theStack = new MyStack(10);
theStack.push(10);
theStack.push(20);
theStack.push(30);
theStack.push(40);
theStack.push(50);
while (!theStack.isEmpty()) {
long value = theStack.pop();
System.out.print(value);
System.out.print(" ");
}
System.out.println("");
}
}
class MyStack {
private int maxSize;
private long[] stackArray;
private int top;
public MyStack(int s) {
maxSize = s;
stackArray = new long[maxSize];
top = -1;
}
public void push(long j) {
stackArray[++top] = j;
}
public long pop() {
return stackArray[top--];
}
public long peek() {
return stackArray[top];
}
public boolean isEmpty() {
return (top == -1);
}
public boolean isFull() {
return (top == maxSize - 1);
}
}
Yukarıdaki kod örneği aşağıdaki sonucu üretecektir.
50 40 30 20 10
-------------------------------------------------
Nested Class (İç İçe Sınıf)
Java programlama dili, başka bir sınıf içinde bir sınıf tanımlamak için izin verir. Böyle bir sınıf iç içe geçmiş bir sınıf olarak adlandırılır ve burada gösterilmiştir:
class OuterClass {
...
class NestedClass {
...
}
}
public static void main(String[] args) {
System.out.println("");
outerClass c1=new outerClass();
System.out.println(c1.b);
}
}
class outerClass{
//nested class
//1.static nested class
//2.non-static nested class
private int a=43;
static int b =35;
class inner{
void f(){
//a,b are access
}
}
static class s_class{
}
}
//Statik olmayan iç içe sınıflar (iç sınıflar)
Kurallar:
[Modifiler1] class A{
[Modifiler2]class B{
}
}
1.)Bir sınıfın içerisinde başka bir sınıf tanımlandığında içteki sınıf nested olarak adlandırılır.Üstedeki sınıf üç şekilde ifade edilir .
*enclosing type
*Parent
*Top level class
2.)Modifiler 1 static olamazken Modifiler2 static olabilir.
3.)Nested class lar static ve non-static olmak üzere ikiye ayrılırlar.
4.)Static anahtarı iliştirilmiş iç sınıflar static nested class olarak adlandırılırlar.Static ahahtarı iliştirilmemiş iç sınflar inner neted class olarak adlandırılır.
5.)İnner sınıflar içinde bulundukları sınıfı tüm üye elemanlarına erişebilirken static nested class lar üst sınıfın sadece static üyelerine erişebilirler.
6.)İnner sınıflar static methotlara sahip olamazlar. Bunun yanında static iç sınıflar hem static hemde non static üye elemanlarına sahip olabilirlrer.
7.)İç sınıf public,private,protected veye defoult olabilirken dış sınıf sadece public olabilir.
public static void main(String[] args) {
outerClass.StaticnestedClass s=new outerClass.StaticnestedClass();
System.out.println(s.a);
}
}
class outerClass{
private int a;
int b;
static void m(){
StaticnestedClass a=new StaticnestedClass();
}
static int c;
static class StaticnestedClass{
int a;
void m(){
}
StaticnestedClass (){
a=34;
}
}
class İnnerClass{
}
}
Shadowing:
NOT: Parametreler alanaları alanlar üst sınıfın alanlarını gizleyebilir.
ÖNEMLİ PROGRAM:
public static void main(String[] args) {
ShadowTest st = new ShadowTest();
ShadowTest.FirstLevel fl = st.new FirstLevel();
fl.methodInFirstLevel(23);
}
}
class ShadowTest {
public int x = 0;
class FirstLevel {
public int x = 1;
void methodInFirstLevel(int x) {
System.out.println("x = " + x);
System.out.println("x = " + x);
System.out.println("this.x = " + this.x);
System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);
}
}
}
v The following is the output of this example:
x = 23
this.x = 1
ShadowTest.this.x = 0
NOT: İnner(iç) sınıftan nesne yaratmak için dış sınıf nesnesi kullanılır.
ÖRNEK 3:
public static void main(String[] args) {
array s1=new array(200);
s1.set(100,0);
System.out.println(s1.get(0));
}
}
class array{
int str[];
array(int size){
str=new int [size];
}
void set (int val,int in){
if(!(in>-1 && in<str.length))
return;//alone:tek,kimsesiz,
str[in]=val;
}
int get(int in){
if (!(in>-1 && in<str.length))
return -1;
return str[in];
}
}
NOT: New Keyvord Üne Nesne Yaratmak İçin Kullanılan Yapıcı Methot Sürümü Etkinlestirilir.
NOT 2: S1 İsimli Değişken Array Sınıfından Yaratılan Nesnenin Adresini Saklayabilir.
NOT 3:Ornek Methotlar İçerisinde Kullanılan Örnek Değişken Ve Methotlar Gizli Olarak This Anahtarına Sahiptir.
ORNEK 4:
public static void main(String[] args) {
localClass c=new localClass();
c.x=34;
c.foo();
}
}
class localClass{
int x;
static int y;
void foo(){
class inside{
int inside_x;
inside(int inside_x){
this.inside_x=inside_x;
}
int ff(){
return x+y;
}
}
inside in1=new inside(10);
System.out.println(in1.ff());
}
}
ÇIKTI:
34
NOT: Local Sınıflar Birer İnner Sınıf Yani İç Sınıftır.
NOT 2: Local Sınıflar Methotlar İçerisinde Döngü Bloklarıdayada İlk Cümleciklerinde Tanımlanabilir.
NOT 3: Local sınıflar sadece tanımlandıkları blokda kullanılabilir.sınıf dışından erişilemez
NOT 4:Local sınıf içerisinden üst sınıfın değişkenlerine ulaşılabilir.
ÖDEV:LOCAL CLASS JAVA ARAŞTIR.
KELİMELER:
· Ceas=sonlandırmak,bitirmek
· Apparent,clear,expilicit bunların üçüde açık görür.
· Ambigious,unclear,implicit belirsiz,üstü kapalı
· Distinct=belirgin
Example1
Why do I need to declare a local variable as final if my Inner class defined within the method needs to use it ?
class MyOuter2 {
private String x = "Outer2";
void doStuff() {
final String y = "Hello World";
final class MyInner {
String z = y;
public void seeOuter() {
System.out.println("Outer x is "+x);
System.out.println("Local variable is "+y);
MyInner mi = new MyInner();
mi.seeOuter();
}
}
}
}
Why the String y needs to be a final constant ? How does it impact ?
The answer is the two are in different scopes. So that variable could change before the inner class accesses it. Making it final prevents that.
FİNAL ANAHTARI VE DEĞİŞKENLER:
public static void main(String[] args) {
LocalClass l=new LocalClass();
l.m();
}
}
class LocalClass {
final int num;
final static int n2=45;
LocalClass (){
num=45;
}
void m(){
final int c;
c=34;
System.out.println(c);
}
}
KURAL1;Final anahtarı hem insance hem de class değişkenleri için kullanılabilir.Staticdeğişkenlerde final anahtarı iliştirilirse bu değişkene ilk değer ataması zordur
KURAL2;Final anahtarı iliştirilmiş insance variable de ilk değer ataması ya tanımlandığı satırda yada yapıcı methot içerisinde yapılabilir.
KURAL3;Local değişkenler final anahtarı ile sabit yapabilirler bu tip değişkenlere ilk değer ataması dışında başka bir atama yapılamaz.
KURAL4;Final anahtarı sınıf ve arayüzlerde kullanılabilir.
CONSTANT:
class LocalClass {
final int a;
public LocalClass(){
a=56;
}
class abc{
}
}
->Bir üye değişken hem static hem fınal anahtarı aldığında sabit olarak tanımlanmış olur ilgili değişken sınıfın yaşam süresi boyunca sadece bir defa yaratılır her bir nesne örneği için tekrar yaratılmaz.
INNER CLASS DA NESNE YARATMA ÖRNEĞİ:
public static void main(String[] args) {
LocalClass outer =new LocalClass();
LocalClass.inner_Box ınner=outer.new inner_Box(2,3);
LocalClass.static_Box a=new LocalClass.static_Box();
}
}
class LocalClass {
int x1;
static int x2;
public LocalClass(){
}
class inner_Box{
int x;
int y =x1;
inner_Box (int x,int y){
this.x=x;
this.y=y;
}
int fied (){
return x*y;
}
}
static class static_Box{
int x;
static int y;
public static_Box(){
// x1=43;
x2=23;
}
}
}
CAPTRUE VARİABLE
Local bir değişkene local bir sınıfta ulaşıldığında ilgili değişken captrue yani yakalanmış olur.
DEĞİŞKEN SAYIDA ARGUMAN ALAN PARAMETRE:
-> Statik bir methot içerisinden sadece sınıfın static üyelerine erişebilir.
KELİMELER:
Accumulate,gather,addition
Arbitrary:rastgeleàrandom
Optinal:isteğe bağlı
public static void main(String[] args) {
//addition()
//addition(2,3)
//addition(2,3,1254)
//addition(2)... OK
//addition(1,2,3,4,5)
//taype ... name --> type name []
//equal,corresponding:denk
}
static int addition(int b,int a,int...c){
//unclear,ambigious,implict
}
}
ÖRNEK 2:DEĞİŞKEN SAYIDA ARGÜMAN ALAN PRAMETRELERDE TOPLAMA
public static void main(String[] args) {
//int b []={1,2,3,4,5};
addition(2,3,4,5);
}
static int addition(int...a){
int tpm = 0;
for(int c:a){
tpm+=c;
}
System.out.println(tpm);
}
}
NOT: Derleyiciler variable parametre metotlarının imzalarını oluştururken ikinci önceliğe alır.Methot imzaları oluşturulurken değişken sayıda prametreler ikinci olarak dikkate alınır İnt türünden tek argümanlı bir çağırım ifadesi yine int türünden tek parametreyle bildirilmiş Bir methot bildirimini işletir.
KOMUT SATIRI ARGÜMANLARI:
->Class uzantılı dosyalar kaynak dosyanın byte kode halini içerir.
Not: boxing and autoboxing sınavda çıkar.
İNTERFACE(ARAYÜZ)
àİmplement=Uygulamak
àAbstract=Soyud
àİnstantiated=Somut
Referance türü oluşturmak için kurulan kurallar kümesidir. İnterface denklarasyonları yeni bir referance türü oluşturur.Bir interface bir yada daha fazla sınıfa uygulanabilir yada bir interfaceden referance türünden bir değişken tanımlanabilir. İnterface dediğimiz yapı sınıflara uygulanmak için yada referance oluşturmak için yapılan bir türdür.İnteface İçerisinde Tanımlanan Methotların Gövdesi Olmaz Yani Body Olmaz.
NOT: İnterface tanımlamaları dosya kapsamında yada bir sınıf kapsamında olabilir. Sınıfın üyesi olan interfacelere sınıf adıyla ulaşılır.
interface mt {
void start();
void stop(int a,int b);
}
class taxi imlements mt{
public void start(){
anahtar();
}
}
class xx implements mt{
public void start(){
parmakizi();
}
}
Daha önce söylendiği gibi interface tanımlaması soyut bir kural kümesi oluşturur.Bir interface nin bir sınıfa uygulanması interface içerisindeki kuralların sınıf tarafından uygulanacağanı bildirir.Bir interfacenin bir sınıfta uygulanması için implements anahtarı kullanılır.Bir sınıfa birden fazla arayüz uygulanabilir.bir sınıfa birden fazla interface uygulandığında interface adları birbirinden virgül ile ayrılmalıdır.Bir interface bir sınıfın üyesi yada direk dosya kapsamında tanımlanabilir. Eyer bir kaynak dosya içerisinde sadece bir interface tanımlaması varsa bu interface public olarak işaretlenebilir bir kaynak dosya içerisinde sadece tek bir interface public olarak işaretlanebilir.
İnterface nin Üye Elemanları
1.abstract metotlar(gövdesiz&soyut)
2.constant’lar (sabitler)àstatic methotlar
àİntefaceler birer constant dır.İnterface ler somutlaştırılamazlar yani interfacelerden nesne yaratılamaz ama değişken tanımlanabilir.
interface abc {
}
abc a =new abc();
Örnek: a değişkenine atanabilecek değer ?
Kural: İnterface içerisindeki üye elemanları ()abstracter,default,static methotlar varsayılan olarak publicdir pirivate veya protected olarak işaretlenemezler.
Örnek:
public static void main(String[] args) {
System.out.println(args.length);
}
}
interface box {
int f1();
int f2(int a,float b);
void pirint();
}
abstract class goo implements box {
public void pirint(){
System.out.println("sddd");
}
public int f1(){
return 5;
}
public int f2 (int a,float b){
System.out.println("sddd");
return 5;
}
},
Not:Abstracter methot bildiriminin önüne static anahtarı iliştirilemez.Abstracter methotlar gizli olarak abstracter keyword üne sahiptir.
Not: İnterface içerisindeki sabitler üstü kapalı olarak static final public anahtarlarına sahiptirler dolayısıyla bunları tekrar tanımlamak gereksiz olur.
ÖRNEĞİN DEVAMI
public static void main(String[] args) {
goo g1=new goo();
box f;
f=g1;
System.out.println(goo.cs);
}
}
interface box {
int cs =33;
public abstract int f1();
int f2(int a,float b);
void pirint();
}
class goo implements box {
public void pirint(){
System.out.println("sddd");
return;
}
public int f1(){
System.out.println("sddd");
return 5;
}
public int f2 (int a,float b){
System.out.println("sddd");
return 5;
}
}
Not:Bir interface ve bu interface nin uygulandığı bir sınıf hayal edelim interface nin uygulandığı bir değişkende sınıfın yaratıldığı nesne referansı atanabilir.
interface mt{
int a=b;
int b=a;
int c=c+1;
}
Not: Derleme zamanında değeri hesaplanabilen deyimler complier time expeleisıon olarak adlandırılır.
Örnek
public static void main(String[] args) {
MammalInt m = new MammalInt();
m.eat();
m.travel();
}
}
class MammalInt implements Animal{
public void eat(){
System.out.println("Mammal eats");
}
public void travel(){
System.out.println("Mammal travels");
}
public int noOfLegs(){
return 0;
}
} public interface Animal {
public void eat();
public void travel();
}
Not: İnterface anahtarının önüne sadece public ve abstract anahtarları iliştirilebilir.
UML CLASS
ÖRNEK :
public static void main(String[] args) {
mix m1;
m1=new x1();//referans numarasını saklar
m1=new x2();//referans numarasınısaklar
//x1 ve x2 nin ortak özelliği yukarıda verilmiştir.
}
}
interface mix{
void stop();
}
class x1 implements mix{
public void stop(){
}
}
class x2 implements mix{
public void stop(){
}
}