반응형

보통 애플리케이션 실행 시, 바로 메인화면으로 한방에 넘어가는 것보다 보통 2~3초의 짧은 시간동안 애플리케이션 소개화면이 잠깐 지나치는 것을 많이 경험하셨을 것입니다.

앱의 완성도를 조금 더 높여주도록 Splash창을 구성해보도록 하겠습니다.


////////////////////////////////////////////////////////////////////////////////////////////

[MainActivity.java]

public class MainActivity extends Activity {

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);


startActivity(new Intent(this, SplashActivity.class));

//Intent창을 새로 만들어서 먼저 SplashActivity를 시작하도록 합니다.

}

}

////////////////////////////////////////////////////////////////////////////////////////////

이제, 위에서 MainActivity가 실행되면, SplashActivity를 시작할테니, SplashActivity를 만들어주어야 겠죠.


[SplashActivity.java]

import android.app.Activity;

import android.os.Bundle;

import android.os.Handler;


public class SplashActivity extends Activity {

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_splash);        

//activity_splash 레이아웃을 구성함으로써 어떤 화면을 보여줄 지, 직접 사용자가 해당 레이아웃에서 구현해주면 됩니다.


Handler hd = new Handler();

hd.postDelayed(new Runnable() {

public void run() {

finish();            //2초동안 보여준 후, SplashActivity를 종료한 후 MainActivity로 돌아갑니다.

}

}, 2000);                //2000millis. 즉 2초동안 해당 화면을 보여준 후, finish() 됩니다.

}

}

////////////////////////////////////////////////////////////////////////////////////////////

//layout에 activity_splash.xml을 만들어주어 사용자에게 보여 줄 SplashView를 구성해주면 됩니다.

/* 일단, 간단한 확인만을 위하여 TextView를 추가하여 text로 Splash창이라는 것을 확인하도록 합니다.

나중에, 예쁘게 꾸미기 위하여 ImageView나 다른 것들을 추가하여 실질적으로 꾸며주시면 됩니다. */


[activity_splash.xml]

<TextView

android:layout_width="match_parent"

android:layout_height="match_parent"

android:textSize="30dp"

android:text="Splash 창 입니다!" />



[AndroidManifest.xml]

<application
android:allowBackup="true"
android:icon="@mipmap/logo"
android:label="@string/app_name"
android:supportsRtl="true"
android:theme="@style/AppTheme">
<activity android:name=".MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />

<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>

<activity android:name=".SplashActivity" />

위와 같이 아마 보여질 것입니다. (android:icon="@mipmap/logo" 부분은 제가 임의로 아이콘을 만들어 준 부분이므로 신경쓰시지 않으셔도 됩니다. 위 부분은 애플리케이션을 실행 시, MainActivity로 시작하겠다는 뜻입니다.)


보시는 것과 같이 <activity android:name=".SplashActivity" /> 를 한 줄 추가해주면 됩니다.

반응형

WRITTEN BY
SiriusJ

,
반응형

특정 버튼을 클릭했을 때의 종료 이벤트를 발생시켜서 애플리케이션이 종료하게 하면 됩니다.


[MainActivity.java]

public class MainActivity extends Activity {

private Button exitBtn;


@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);


exitBtn = (Button)findViewById(R.id.btn_exit);


exitBtn.setOnClickListener(new View.OnClickListener() {        //버튼을 클릭했을 때, Click이벤트를 발생

@Override

public void onClick(View v) {            //아래에서 클릭했을 때의 수행되는 부분으로, 원하는 대로 작성하면 됩니다.

//저는 Dialog를 통하여 종료이벤트를 수행하게 하였습니다.

new AlertDialog.Builder(MainActivity.this)

.setTitle("Application 종료")

.setMessage("애플리케이션을 종료하시겠습니까?")

.setPositiveButton("OK", new DialogInterface.OnClickListener() {

@Override

public void onClick(DialogInterface dialog, int which) {

Toast.makeText(MainActivity.this, "애플리케이션이 종료되었습니다.", Toast.LENGTH_SHORT).show();

finish();

}

})

.setNegativeButton("NO", null)        

//"NO"를 사용자가 클릭했을 때에는 null. 즉 아무 작업도 수행하지 않고 다시 main화면으로 돌아가게 됩니다.

.setIcon(android.R.drawble.ic_dialog_alert)        

//Icon은 기존 제공하는 이미지를 사용하였습니다.

.show();

}

});

});

}


//////////////////////////////////////////////////////////////////////////////////////////////////////////

[activity_main.xml]

<Button

android:id="@+id/btn_exit"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="종료"

android:textSize="10dp"> </Button>


다음과 같이 id는 btn_exit로 하여 버튼을 하나 추가시켜주면 됩니다.

반응형

WRITTEN BY
SiriusJ

,
반응형

( Android에서 현재 시간 알기 )


[MainActivity.java]

import java.util.Date;


public class MainActivity extends Activity {

TextView timeView;

long now_Time = System.currentTimeMillis();

Date date = new Date(now_Time);

//날짜, 시간정보 받아오기

SimpleDateFormat CurDateFormat = new SimpleDateFormat("yyyy년 MM월 dd일");

SimpleDateFormat CurTimeFormat = new SimpleDateFormat("HH시 mm분");

SimpleDateFormat CurYearFormat = new SimpleDateFormat("yyyy");

SimpleDateFormat CurMonthFormat = new SimpleDateFormat("MM");

SimpleDateFormat CurDayFormat = new SimpleDateFormat("dd");

SimpleDateFormat CurHourFormat = new SimpleDateFormat("HH");

SimpleDateFormat CurMinuteFormat = new SimpleDateFormat("mm");


//위에서 지정된 포맷으로, String 타입으로 리턴합니다.

String strCurDate = CurDateFormat.format(date);

String strCurTime = CurTimeFormat.format(date);

String strCurYear = CurYearFormat.format(date);

String strCurMonth = CurMonthFormat(date);

String strCurDay = CurDayFormat.format(date);

String strCurHour = CurHourFormat.format(date);

String strCurMinute = CurMinuteFormat.format(date);


/* 위와 같이 MainActivity에서 날짜 및 시간에 대한 정보를 얻을 수 있습니다.

만약 TextView에서 위의 정보를 이용하여 보여주고 싶다면, 아래와 같이 setText를 통해 월, 일, 시간에 대한 정보를 볼 수 있게 됩니다. */


@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);


timeView = (TextView)findViewById(R.id.txt_curTime(보여줄 TextView의 id));

timeView.setText("현재 시간정보 = " + strCurMonth + "월 " + strCurDay + "일 " + strCurHour + "시");

}


////////////////////////////////////////////////////////////////////////////////////

[activity_main.xml]

<TextView

android:id="@+id/txt_curTime"

android:layout_width="match_parent"

android:layout_height="match_parent"

android:textSize="12dp" />


이 소스에서는 TextView를 하나 만들어 준 후, MainActivity에서 사용하기 위하여 android.id를 txt_curTime 으로 해주면 됩니다. id만 추가하면 됩니다.

반응형

WRITTEN BY
SiriusJ

,
반응형

( 안드로이드 폰에서 Back 키 두 번 눌러서 애플리케이션 종료하기 )


보통 애플리케이션을 실행한 후, 종료할 때에 안드로이드 BACK 키를 2번 눌러서 종료해본 경험이 있으실 것입니다.

안드로이드 첫 포스팅은 애플리케이션 메인화면에서 BACK를 1번 눌렀을 때, 확인 토스트 창을 한 번 띄워서 확인을 한 후, 일정시간 안에 다시 한번 눌렀을 때, 종료하는 부분을 다뤄보겠습니다.


안드로이드 스튜디오를 설치 후, 프로젝트를 생성하여 MainActivity를 띄워 놓았다는 가정 하입니다.

[MainActivity.java]

import android.app.Activity;

import java.util.Calendar;

import android.os.Message;

import android.os.Handler;

import android.widget.Toast;


public class MainActivity extends Activity {

//2번 back누르면 종료시키도록

private boolean flag_BackKey = false;                //BACK KEY가 눌려졌는지에 대한 FLAG 로 사용됩니다.

private long currentTime = 0;                          // Time(Millis) Interval을 계산합니다.

private static final int MSG_TIMER = 1;              // Switch문에서 사용하게 되는 Key값입니다.

private static final int BACKKEY_TIMEOUT = 2;    // Interval을 정의합니다.

private static final int IN_MILLISEC = 1000;        // Millis를 정의합니다.


@Override

    protected void onCreate(Bundle savedInstanceState) {

       super.onCreate(savedInstanceState);

       setContentView(R.layout.activity_main);


       //back버튼을 두번 누르면 종료되도록 합니다.

    @Override

    public void onBackPressed(){            //BACK키가 눌렸을 때의 함수로 Override하여 사용합니다.

            if ( flag_BackKey == false ){

                // 첫 번째로 클릭했을 경우로, false에서 true로 바꿔줍니다.

            flag_BackKey = true;


            currentTime = Calendar.getInstance().getTimeInMillis();       //Java의 Calendar를 import하여 사용합니다.

            Toast.makeText(this, "\'뒤로\'버튼을 한번 더 누르시면 종료됩니다.", Toast.LENGTH_SHORT).show();

//Toast는 차후에 설명하겠지만, 첫번째 파라미터 this는 현 수행중인 MainActivity이며, 두번째 파라미터는 출력할 문자열입니다. 세번째 파라미터는 Toast창을 길게 보여줄 것인지, 짧게 보여줄 것인지에 대한 시간 간격으로 SHORT와 LONG 이 있습니다.

            startTimer();

            }else{            //만약 BACKKey의 플래그가 현재 false가 아닌, true 라면 아래를 수행합니다.

                // second click : 2초 이내면 종료! 아니면 아무것도 안한다.

            flag_BackKey = false;

            if ( Calendar.getInstance().getTimeInMillis() <= (currentTime + (BACKKEY_TIMEOUT * IN_MILLISEC )) ) {

                    finish();                //currentTime + 2000 (2초) 이므로, 2초 안에 클릭 했을 때, MainActivity를 종료해주는 부분입니다.

            }

        }

    }


    private void startTimer() {                                    //2초의 시간적 여유를 가지도록 Delay 시킵니다.

        backTimerHandler.sendEmptyMessageDelayed(MSG_TIMER , BACKKEY_TIMEOUT * IN_MILLISEC );

    }


    private Handler backTimerHandler = new Handler(){

        public void handleMessage(Message msg){

            switch( msg.what ){                //msg의 값이 무엇인지 파악하여 만약 MSG_TIMER라면, flag를 다시 false로 해줍니다.

                case MSG_TIMER :{

                    flag_BackKey = false;

                }

                break;

            }

        }

    };


==> 즉, 전체적인 구조를 정리하면, MainActivity. 즉 메인화면에서 BACK키를 한번 누르게 되면 Toast창을 출력 한 후, onBackedPressed 함수를 수행하여 flag를 false->true로 바꿔준 후, startTimer함수를 거쳐서 Handler를 수행하게 됩니다. BACKKEY_TIMEOUT 의 값을 통하여 2초로 Delay를 줄것인지, 그 밖의 임의의 값을 Delay로 줄 수 있습니다. 그 안에 한번 더 BACK Key를 누르게 되면 finish() 를 통해 MainActivity를 종료해주게 됩니다.

반응형

WRITTEN BY
SiriusJ

,
반응형

접근 제한자는 public, protected, default, private 와 같이 네 가지 종류가 있습니다.


public 접근 제한자 외부 클래스가 자유롭게 사용할 수 있는 공개 멤버를 만듭니다.

protected 접근 제한자는 같은 패키지 또는 자식클래스에서 사용 할 수 있는 멤버를 만듭니다.

private 접근 제한자는 단어의 뜻 그대로 개인적인 것이라 외부에 노출되지 않는 멤버를 만듭니다

-> 위 세 가지 접근 제한자가 적용되지 않은 멤버는 default 접근 제한을 가지게 됩니다.

default 접근 제한자는 같은 패키지에 소속된 클래스에서만 사용할 수 있는 멤버를 만듭니다.


접근 제한 

적용 대상 

접근할 수 없는 클래스 

 public

클래스, 필드, 생성자, 메소드 

없음 

 protected

필드, 생성자, 메소드 

자식 클래스가 아닌 다른 패키지에 소속된 클래스 

 default

클래스, 필드, 생성자, 메소드 

다른 패키지에 소속된 클래스 

 private

필드, 생성자, 메소드 

모든 외부 클래스 


[클래스의 접근 제한]

클래스를 선언 시, 고려사항은 같은 패키지 내에서만 사용할 것인지, 다른 패키지에서도 사용할 수 있도록 할것인지를 결정하는 것입니다.

클래스에 적용할 수 있는 접근제한은 public 과 , default 단 두가지입니다.


예시)

//(1) default 접근 제한

class 클래스 { ... }

//(2) public 접근 제한

public class 클래스 { ... }


(1)

class A { }

class B { }

=> (1) 의 경우에는 같은 패키지 내에서는 A클래스와 B 클래스가 아무 제한 없이 사용할 수 있지만, 다른 패키지에서는 사용할 수 없도록 제한됩니다.

(2)

public class C { }

class D { }

==> (2) 의 경우에는 클래스를 선언 시, public 접근 제한자를 붙였다면 클래스는 public 접근 제한을 가지게 되고, 다른 패키지에서도 자유롭게 사용할 수 있습니다.

인터넷으로 배포되는 라이브러리 클래스들도 모두 public 접근 제한을 가지고 있습니다.


[생성자의 접근 제한]

객체를 생성하기 위해서는 new 연산자로 생성자를 호출해야 합니다. 하지만 생성자 또한 어디에서나 호출할 수 있는 것은 아닙니다. 생성자가 어떤 접근 제한을 갖느냐에 따라 호출가능 여부가 결정됩니다.

생성자는 public, protected, default, private 접근제한을 가질 수 있습니다.

ex)

public class ClassName {

public ClassName( ... ) { ... }

protected ClassName( ... ) { ... }

ClassName( ... ) { ... }

privaet ClassName( ... ) { ... }

}

접근 제한자 

생성자 

명 

 public

클래스( ... ) 

public 접근 제한은 모든 패키지에서 아무런 제한 없이 생성자를 호출할 수 있도록 합니다. 생성자가 public 접근 제한을 가진다면 클래스도 public 접근 제한을 가지는 것이 정상적입니다. 클래스가 default 접근 제한을 가진다면 클래스 사용이 같은 패키지로 한정되므로, 비록 생성자가 public 접근 제한을 가지더라도 같은 패키지에서만 생성자를 호출할 수 있습니다. 

 protected

클래스 ( ... ) 

protected 접근 제한은 default 접근 제한과 마찬가지로 같은 패키지에 속하는 클래스에서 생성자를 호출할 수 있도록 합니다. 차이점은 다른 패키지에 속한 클래스가 해당 클래스의 자식(child)클래스라면 생성자를 호출할 수 있습니다. 

 default

클래스 ( ... ) 

생성자를 선언할 때 public 또는 private 를 생략 했다면 생성자는 default 접근 제한을 가집니다. default 접근 제한은 같은 패키지에서는 아무런 제한 없이 생성자를 호출할 수 있으나, 다른 패키지에서는 생성자를 호출할 수 없도록 합니다. 

 private

클래스 ( ... ) 

private 접근 제한은 동일 패키지이건 다른 패키지이건 상관없이 생성자를 호출하지 못하도록 제한합니다. 즉, 클래스 외부에서 new 연산자로 객체를 만들 수 없습니다. 오로지 클래스 내부에서만 생성자를 호출할 수 있고, 객체를 만들 수 있습니다. 


[필드와 메소드의 접근 제한]

필드와 메소드를 선언할 때 고려사항은 클래스 내부에서만 사용할 것인지, 패키지 내에서만 사용할지 다른패키지에서도 사용할지를 결정해야 합니다. 이것은 필드와 메소드가 어떤 접근 제한을 갖느냐에 따라 결정됩니다.

필드와 메소드는 다음과 같이 public, protected, default, private 접근 제한을 가질 수 있습니다.

예시)

//필드 선언

[ public | protected | private ] [static] 타입 필드;

//메소드 선언

[ public | protected | private ] [static] 리턴 타입 메소드( ... ) { ... }

 접근 제한자

생성자 

명 

 public

필드

메소드 ( ... ) 

public 접근 제한은 모든 패키지에서 아무런 제한 없이 필드와 메소드를 사용할 수 있도록 해줍니다. 필드와 메소드가 public 접근 제한을 가질 경우 클래스도 public 접근 제한을 가져야 합니다. 클래스가 default 접근 제한을 가지게 되면 같은 패키지 안에서만 클래스가 사용되기 때문입니다. 

 protected

필드

메소드 ( ... ) 

protected 접근 제한은 default 접근 제한과 마찬가지로 같은 패키지에 속하는 클래스에서 필드와 메소드를 사용할 수 있도록 합니다. 차이점은, 다른 패키지에 속한 클래스가 해당 클래스의 잣기 클래스라면 필드와 메소드를 사용할 수 있습니다. 

 default

필드

메소드 ( ... ) 

필드와 메소드를 선언할 때 public 또는 private 를 생략했다면 default 접근제한ㅇ르 가집니다. default 접근 제한은 같은 패키지에서는 아무런 제한 없이 필드와 메소드를 사용할 수 있으나, 다른 패키지에서는 필드와 메소드를 사용할 수 없도록 합니다. 

 private

필드

메소드 ( ... ) 

private 접근 제한은 동일 패키지이건 다른 패키지이건 상관 없이 필드와 메소드를 사용하지 못하도록 제한합니다. 오로지 클래스 내부에서만 사용할 수 있습니다. 


반응형

WRITTEN BY
SiriusJ

,
반응형

[final 필드]

final의 의미는 최종적이란 뜻을 가지고 있습니다.

final필드는 초기값이 저장되면 이것이 최종적인 값이 되어서 프로그램 실행 도중에 수정할 수 없다는 것입니다. final 필드는 다음과 같이 선언됩니다.


final 타입 필드 [ = 초기값];


ex)

[Person.java]

public class Person {

final String nation = "Korea";

final String num;

String name;


public Person(String num, String name) {

this.num = num;

this.name = name;

}

}


[PersonExample.java]

public class PersonExample {

public static void main(String[] args) {

Person p1 = new Person("123-123", "최진우");


System.out.println(p1.nation);

System.out.println(p1.num);

System.out.println(p1.name);


//p1.nation = "USA"';        -> final 필드는 값 수정 불가

//p1.num = "456-456";      -> final 필드는 값 수정 불가

p1.name = "지누";

}

}


[상수 (static final) ]

일반적으로 불변의 값을 상수라고 부릅니다.

이런 불변의 값을 저장하는 필드를 자바에서 상수(constant) 라고 합니다.

final과 차이를 살펴보겠습니다.

final필드는 한 번 초기화 되면 수정할 수 없는 필드라고 하였습니다. 그러나 final필드를 상수라 하지는 않습니다.

왜냐하면 불변의 값은 객체마다 저장할 필요가 없는 공용성을 띠고 있으며, 여러가지 값으로 초기화 될 수 없기 때문입니다.

final 필드는 객체마다 저장되고, 생성자의 매개값을 통해서 여러가지 값을 가질 수 있기 때문에 상수가 될 수 없습니다. 상수는 static 이면서, final 이어야 합니다. static final 필드는 객체마다 저장되지 않고, 클래스에만 포함됩니다.

그리고 한 번 초기값이 저장되면 변경할 수 없습니다.

static final 타입 상수 [ = 초기값];


예시)

static final 타입 상수;

static {

상수 = 초기값;

}


ex)

static final double  PI = 3.14159;

static double EARTH_SURFACE_AREA;

-> (상수 이름은 모두 대문자로 작성하는 것이 관례입니다.)


반응형

WRITTEN BY
SiriusJ

,
반응형

전체 프로그램에서 단 하나의 객체만 만들도록 보장해야 하는 경우가 있습니다.

단 하나만 생성된다고 해서 이 객체를 싱글톤(Singleton)이라 합니다. 싱글톤을 만들려면 클래스 외부에서 new 연산자로 생성자를 호출할 수 없도록 막아야 합니다. (생성자를 호출한 만큼 객체가 생성되므로)

생성자를 외부에서 호출할 수 없도록 하려면 생성자 앞에 private 접근 제한자를 붙여주면 됩니다.


예시)

[싱글톤을 만드는 코드]

public class 클래스 {

//정적 필드

private static 클래스 singleton = new 클래스();


//생성자

private 클래스() {}


//정적 메소드

static 클래스 getInstance() {

return singleton;

}

}


(싱글톤 객체는 힙(heap)영역에 들어있습니다.)

==> 외부에서 객체를 얻는 유일한 방법은 getInstance() 메소드를 호출하는 방법입니다

getInstance() 메소드는 단 하나의 객체만 리턴하기 때문에 아래 코드에서 변수1과 변수2는 동일한 객체를 참조합니다.


ex)

클래스 변수1 = 클래스.getInstance();

클래스 변수2 = 클래스.getInstance();



ex) [Singleton.java]

public class Singleton {

private static Singleton singleton = new Singleton();

private Singleton() { }


static Singleton getInstance() {

return singleton;

}

}


[SingletonExample.java]

public class SingletonExample {

public static void main(String[] args) {

/*

Singleton obj1 = new Singleton();        //컴파일 에러

*/

Singleton obj1 = Singleton.getInstance();

Singleton obj2 = Singleton.getInstance();


if(obj1 == obj2) {

System.out.println("같은 Singleton객체입니다.");

} else {

System.out.println("다른 Singleton객체입니다.");

}

}

}


[결과]

==> 같은 Singleton객체입니다.


반응형

WRITTEN BY
SiriusJ

,
반응형

[정적 멤버와 static]

정적(static)은 '고정된'이란 의미를 가지고 있다. 정적 멤버는 클래스에 고정된 멤버로서 객체를 생성하지 않고 사용할 수 있는 필드와 메소드를 말합니다. 

이들을 각각 정적 필드, 정적 메소드라고 부릅니다.

또한 정적멤버는 객체(인스턴스)에 소속된 멤버가 아니라 클래스에 소속된 멤버이기 때문에 클래스 멤버라고도 합니다.


[정적 멤버 선언]

정적 필드와 정적 메소드를 선언하는 방법은 필드와 메소드 선언 시 static 키워드를 추가적으로 붙이면 된다.

예시)

public class 클래스 {

//정적 필드

static 타입 필드 [= 초기값];


//정적 메소드

static 리턴 타입 메소드 (매개변수선언, ...) {

...

}

}


->ex)

public class Calculator {

String color;                    //color는 변할 수 있음.

static double pi = 3.14159;        //어디에서건 파이 값은 동일함.

static int plus(int x, int y) {            //정적 메소드

return x + y;

}

}


[정적 멤버 사용]

클래스가 메모리로 로딩되면, 정적 멤버를 바로 사용할 수 있는데, 클래스 이름과 함께 도트(.) 연산자로 접근할 수 있습니다.

예시) 

클래스.필드;

클래스.메소드(매개값, ...);


->ex)

public class Calculator {

static double pi = 3.14159;

static int plus(int x, int y) { 

return x + y;

}

static int minus(int x, int y) { 

return x - y;

}

}


public class CalcTest {

public static void main(String[] args) {                //main 실행
    double result1 = 10 * 10 * Calculator.pi;

int result2 = Calculator.plus(10, 5);

int result3 = Calculator.minus(10, 5);


System.out.println("result1 = " + result1);

System.out.println("result2 = " + result2);

System.out.println("result3 = " + result3);

}

}


[정적 초기화 블록]

정적 블록은 클래스가 메모리로 로딩될 때 자동적으로 실행됩니다. 정적 블록은 클래스 내부에 여러 개가 선언되어도 상관없습니다. 클래스가 메모리로 로딩될 때 선언된 순서대로 실행됩니다.

예시)

static {

....

}


->ex)

[Television.java]

public class Television {

static String company = "Samsung";

static String model = "LCD";

static  String info;


static {

info = company + "-" + model;

}

}


[TvExample.java]

public class TvExample {

public static void main(String[] args) {
    System.out.println(Television.info);

}

}


[결과 값]

==> Samsung-LCD


[정적 메소드와 블록 선언 시 주의할 점]

정적 메소드와 정적 블록을 선언 시 주의할 점은 객체가 없어도 실행된다는 특징 때문에, 이들 내부에 인스턴스 필드나 인스턴스 메소드를 사용할 수 없습니다. 또한 객체 자신의 참조인 this 키워드도 사용이 불가능 합니다.


ex)

public class ClassName {

//인스턴스 필드와 메소드

int field1;

void method1() { ... }


//정적 필드와 메소드

static int field2;

static void method2() { ... }


//정적 블록

static {

field1 = 10;         (x)       ->컴파일 에러

method1();          (x)       ->컴파일 에러

field2 = 10;         (0)

method2();          (0)

}

//정적 메소드

static void method3 {

this.field1 = 10;        (x)       ->컴파일 에러

this.method1();         (x)       ->컴파일 에러

field2 = 10;              (0)

method2();               (0)

}

}


==> 정적 메소드와 정적 블록에서 인스턴스 멤버를 사용하고 싶다면 아래와 같이 객체를 먼저 생성 후, 참조 변수로 접근해야 합니다.

{Method3 정적 메소드]

static void Method3() {

ClassName obj = new ClassName();

obj.field1 = 10;

obj.method1();

}


반응형

'Programming > JAVA' 카테고리의 다른 글

Java - (11) final 필드와 상수  (0) 2016.05.15
Java - (10) 싱글톤(Singleton)  (0) 2016.05.15
Java - (8) 메소드 (Method)  (0) 2016.05.15
Java - (7) 생성자 오버로딩(Overloading)  (0) 2016.05.04
Java - (6) 객체와 클래스(Class)  (0) 2016.05.04

WRITTEN BY
SiriusJ

,