본문 바로가기
java

22.11.08 접근제한자, 생성자, static, no-static

by SoulMania 2023. 2. 13.

221108.zip
0.01MB
Student01_Main_송준호.txt
0.00MB
Student01_송준호.txt
0.00MB
설명.txt
0.03MB
숙제.xlsx
0.01MB

이클립스 언어 세팅

윈도우 프리퍼런시즈

제너럴 어피어런스 - 컬러 앤드 폰트 -> 텍스트 폰트 콘솔애즈

에디터스 - 텍스트 에디터스 - 쇼라인넘버스

  -  텍스트 에디터스 스펠링 UTF-8  어플라이!!!

웹브라우저 - 익스터널 웹브라우저 - 크롬!

워크스페이스 - other UTF-8

private ----> 동일 클래스 안에서만 가능 가능한 것
protected ----> 상속관계에 있는 것 들 끼리만 사용가능
default ----> 동일 패키지 안에있는 것 들 끼리만 사용가능
public ----> 모두 사용가능

public 선언 생략시...아무것도 선언 안하면 default 가 적용....

  • 클래스 선언할 때 public 생략한 경우 ​
  • 다른 패키지에서는 사용 불가​

public

  • 다른 개발자가 사용할 수 있도록 라이브러리 클래스로 만들 때 유용​

package ch06;

public class Member01 {
//field
//[접제][제] 타입 필드명
//static 필드(=정적필드)클래스 명을 통해서 접근한다!!! 그래서 클래스 필드라고도 한다. (대신 앞에 static이 붙는다.)
static String nation = "KOREA~"; //대한민국 사람만 있으므로 국적은 초기값으로 모두 동일하게 초기화 한다. (static field) 참조변수명이 없기 때문에 static이 붙는다고도 볼 수 있다.
//동일한 변수 값에 대해서 static 이라고 선언하면 객체를 굳이 만들지 않아도 접근가능하다!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

//인스턴스 필드  --->>> 인스턴스 변수, 즉 참조변수는 참조변수 명.필드데이터 이런식으로 접근을 해줘야한다. 참조변수명에 주소가 있으므로. (non-static field)
String name; // 이름
String id; // id
String pwd; // 비번
int age; // 나이

// 생성자
// [접제][제] 클래스명 (매개변수){}
// 기본생성자 - 매개변수없는 생성자
//==> new Member01();
Member01(){} // --> 기본 생성자(default constructor)
//매개변수 있는 생성자-주로 필드값을 초기화
Member01(String name, String id, String pwd, int age){
this.name = name;
this.id = id;
this.pwd = pwd;
this.age = age;
}

// method
// [접제][제] 리턴유형 메소드명(매개변수){}
public void test(){

}  // --> 기본 생성자(default constructor)

}

package ch06;

//이 클래스는 회원관련 데이터, 기능을 실행하는 클래스이다.
public class Member01_Main {

static void showView(Member01 my) {
    System.out.println("Member name : "+my.name);
    System.out.println("Member ID : "+my.id);
    System.out.println("Member PW : "+my.pwd);
    System.out.println("Member age : "+my.age);
    System.out.println("==========================================");

    }




//non-static메소드 =>참조변수명.메소드명()

// void test() {}
//static메소드 => 클래스명.메소드명()
// static void testt() {}

public static void main(String[] args) {

    //static메소드를 호출

// 그러나 public static void main 또는 위에 과 같이 static void testt와 같은 static 메소드는 참조변수를 선언할 필요가 없다.
// Member01_Main.testt();

    //정적메소드를, non-static메소드 ==>p233, p236, p237
    //객체생성

// 클래스타입 참조변수=new 클래스명();
// Member01 a = new Member01();
// 참조변수명.test();
// a.test();
// static이 붙지 않은 논 스태틱 메소드는 위와같이 참조변수 선언및 객체 선언해주고
//참조변수.test();로 접근!!! 기존 인스턴스 생성과 동일하다.

//★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
// new Member01.test(); ---> new를 붙여서 인스턴스 화 되면 앞에 test(); 메소드에 static이 붙으면 안된다. -->>인스턴스화 자체가 참조변수를 만들고 객체를 생성하면서 생성자가 생성되기 때문에
// ---> 반대로 new를 선언하지 않고 Member01.test(); 가 적용되려면 test(); 메소드에 static 이 븥어야 한다.
//★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

    //참조변수선언 및 객체생성
    //클래스명 참조변수=new 생성자();

// Member01 mem1 = null; //이런식으로 따로 선언해도 무관 -->객체의 주소가 저장될 변수 선언 (참조변수 = 인스턴스변수)
// mem1 = new Member01("홍길동", "hid", "h123", 20); //이런식으로 따로 선언해도 무관
Member01 mem1 = new Member01("홍길동", "hid", "h123", 20);
//mem1은 인스턴스 변수
// mem1.nation = "Republic of Korea"; //이렇게 해도 상관없으나 ... 더 좋은 방법으로

~ 주석
// System.out.println("Member nation : "+mem1.nation);
System.out.println("Member nation : "+Member01.nation); // -->>이건 어느 클래스안에 nation 인지를 찍는 더 확실한 방법. -->절대경로 느낌 //정적필드
System.out.println("클래스명.nation = "+mem1.name);
System.out.println("Member ID : "+mem1.id);
System.out.println("Member PW : "+mem1.pwd);
System.out.println("Member age : "+mem1.age);
System.out.println("==========================================");
showView(mem1);
Member01 mem2 = new Member01("손흥민", "sid", "s123", 31);
// mem2.nation = "Republic of Korea"; //이렇게 해도 상관없으나 ... 더 좋은 방법으로

주석
// System.out.println("Member nation : "+mem2.nation);
System.out.println("클래스명.nation = "+Member01.nation); // -->>이건 어느 클래스안에 nation 인지를 찍는 더 확실한 방법. -->절대경로 느낌 //정적필드
System.out.println("Member name : "+mem2.name);
System.out.println("Member ID : "+mem2.id);
System.out.println("Member PW : "+mem2.pwd);
System.out.println("Member age : "+mem2.age);
System.out.println("==========================================");
showView(mem2);
Member01 mem3 = new Member01("이순신", "lid", "l123", 35);
// mem3.nation = "Republic of Korea"; //이렇게 해도 상관없으나 ... 더 좋은 방법으로~~ 주석
// System.out.println("Member nation : "+mem3.nation);
System.out.println("클래스명.nation = "+Member01.nation); // -->>이건 어느 클래스안에 nation 인지를 찍는 더 확실한 방법. -->절대경로 느낌 //정적필드
System.out.println("Member name : "+mem3.name);
System.out.println("Member ID : "+mem3.id);
System.out.println("Member PW : "+mem3.pwd);
System.out.println("Member age : "+mem3.age);
System.out.println("==========================================");
showView(mem3);

        //참조변수명을 통해서 접근하지 않아도 Member01 클래스명.필드변수로 수정 및 출력이 모두 가능하다.
    //객체가 서로 달라도 동일한 값의 데이터를 공유해야하는 경우라면 정적필드 static field를 사용한다!!!이것을 사용하면 각 객체의 참조변수에 담겨있는 주소지를 참고할 필요가 없다.
    //바로 클래스명.으로 접근 및 수정 가능!!!
}

}

package ch06;

public class Member02 {
//field (인스턴스 필드)
//[접근제한자][제어자] 데이터타입 필드명[=값];
//static 필드(=정적필드)클래스 명을 통해서 접근한다!!! 그래서 클래스 필드라고도 한다. (대신 앞에 static이 붙는다.)
static String nation = "KOREA~"; //대한민국 사람만 있으므로 국적은 초기값으로 모두 동일하게 초기화 한다. (static field) 참조변수명이 없기 때문에 static이 붙는다고도 볼 수 있다.
//동일한 변수 값에 대해서 static 이라고 선언하면 객체를 굳이 만들지 않아도 접근가능하다!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

//인스턴스 필드  --->>> 인스턴스 변수, 즉 참조변수는 참조변수 명.필드데이터 이런식으로 접근을 해줘야한다. 참조변수명에 주소가 있으므로. (non-static field)
//field(인스턴스필드)
//[접근제한자][제어자] 
private String name; // 이름
private String id; // id
private String pwd; // 비번
private int age; // 나이

// 생성자
// [접제][제] 클래스명 (매개변수){}
// 기본생성자 - 매개변수없는 생성자
//==> new Member01();
Member02(){} // --> 기본 생성자(default constructor)
//매개변수 있는 생성자-주로 필드값을 초기화
Member02(String name, String id, String pwd, int age){ //생성자 오버로딩
this.name = name;
this.id = id;
this.pwd = pwd;
this.age = age;
}

Member02(String nation, String name, String id, String pwd, int age){ //생성자 오버로딩
    this.name = name;
    this.id = id;
    this.pwd = pwd;
    this.age = age;
}

// method
// [접근제한자][제어자] 리턴유형 메소드명(매개변수리스트){}

// 리턴유형 set필드명(타입 매개변수명->내가 변경하고자하는 필드명과 똑같이 한다.) {
// this.필드명=매개변수명;
// }

void setName(String name) {
    this.name=name;
}
void setId(String id) {
    this.id=id;
}
//pw, age값 변경하는 setter() 작성
void setPwd(String pwd) {
    this.pwd=pwd;
}
void setAge(int age) {
    this.age=age;
}

//따라서 필드 값의 private를 건드리는 것이 아니라 set메소드 앞에 접근제한자를 붙여 관리해준다.

// 리턴유형 get필드명() {
// return 필드명;
// }

String getName() {
    return name; //필드에 있는 값을 리턴 한다!!!!  this.name 인데 생략. 필드에 있는값.
}



String getId() {
return id; //필드에 있는 값을 리턴 한다!!!!  this.id 인데 생략. 필드에 있는값.
}

String getPwd() {
return pwd; //필드에 있는 값을 리턴 한다!!!!  this.pwd 인데 생략. 필드에 있는값.
}

int getAge() {
return age; //필드에 있는 값을 리턴 한다!!!!  this.pwd 인데 생략. 필드에 있는값.
}




public void test(){

}  

public void delete(){

}  

public void update(){

} 



void getInfo(){ //하나하나 get메소드를 만들지 말고 이런식으로 한번에 모아서 메소드 하나로 묶으면 한번에 다 출력한다.
    System.out.println("이름 : "+ this.name);
    System.out.println("아이디: "+ this.id);
    System.out.println("비번 : "+ this.pwd);
    System.out.println("나이 : "+ this.age);
    System.out.println("국가 : "+ this.nation);
    System.out.println();

}

}

package ch06;

public class Member02_Main {

//field

//constructor

//method

public static void main(String[] args) {
    //참조변수선언 및 Member02클래스 객체 생성

    Member02 member1 = new Member02();//기본생성자를 호출


    //private는 다이렉트로 필드로 접근하기보다 set메소드나 get메소드를 이용하여 접근하고 수정해주는것이 좋다.




    //setter()를 이용하여 필드값을 setting가능
    member1.setName("손흥민");


    //이름 확인
    String name1 = member1.getName();//필드로 바로 접근은 불가능 하지만 getter()를 통한 필드의 값을 가져올 수 있다.
    System.out.println(name1);
    //System.out.println(member2.getName());

    member1.setId("sid");

    //id 확인
    String id1 = member1.getId();
    System.out.println(id1);
    //System.out.println(member2.getId()); 

    member1.setPwd("s123");

    //pwd값 확인        
    String pwd1 = member1.getPwd();
    System.out.println(pwd1);
    //System.out.println(member2.getPwd()); 

    member1.setAge(31);

    //age값 확인
    int age1 = member1.getAge();
    System.out.println(age1);
    //System.out.println(member2.getAge()); 

    System.out.println("--------------------------------------------------------------------------");
    member1.getInfo(); //getInfo 메소드로 만들어서 한번에 출력

    System.out.println("--------------------------------------------------------------------------");


    //회원이름 출력
    //System.out.println(member1.name); ///-->> private라서 안보인다. name, id, pwd, age 등등... nation만 보인다.
    //The field Member02.name is not visible

    //매개변수가 있는 생성자를 이용하여 필드값을 setting가능
    Member02 member2 = new Member02("대한민국", "홍길동", "hid", "h123", 20);

// System.out.println(Member02.nation);
// System.out.println(member2.name); //변수에 직접적으로 접근이 안된다. 변수에 따로 담아 선언해도 마찬가지... 이럴때는 메소드로 선언해서 메소드를 호출해야한다.
//The field Member02.name is not visible
//데이터보호를 목적 접근제한 -> 캡슐화
System.out.println("--------------------------------------------------------------------------");

}

}

package other;

/*접근제한자

  • public : 아무나 다 돼---> 접근을 안 막을게
  • protected : 동일패키지이거나, 다른패키지일때는 상속된 필드내에 선언된 자식클래스이면 가능. 
             --->동일 패키지 일때는 상속클래스필드 외부참조변수 선언으로 접근도 가능하면서 상속필드내에서 접근 가능. 
          --->다른 패키지 일때는 상속클래스필드 외부 참조변수 선언으로 접근 불가, 상속필드 내에서만 접근가능.
  • default : 동일패키지내에서만 접근허용
  • private : 동일클래스 내에서만 접근 허용
  • /
    public class AccessModifier {
    //필드
    //접근제한자 [제어자] 데이터타입 필드명[=값];
    public int pub = 100;
    protected int pro = 200; 
              int pack = 300;//default 라는건 default를 적으라는게 아니라 아무것도 적지 말라는 의미.
    private int pri = 400; //동일 클래스 안에서만 사용 가능
void test() {
    pub=110; // 그냥 다 되는 것.
    pro=220; // 상속관계. 그냥 같은 클래스 안에 있으면 당연히 된다.
    pack=330; // --->default 이기 때문에 동일 패키지 내에 접근 및 변경 가능.
    pri=444; //--->동일클래스 안에 있으니 접근해서 데이터 변경까지 가능.
}

}

package other;

public class AccessModifier2 {

public static void main(String[] args) {

    AccessModifier am = new AccessModifier();
    am.pub=110;
    am.pro=220;
    am.pack=330;
    //am.pri=440; X 
    //The field AccessModifier.pri is not visible //클래스가 다르므로 안됨.


}

}

package ch06;

import other.AccessModifier;

public class AccessModifier3 {

public static void main(String[] args) {

    AccessModifier am = new AccessModifier(); //AccessModifier는 동일한 ch06패키지가 아닌 other 패키지에 있어서 외부 패키지 import 해줘야한다.
    am.pub=110; //pub는 퍼블릭이라 접근 가능
    //am.pro=220; //protected는 상속관계만 접근가능인데.. 패키지가 달라버리니... 접근 안된다.
    //The field AccessModifier.pri is not visible
    //am.pack=330;//default도 마찬가지로 동일패키지 내에서만 접근가능인데 달라서 접근이 안된다.
    //The field AccessModifier.pri is not visible
    //am.pri=440; X --->>당연히 안된다.
    //The field AccessModifier.pri is not visible //클래스가 다르므로 안된다.


}

}

package other;

//AccessModifier는 부모클래스(=상위클래스=super클래스) --->더 위에는 조상클래스
//AccessModifier4_1는 자식클래스(=하위클래스) ---> 더 밑에는 자손클래스
//AccessModifier4_1는 AccessModifier의 자식클래스이다.
//[접근제한자] class 자식클래스명 extends 부모클래스명
public class AccessModifier4_1 extends AccessModifier{ //자식클래스 입장에서 부모클래스를 지칭하면 된다.

//필드
//눈에 보이지는 않지만 부모클래스로부터 상속받은 필드가 존재
//-->>한마디로 필드값까지 상속 받는다. pub, pro, pack, pri
String name="홍길동";
//AccessModifier4에서  자체적으로 만들어준 필드.

//부모클래스로부터 상속받은 필드가 존재
//pub, pro, pack, pri 


//생성자
//메소드
void test() {
    name="김길동";
    pub=111;   //선언하지 않아도 적용되는걸 보면 상속받은 필드데이터이다.
    pro=222;    //부모로부터 상속받은 필드 내에서 작성된 것이라 가능// 필드데이터도 상속 되기때...

// pack=333;
// pri=440;
}

public static void main(String[] args) {

    AccessModifier am = new AccessModifier(); 
    am.pub=110; //pub는 퍼블릭이라 접근 가능

    am.pro=220; //동일패키지이면서 상속관계 일때 된다. (상속이 없어도 동일패키지라서 되는듯...)동일패키지면 참조변수를 통해서도 접근가능

    am.pack=330;//상속관계가 없어도 동일 패키지이기 때문에 가능

    //am.pri=440; X --->>당연히 안된다. 동일클래스가 아니므로 접근불가
    //The field AccessModifier.pri is not visible //클래스가 다르므로 안된다.


}

}

package ch06;

import other.AccessModifier;

//AccessModifier는 부모클래스(=상위클래스=super클래스) --->더 위에는 조상클래스
//AccessModifier4_1는 자식클래스(=하위클래스) ---> 더 밑에는 자손클래스
//AccessModifier4_1는 AccessModifier의 자식클래스이다.
//[접근제한자] class 자식클래스명 extends 부모클래스명
public class AccessModifier4_2 extends AccessModifier{ //자식클래스 입장에서 부모클래스를 지칭하면 된다.
//필드
//눈에 보이지는 않지만 부모클래스로부터 상속받은 필드가 존재
//-->>한마디로 필드값까지 상속 받는다. pub, pro, pack, pri
String name="홍길동";
//AccessModifier4에서 자체적으로 만들어준 필드.

//부모클래스로부터 상속받은 필드가 존재
//pub, pro, pack, pri 


//생성자
//메소드
void test() {
    name="김길동";
    pub=111;       //선언하지 않아도 적용되는걸 보면 상속받은 필드데이터이다.
    pro=222;    //다른 패키지에 소속되었지만 //부모로부터 상속받은 필드 내에서 작성된 것이라 가능//

// pack=333;
// pri=440;
}

public static void main(String[] args) {

    AccessModifier am = new AccessModifier(); 
    am.pub=110; //pub는 퍼블릭이라 접근 가능

    //am.pro=220; //동일패키지가 아닌 상속관계 접근불가 --->>부모로부터 불려받지 않은 클래스에서 선언된 것이라 접근 안됨... 한마디로 동일 클래스 아니라서 안된다는것.

    //am.pack=330;//동일 패키지가 아니므로 안된다.

    //am.pri=440; X --->>동일클래스가 아니므로 접근불가
    //The field AccessModifier.pri is not visible //클래스가 다르므로 안된다.


}

}

package ch06;

public class Student01 {

private int sno; 
private String major; 
private int grade; 
private String sname; 
private char gender;


Student01(){

}

Student01(int sno, String major, int grade, String sname, char gender){ //생성자 오버로딩
    this.sno = sno;
    this.major = major;
    this.grade = grade;
    this.sname = sname;
    this.gender = gender;
}

public void setSno(int sno) {
    this.sno=sno;
}
public void setMajor(String major) {
    this.major=major;
}
public void setGrade(int grade) {
    this.grade=grade;
}
public void setSname(String sname) {
    this.sname=sname;
}
public void setGender(char gender) {
    this.gender=gender;
}




public int getSno() {
    return sno;
}

public String getMajor() {
    return major; 
}

public int getGrade() {
    return grade; 
}

public String getSname() {
    return sname; 
}

public char getGender() {
    return gender;
}

void getInfo(){ 
    System.out.println("학번 : "+ this.sno);
    System.out.println("전공: "+ this.major);
    System.out.println("학년 : "+ this.grade);
    System.out.println("이름 : "+ this.sname);
    System.out.println("성별 : "+ this.gender);
    System.out.println();

}

}

package ch06;

public class Student01_Main {

//field

//constructor

//method

public static void main(String[] args) {
    //참조변수선언 및 Member02클래스 객체 생성

    Student01 st1 = new Student01();//기본생성자를 호출




    st1.setSno(220001);


    //학번 확인
    int sno1 = st1.getSno();//
    System.out.println("학번 : "+sno1);

    st1.setMajor("경영");
    //전공 확인
    String mj1 = st1.getMajor();
    System.out.println("전공 : "+mj1);

    st1.setGrade(1);

    //학년 확인        
    int gr1 = st1.getGrade();
    System.out.println("학년 : "+gr1);
    //System.out.println(member2.getPwd()); 

    st1.setSname("최경영");

    //이름 확인
    String sn1 = st1.getSname();
    System.out.println("이름 : "+sn1);
    //System.out.println(member2.getAge()); 

    st1.setGender('남');

    //성별 확인
    char gd1 = st1.getGender();
    System.out.println("성별 : "+gd1);
    //System.out.println(member2.getAge()); 


    System.out.println("--------------------------------------------------------------------------");
    Student01 st2 = new Student01(220002, "컴공", 2, "강컴공", '여');//기본생성자를 호출

    st2.getInfo(); //getInfo 메소드로 만들어서 한번에 출력

    System.out.println("--------------------------------------------------------------------------");

    Student01 st3 = new Student01(220003, "국어국문", 3, "세종대왕", '남');//기본생성자를 호출

    st3.getInfo(); //getInfo 메소드로 만들어서 한번에 출력

    System.out.println("--------------------------------------------------------------------------");






}

}

저작자표시

'java' 카테고리의 다른 글

22.11.10 접근제한자, 상속, 다형성(Polymorphism), Override  (0) 2023.02.13
22.11.09 상속, 생성자, final, super(), Override, Overload  (0) 2023.02.13
22.11.07 클래스 인스턴스화 및 생성자  (0) 2023.02.13
22.11.03 클래스 인스턴스화 심화  (0) 2023.02.12
22.11.02 다차원 배열, 클래스 객체화를 위한 설계  (0) 2023.02.12

관련글

티스토리툴바