문법/기본 문법
객체지향 심화(0119)
코딩 화이팅
2023. 1. 19. 17:50
패키지
- PC의 많은 파일을 관리하기 위해서 폴더를 이용한다.
- 프로그램의 많은 클래스를 관리하기 위해서 패키지를 이용한다.
- 클래스와 관련 있는 인터페이스들을 모아두기 위한 이름 공간
- 패키지의 이름은 시중에 나와 있는 패키지들과 구분되게 지어야 한다.
- 패키지의 구분은 .(dot) 연산자를 이용한다.
com.ssafy.project_이름.module_이름 - 패키지 사용 이유 : 정리하기 위해서 / 패키지 단위로 접근 제어 가능 / 클래스를 구별할 수 있다.
임포트
- 다른 패키지에 있는 클래스를 사용하기 위해서는 import 과정이 필요하다.
- import 선언할 때는 import 키워드 뒤에 package 이름과 클래스 이름을 모두 입력하거나, 해당 패키지의 모든 클래스를 포함할 때는 '*'를 사용하기도 한다.
import package_name.class_name;
package pkg1;//패키지 선언문: 이 클래스가 어떤 패키지에 속하는지?
//항상 클래스는 하나의 패키지 안에 포함이 되어야 함
public class person {
public String pkg="pkg1";
}
==========================================================================
package pkg1.pkg2;
public class person {
public String pkg="pkg1.pkg2";
}
==========================================================================
package pkg1.pkg2.pkg3;
public class person {
public String pkg="pkg1.pkg2.pkg3";
}
==========================================================================
package pkg1;
import pkg1.pkg2.pkg3.person;
//패키지 명을 생략하고 쓰겠다.
public class pkgTest {
public static void main(String[] args) {
//서로 다른 패키지에 있는 클래스 중에서
//하나를 골라서 쓸 때만 이렇게 쓸 수 있다.
// person p1=new person();
// System.out.println(p1.pkg);
//만약에 서로 다른 패키지에 있는 이름이 같은 클래스를
//두 개 이상 사용하고 싶다면->패키지를 생략할 수 없고
//패키지명.클래스명->풀패키지이름
pkg1.person p1=new pkg1.person();
pkg1.pkg2.person p2=new pkg1.pkg2.person();
pkg1.pkg2.pkg3.person p3=new pkg1.pkg2.pkg3.person();
person p4=new person();
System.out.println(p1.pkg);
System.out.println(p2.pkg);
System.out.println(p3.pkg);
System.out.println(p4.pkg);
}
}
==========================================================================
package test01;
//import java.util.Arrays;
//import java.util.Date;
//import java.util.Scanner;
import java.util.*;
import java.util.logging.*;
//하위패키지에 있는 클래스까지 임포트되는 것은 아니다.
//하위패키지라고 해도 엄연히 다른 패키지이다.
public class test01_1 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
Date d=new Date();
int [] arr= {1,2,3,4,5};
Arrays.toString(arr);
// java.util.logging.Logger
Logger l=Logger.getGlobal();
}
}접근 제한자
- 클래스, 멤버 변수, 멤버 메서드 등의 선언부에서 접근 허용 범위를 지정하는 역할의 키워드이다.
- 접근 제한자의 종류
public: 모두 공개
protected
(default) : 접근 제한자를 생략하면 default
private: 나만 - 그 외 제한자
static : 클래스 레벨의 요소 설정
final
abstract
public
모든 위치에서 접근이 가능
package test07_public;
//class는 public 아니면 default
public class person {
public String name;
public int age;
//어디서든 접근 가능
public static void main(String[] args) {
person p1=new person();
//자기 자신이므로 접근 가능
p1.name="강현";
}
}package test07_public;
public class personTest {
public static void main(String[] args) {
person p1=new person();
//다른 클래스에 있지만 같은 패키지 이므로 public 속성에 접근 가능
p1.
}
}package test07_public2;
import test07_public.person;
public class personTest {
public static void main(String[] args) {
person p1=new person();
//다른 패키지에 있지만 public 속성에 접근 가능
p1.
}
}protected
같은 패키지에서 접근이 가능, 다른 패키지 접근 불가능. 단, 다른 패키지의 클래스와 상속관계가 있을 경우 접근 가능
package test05;
//class는 public 아니면 default
public class person {
protected String name;
protected int age;
//다른 패키지에서는 안되지만 다른 패키지에 있더라도 상속을 받은 클라스라면 접근 가능
public static void main(String[] args) {
person p1=new person();
//자기 자신이므로 접근 가능
p1.name="강현";
}
}package test05;
public class personTest {
public static void main(String[] args) {
person p1=new person();
//다른 클래스에 있지만 같은 패키지 이므로 protected 속성에 접근 가능
p1.
}
}package test06;
import test05.person;
public class personTest {
public static void main(String[] args) {
person p1=new person();
//다른 패키지에 있으므로 protected 속성에 접근 불가
p1.
}
}package test06;
import test05.person;
public class student extends person {
public static void main(String[] args) {//extends 상속 메소스
student s1=new student();//상속을 받았으므로 다른 패키지에 있더라도 protected속성에 접근 가능
s1.
}
}default
같은 패키지에서만 접근이 허용 / 접근 제한자가 선언이 안 되었을 경우 기본 적용
package test03;
//class는 public 아니면 default
public class person {
String name;//접근 제한자를 생략하면 (default)
int age;//멤버 변수
public static void main(String[] args) {
person p1=new person();
//자기 자신이므로 접근 가능
p1.
}
}package test03;
public class personTest {
public static void main(String[] args) {
person p1=new person();
//다른 클래스에 있지만 같은 패키지 이므로 default 속성에 접근 가능
p1.
}
}package test04;
import test03.person;
public class personTest {
public static void main(String[] args) {
person p1=new person();
//다른 패키지에 있으면 default 속성에 접근 불가
p1.
}
}private
자신 클래스에서만 접근이 허용
클래스 사용 가능 : public, default
package test02;
//class는 public 아니면 default
public class person {
private String name;//멤버변수
private int age;//멤버 변수
//private 접근 제한자는 같은 클래스 내에서만 접근이 가능
public static void main(String[] args) {
person p1=new person();
//자기 자신이므로 접근 가능
p1.name="강현";
}
}package test02;
public class personTest {
public static void main(String[] args) {
person p1=new person();
p1.
// private 접근 제한자는 다른 클래스에 있으므로 접근 불가
}
}| 수식어 | 클래스 내부 | 동일 패키지 | (다른 패키지내의) 하위 클래스 |
다른 패키지 |
| private | o | |||
| (default) | o | o | ||
| protected | o | o | (상속한다면 가능) | |
| public | o | o | o | o |
접근자/설정자
- 클래스에서 선언된 변수 중 접근제한에 의해 접근할 수 없는 변수의 경우 다른 클래스에서 접근할 수 없기 때문에, 접근하기 위한 메서드(설정자와 접근자)를 public으로 선언하여 사용
싱글턴 패턴
객체를 단 하나만 만들 때
JVM 메모리 구조
- Java 언어는 메모리 관리를 개발자가 하지 않음.
- GC(Garbage Collection)가 메모리 관리
Garbage Collection : Heap 영역(class 영역 포함)에 생성된 메모리 관리 담당 /
더 이상 사용되지 않는 객체들을 점검하여 제거
자동적 실행 / CPU가 한가 or 메모리 부족
JVM에 의해서 실행
System.gc()를 통해 호출(시스템 영향을 줘서 하지 않기)
package test08_getSetter;
public class person {
//접근자와 설정자 만들기
//먼저 멤버 변수를 private으로 선언
private String name;
private int age;
private boolean hungry;
//위 멤버변수에 접근할 수 있는 통로를
//public한 메서드로 만들어줌
//값을 변경->설정자(setter) : set+멤버변수 이름
//값을 조회->접근자(getter) : get+멤버변수 이름
//마우스 우클릭 ->Source->generate getters and setters
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age<0) {
System.out.println("나이가 음수는 될 수 없다.");
return;
}
if (age>200) {
System.out.println("오래 살수는 없다.");
return;
}
this.age = age;
}
public boolean isHungry() {
return hungry;
}
public void setHungry(boolean hungry) {
this.hungry = hungry;
}
}package test08_getSetter;
public class personTest {
public static void main(String[] args) {
person p1=new person();
//p1.age=30;하는 거랑 차이 : set이라는 함수안에 로직을 통해 필터링 과정을 거쳐 출력되어질 수 있다.
p1.setName("강현");//public 메서드라서 접근 가능
// p1.setAge(26);
p1.setAge(300);//setter를 이용해서 멤버변수의 값을 수정 가능
System.out.println(p1.getAge());
System.out.println(p1.getName());
}
}package test09_singleturn;
public class person {
//싱글턴으로 바꾸기
//1. private으로 자기 자신 만들기
// 객체를 생성하지 않고, 클래스 이름으로 생성하기 위해서
private static person instance=new person();
// 2. 생성자를 막기
private person() {
this.name="유일한 사람";
this.age=123;
}
//유일한 객체에 접근할 수 있는 통로 만들기
public static person getInstance() {
return instance;
}
//접근자와 설정자 만들기
//먼저 멤버 변수를 private으로 선언
private String name;
private int age;
private boolean hungry;
//위 멤버변수에 접근할 수 있는 통로를
//public한 메서드로 만들어줌
//값을 변경->설정자(setter) : set+멤버변수 이름
//값을 조회->접근자(getter) : get+멤버변수 이름
//마우스 우클릭 ->Source->generate getters and setters
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age<0) {
System.out.println("나이가 음수는 될 수 없다.");
return;
}
if (age>200) {
System.out.println("오래 살수는 없다.");
return;
}
this.age = age;
}
public boolean isHungry() {
return hungry;
}
public void setHungry(boolean hungry) {
this.hungry = hungry;
}
}package test09_singleturn;
public class personTest {
public static void main(String[] args) {
// person p1=new person();//싱글턴에서는 추가로 객체 추가 X
person p1=person.getInstance();
System.out.println(p1.getName());
System.out.println(p1.getAge());
person p2=person.getInstance();
System.out.println(p1.getName());
System.out.println(p1.getAge());
}
}영화관리
public class class1 {
private int id;
private String title;
private String director;
private String genre;
private int runningTime;
//마우스 우클릭->source->generate constructor using field
public class1() {
}
public class1(int id, String title, String director, String genre, int runningTime) {
this.id = id;
this.title = title;
this.director = director;
this.genre = genre;
this.runningTime = runningTime;
}
//접근자와 설정자
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getDirector() {
return director;
}
public void setDirector(String director) {
this.director = director;
}
public String getGenre() {
return genre;
}
public void setGenre(String genre) {
this.genre = genre;
}
public int getRunningTime() {
return runningTime;
}
public void setRunningTime(int runningTime) {
this.runningTime = runningTime;
}
@Override
public String toString() {
return "class1 [id=" + id + ", title=" + title + ", director=" + director + ", genre=" + genre
+ ", runningTime=" + runningTime + "]";
}
}public class movieManager {
private final int MAX_SIZE=100;
private class1[] movielist=new class1[100];
//싱글턴
//1. private으로 자기 자신의 인스턴스 만들기
//2. 생성자를 private으로 막기
//3. 유일한 인스턴스에 접근 가능한 getter 만들기
private static movieManager instance = new movieManager();
private movieManager () {
}
public movieManager getInstance() {
return instance;
}
}