JAVA - 생성자, 메서드, static

 

생성자는 인스턴스 변수를 초기화시켜준다.

 

항상 해왔던 것처럼 문법과 특징을 알려주겠다.

 

 

 

문법:
       public 클래스명([변수,..]){}

  특징: 반드시 호출해야 실행된다.
       ==> 호출방법 2가지
        1) 다른 클래스에서
     new 클래스명([값,..]);
 2) 자신 클래스에서
     this([값,..]);

       -반드시 클래스명으로 지정해야 된다.
       -개발자가 명시적으로 생성자를 지정하지 않으면 자동으로 생성자를 제공한다. ( 기본 생성자, default 생성자 )
        ==> public 클래스명(){}
        단 개발자가 명시적으로 생성자를 지정하면 기본 생성자는 제공이 안된다.
       -오버로딩(overloading) 생성자가 가능하다.
        ==> 개념: 하나의 클래스 안에 동일한 이름의 생성자가 여러 개 지정이 가능함.
==> 규칙: 반드시 인자 리스트(파라미터)가 다르면 가능하다.
         인자리스트는 개수, 타입, 순서 의미.
        ==> 장점: 재사용성 목적

 

 

 

생성자는 이처럼 우리가 

public class Cat {

        // private로 지정하면 외부클래스에서 접근이 불가능
        private String name;
        private int age;
        private String gender;
}

 

으로 정의한 것과 같이 private로 접근이 불가한

것을 접근이 가능하게 만들어주는 것이다.

public Cat(String name, int age, String gender) {
    this.name = name;
    this.age = age;
    this.gender = gender;
}

 

 

이처럼 생성자를 만들어주고

 

 

두 번째로 메서드는

 

용도: 기능처리
         일반적으로 인스턴스 변수와 관련된 기능처리이다. ( 변숫값 수정, 변수값 조회, 유효성검사 기능등 )

  문법:
   
       public 리턴타입 메서드명([변수,...]){  // 파라미터는 없거나 여러 개 지정 가능
   문장 1;
   [return 값;]  // 리턴값,  리턴값은 없거나 반드시 한 개만 지정 가능
       }

  3) 특징:
        반드시 호출해야 실행된다.
         ==> 호출 방법은?
    1) 다른 클래스에서
        step1: 반드시 객체생성해야 된다.
       클래스명  참조변수명 = new 클래스명([값,..]);
                step2: 참조변수명. 메서드([값,...]);
 
    2)  자신 클래스에서
         step1: 반드시 객체생성해야 된다.
       클래스명  참조변수명 = new 클래스명([값,..]);

 step2: this. 메서드([값,...]);
        또는
                        메서드([값,...]);

  4) 메서드의 파라미터 및 리턴값의 따른 4가지 형식

    1)  파라미터 없고 리턴값없는 경우
      문법:
         public class 클래스명{
           public void 메서드명(){
              문장;
   }
   public void 메서드명 2(){
              문장;
      this. 메서드명(); //  메서드명();
   }
 }

      사용:
           클래스명  참조변수명 = new 클래스명();
           참조변수명. 메서드명();

    2)  파라미터 있고 리턴값없는 경우
      문법:
          public class 클래스명{
 
             public void 메서드명 1(int n){
     }
     public void 메서드명 1(String n){
     }
     public void 메서드명1(String n, int n2){
     }
  }
        사용:
           클래스명  참조변수명 = new 클래스명();
           참조변수명. 메서드명 1(10);
   참조변수명. 메서드명 1("홍길동");
   참조변수명. 메서드명 1("홍길동", 10);
 
     *오버로딩 메서드 ( overloading )
     개념: 하나의 클래스 안에 동일한 이름의 메서드가 여러 개 지정이 가능하다.
          단 식별하기 위해서 인자리스트( 개수, 타입, 순서 )를 반드시 달라야 된다.
     - 장점: 재사용


    3)  파라미터 없고 리턴값있는 경우
     문법:
          public class 클래스명{

     public 리턴되는 값타입 메서드명(){
                   문장 1;
 return 값;  // 리턴되는 값: 리턴값
     }
  }
 예>
    public int x(){
문장;
return 100;
    }
           public String x(){
문장;
return "홍길동";
    }
     사용:
          클래스명  참조변수명 = new 클래스명();
          리턴값저장용변수 =  참조변수명. 메서드명();


    4)  파라미터 있고 리턴값있는 경우

     문법:
          public class 클래스명{

    public 리턴타입 메서드명(변수, 변수 2,...){
               문장;
               return 값;
    }
  }

예> public int sum(int n, int n2){
              return n+n2;
   }

     사용:
           클래스명  참조변수명 = new 클래스명();
          리턴값저장용변수 =  참조변수명. 메서드명(값, 값 2);


4. 메서드 호출 시 파라미터에 전달하는 값(인자값,argument)인 기본형 vs 참조형

   => call by value   vs call by value Reference

   1) call by value
     ==> 메서드 호출 시 파라미터에 인자값으로 기본형 데이터를 전달할 수 있다.
     이때 전달받은 메서드에서 값을 수정할 수 있음. 원본은 변경 안됨.


   2) call by value Reference
     ==> 메서드 호출시 파라미터에 인자값으로 참조형 데이터(클래스, 배열)를 전달 할 수 있다.
     이때 전달받은 메서드에서 값을 수정할 수 있음. 원본이 변경됨.
       이유는 전달되는 인자값이 주소값이기 때문이다.

 

//메서드
// 이름 변경하는 메서드: 나 번 사용하자
// 나.파라미터 있고 리턴값 없는 경우
public void setName(String name) {
    this.name = name;
}
// 나이 변경하는 메서드
public void setAge(int age) {
    this.age = age;
}
// 성별 변경하는 메서드
public void setGender(String gender) {
    this.gender = gender;
}

// 이름 조회하는 메서드:  다 번
// 다. 파라미터 없고 리턴값 있는 경우
public String getName() {
    return name;
}

// 나이 조회하는 메서드:
public int getAge() {
    return age;
}
// 성별 조회하는 메서드:
public String getGender() {
    return gender;
}

 

 

 

 

마지막으로 스테틱은

 

 

static 키워드 ( 정적 )

  1) 개념:  프로그램 실행과 관련된 키워드임. ( 객체생성인 new와 무관, 객체생성 전에 결정된다. )
           static으로 지정된 변수 및 메서드, 클래스는 프로그램 실행 시 생성이 된다. (************)

  2) 로컬 변수 vs 인스턴스 변수 vs static 변수
  
     로컬변수: 메서드 안에서 선언. 메서드 호출~ 메서드종료. stack메모리
     인스턴스변수: 메서드밖에서 선언.  객체생성(new)~객체소멸. heap 메모리
                객체소멸시점? heap에 생성된 인스턴스를 참조 못할 때
                사용방법?  
   Cat c = new Cat();
   c. 변수명;
                생성 횟수? new 할 때마다 매번 생성된다. (공유 안됨)
        용도: 객체의 속성 저장 예> 고양이 이름, 나이

     static변수: 메서드밖에서 선언하고 static 지정. 프로그램실행~프로그램 종료, method area메모리
                프로그램실행시점? run > main 시작
                프로그램 종료시점?   main 종료
==> 객체생성(new)과 무관하다. (*****************)
    객체생성(new) 전에 생성된다.
                사용방법? 클래스명. static변수;
생성 횟수? 한 번만  생성된다. 
용도: 한번만 생성되고 가장 lifecycle 길다. ==> 데이터를 공유할 목적

  3) 메서드(인스턴스 메서드, 멤버 메서드 ) vs static 메서드

     메서드(인스턴스 메서드,멤버 메서드 ): 메서드 생성시점? new 할 때(객체생성) 생성
                                   메서드 소멸시점? 객체소멸 시 제거
   사용방법?  
           Cat c = new Cat();
   c. 메서드명();
                                   생성 횟수? new 할 때마다 매번 생성된다.
           (실제로는 공유한다.)
   
     static 메서드:   메서드 생성시점? 프로그램실행 시 생성
                    메서드 소멸시점? 프로그램 종료 시 제거
   ==> 객체생성(new)과 무관하다. (*****************)
       객체생성(new) 전에 생성된다.
    사용방법? 클래스명. static메서드();
    생성 횟수? 한 번만  생성된다.
    용도: new 없이 사용할 목적이다.
      예> Integer.parseInt("10");
                    *주의할 점
     - 인스턴스 변수 및 this 키워드 사용불가 ==> 아직 인스턴스가 생성 안됨.
     - 상속 관련에서는 오버라이딩(Overriding) 불가


 4) 일반 클래스 vs static 클래스
   
   ==> static 클래스는 반드시 중첩 클래스에서만 사용이 가능하다.
      * 중첩클래스
       
        public  class A { // 외부클래스, outer class )
   //변수
   //생성자
   //메서드

           //클래스 (중첩클래스, nested class, inner class )
  static class B {

  }//end B

}//end A
   
   ==> A 클래스는 반드시 new 해야 된다.
   하지만 B클래스는 프로그램실행 시 자동으로 생성된다.

  
   5) static 블록 ( *********** )

   ==> 문법:
    
           static {
              실행문;
   }

     특징: 프로그램 시작할 때 자동으로 실행된다.
          초기화 작업 ( 예> DB 및 파일 연동 시 )

 

혹시나 쓴이가 잘못된 부분이 있거나 수정이 필요한 부분이 있으면

꼭!! 알려주길 바란다.