06_OOP
- 객체 : 키보드, 나, 모래한알
-> 독립적으로 각각 구분해서 인식할 수 있는 모든 것
-> 독립적으로 각각 구분해서 인식할 수 있도록 프로그래밍하는 것을 목표로 한다.
1. 캡슐화 : 외부로부터의 보호, 정보은닉
2. 상속 : 공통된 것 재사용
3. 다형성 : 다양한 형태를 지니는 성질
4. 추상화 : 공통된 코드만 작성, 개별적인 것은 모두 제거
- 상속의 장점
- 코드 길이 감소
- 코드의 재사용성 증가
매우중요한 것~!
객체 지향 언어 정의 -> 면접에서 많이 물어봄
ex) 객체가 사람이라면? - 속성 : 변수(이름, 나이, 키 ...) = 명사
- 기능 : 메서드(밥을 먹는다, 출근한다 ...) = 동사
ex) 객체가 모니터라면? (= Class) - 속성 : 변수(크기, 화소, 버튼 ...) = 명사
- 기능 : 메서드(화면을 보여준다, 밝기를 조절한다, 화면을 끈다 ...) = 동사
위 사진에서 객체의 특성? '변수 + 메서드'를 의미
[ 메모리 구조 ]
package edu.kh.oop.abstraction.model.vo;
//VO(Value Object) : 값 저장용 객체를 만들기 위한 클래스를 모아두는 패키지
public class People { // 국민(사람) 클래스
// 클래스란 ? 객체의 특성(속성, 기능)을 정의한 것
// == 객체를 만들기 위한 설계도
// 캡슐화
// - 데이터와 기능을 하나로 묶어서 관리하는 기법
// - 데이터의 직접적인 접근을 제한 하는것이 원칙이다.
// -> 직접접근을 못하기 때문에
// 클래스 내부에 간접 접근 방법을 제공하는 기능을 작성해둔다
// 속성 == 값 == data
// 값을 저장하기 위한 변수 선언
// -> 국민이라면 공통적으로 가지고 있는 속성만 작성(추상화)
// 이름, 성별, 주민번호, 주소, 전화번호, 나이
// 필드 == 필드변수 == 멤버 변수 == 클래스 변수
private String name; // The field People.name is not visible
private char gender;
private String pNo; // "220303-3456789"
private String address;
private String phone;
private int age;
//public double bitCoin; // 공통점이 아니므로 제거
// *** 데이터 직접 접근 제한 ***
// public(공공의) -> private(사적인, 개인적인) 변경
// 기능 == 행동 == method
public void tax() {
System.out.println("세금을 냅니다.");
}
public void vote() {
System.out.println("투표를 합니다. 꼭하세요!");
}
// 캡슐화에서 사용할 간접 접근 기능(getter/setter)
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
public String getpNo() {
return pNo;
}
public void setpNo(String pNo) {
this.pNo = pNo;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
// alt + shift + s 또는 상단 메뉴 Source 클릭
// -> Generate Getters and Setters... 클릭
// -> selectAll -> generate
}package edu.kh.oop.abstraction.model.service;
import edu.kh.oop.abstraction.model.vo.People;
// Service : 특정 기능(비즈니스 로직)을 제공하는 클래스
public class AbstractionService {
public void ex1() {
// 국민 객체 만들기
People p1 = new People();
// People p1 : People 객체의 주소를 저장하여 참조하는 변수 p1
// new People() : 새로운 People 객체를 Heap영역에 생성
// ** 클래스 이름이 자료형처럼 사용된다
// == 그래서 클래스를 "사용자 정의 자료형"이라고도 한다!! **
//p1.name = "홍길동";
p1.setName("홍길동");
//p1.age = 25;
p1.setAge(25);
//p1.gender = '남';
p1.setGender('남');
//p1.phone = "010-1234-1234";
p1.setPhone("010-1234-1234");
//p1.pNo = "200303-1234567";
p1.setpNo("200303-1234567");
//p1.address = "서울시 중구 남대문로 120 대일빌딩 3층 E강의장";
p1.setAddress("서울시 중구 남대문로 120 대일빌딩 3층 E강의장");
System.out.println("p1의 name : " + p1.getName());
System.out.println("p1의 age : " + p1.getAge());
System.out.println("p1의 gender : " + p1.getGender());
System.out.println("p1의 phone : " + p1.getPhone());
System.out.println("p1의 pNo : " + p1.getpNo());
System.out.println("p1의 address : " + p1.getAddress());
System.out.println("========================================");
People p2 = new People();
p2.setName("이유진");
p2.setAge(7);
p2.setGender('여');
p2.setPhone("010-1234-1234");
p2.setpNo("220101-2222222");
p2.setAddress("서울시 중구 남대문로 120 대일빌딩 3층 E강의장");
System.out.println("p2의 name : " + p2.getName());
System.out.println("p2의 age : " + p2.getAge());
System.out.println("p2의 gender : " + p2.getGender());
System.out.println("p2의 phone : " + p2.getPhone());
System.out.println("p2의 pNo : " + p2.getpNo());
System.out.println("p2의 address : " + p2.getAddress());
}
}package edu.kh.oop.abstraction.run;
import edu.kh.oop.abstraction.model.service.AbstractionService;
public class AbstractionRun {
public static void main(String[] args) {
AbstractionService as = new AbstractionService();
as.ex1();
}
}
06_OOP
- [] = 생략이 가능함을 의미
- 속성값 설정 = 필드
- 기능정의 설정 = 메서드(getter/setter)
- 필드
- 생성자
- 기능
(+) public : 누구나 쓸 수 있음, 어디서든지 import 가능
(~) default : 외부패키지에서 사용못함(접근금지) ( ~ : 틸드(tilde)를 의미)06_OOP
★ 상단 사진은 암기하기!
- private : '원칙'!
package edu.kh.oop.cls.model.vo;
public class Student { // 클래스 선언부
// [접근제한자] [예약어] class 클래스명
// 접근제한자 public : 같은 프로젝트 내에서
// 어떤 클래스에서든 import 할 수 있음을 나타냄.
// 1. 필드(field) : 객체의 속성을 작성하는 클래스 내부 영역
// == 멤버 변수 : 메서드 밖에 작성된 변수
// 인스턴스 변수 : 필드에 작성되는 일반 변수
// ex) private int age;
// 클래스 변수( == static 변수 ) : 필드에 static 예약어가 작성된 변수
/* 필드 구성 (대괄호는 생략가능)
* [접근제한자] [예약어] 자료형 변수명 [=초기값;]
* + public final 기본자료형
* # protected static (참조형)
* ~ (default) final static 배열
* - private static final 클래스명
*
*
* 필드의 접근 제한자의 뜻 : 직접 접근 가능한 범위를 나타냄.
*/
public int v1 = 10;
protected int v2 = 20;
int v3 = 30;
private int v4 = 40;
// 접근 제한자 예제
public void ex() {
System.out.println( v1 );
System.out.println( v2 );
System.out.println( v3 );
System.out.println( v4 );
}
// ---------------------------------------------
public static String schoolName = "KH고등학교";
private String name; // 캡슐화 원칙 -> 간접 접근 방법 필요
{// 초기화 블록 : 객체 생성 시 필드 값 초기화
name = "김길동";
}
// getter/setter
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
// ---------------------------------------------------------------
// 2. 생성자(constructor)
/* - new 연산자를 통해서 객체를 생성할 때
* 생성된 객체의 필드 값 초기화 + 지정된 기능을 수행하는 역할
*
* - 생성자 작성 규칙
* 1) 생성자의 이름은 반드시 클래스명과 같아야 한다.
* 2) 반환형이 존재하지 않는다.
*
* - 생성자 종류
* 1) 기본 생성자
* 2) 매개변수 생성자
*
*
*/
// 기본 생성자
// [접근제한자] 클래스명() { 코드 }
public Student() {
// 객체가 생성될 때 수행할 코드
System.out.println("기본 생성자에 의해서 Student 객체가 생성됨");
}
// 3. 메서드(method)
}package edu.kh.oop.cls.model.vo;
class TestVO {
// 접근제한자 (default) : 같은 패키지내에서만 import가 가능함을 나타냄.
// Student와 같은 패키지에 있기 때문에
// -> public, protected, (default) 3개는 접근 가능
public void ex() {
Student std = new Student();
System.out.println( std.v1 );
System.out.println( std.v2 );
System.out.println( std.v3 );
//System.out.println( std.v4 );
// v4는 private이기 때문에 같은 패키지라도
// 다른 클래스에서 직접 접근 불가
}
}package edu.kh.oop.cls.model.service;
import edu.kh.oop.cls.model.vo.Student;
import edu.kh.oop.cls.model.vo.User;
//import edu.kh.oop.cls.model.vo.TestVO;
// The type edu.kh.oop.cls.model.vo.TestVO is not visible
public class ClsService /*extends Student*/{
// 부모 Student를 상속받음
public void ex1() {
// 클래스 접근 제한자 확인하기
Student std = new Student();
// public class인 Student는 import 가능
//TestVo test = new TestVo();
// (default) class인 TestVO는 import 불가(다른패키지)
System.out.println( std.v1 );
// 다른 패키지에서도 접근 가능한 public 만 에러 X
// System.out.println( std.v2 );
// System.out.println( std.v3 );
// System.out.println( std.v4 );
// 상속 관계에서 직접 접근 가능 범위
// System.out.println( v1 ); // public
// System.out.println( v2 ); // protected
// System.out.println( v3 ); // default
// System.out.println( v4 ); // private
}
public void ex2() {
// static 필드 확인 예제
// 학생 객체 2개 생성
Student std1 = new Student();
Student std2 = new Student();
// 학생 객체에 name 세팅
std1.setName("홍길동");
std2.setName("김영희");
// 정보 출력
System.out.println(std1.schoolName); // public 이기 때문에 직접 접근 가능 // KH고등학교
// schoolName에 노란줄이 뜨는 이유 -> 제대로 작성을 안해서
// *** static이 붙은 필드(변수)는 '클래스명.변수명' 으로 사용함 ***
System.out.println(Student.schoolName); // KH고등학교
Student.schoolName = "KH";
System.out.println("변경후 : " + Student.schoolName); // 변경후 : KH
/* static
*
* 1) 공유 메모리 영역(또는 정적 메모리 영역) 이라고 함.
*
* why? 프로그램 시작 시 static이 붙은 코드들이 모두
* static 영역에 생성되고,
* 프로그램이 종료될 때 까지 사라지지 않음 (정적)
* 그리고, static 영역에 생성된 변수는 어디서든지 공유 가능(공유)
*
* 2) 사용 방법 : 클래스명.변수명
*
*/
}
public void ex3() {
// 생성자 확인 테스트
// Student 객체를 기본 생성자를 이용해 생성하고 이를 참조하는 참조변수 s1에 대입
Student s1 = new Student(); // 기본 생성자에 의해서 Student 객체가 생성됨
// 기본 생성자
// User 기본 생성자를 이용해서 객체 생성
User u1 = new User(); // 기본 생성자로 User 객체 생성
// User 객체 필드 초기화 확인
System.out.println( u1.getUserId() ); // user01
System.out.println( u1.getUserPw() ); // pass01
System.out.println( u1.getUserName() ); // 홍길동
System.out.println( u1.getUserAge() ); // 20
System.out.println( u1.getUserGender() ); // 남
}
}package edu.kh.oop.cls.run;
import edu.kh.oop.cls.model.service.ClsService;
public class ClsRun {
public static void main(String[] args) {
ClsService service = new ClsService();
// 매개변수 아무것도 없는 생성자는 기본 생성자라고 한다.
// ClsService의 기본 생성자가 작성되어 있지 않지만
// 문제 없이 사용 가능하다.
// 왜??
// 컴파일러가 코드를 번역할 때
// 클래스 내부에 생성자가 하나도 없다면
// 자동으로 기본 생성자를 추가해줌(우리 눈엔 안보임)
//service.ex2();
service.ex3();
}
}package edu.kh.oop.cls.model.vo;
public class User {
// 속성 ( == 필드 )
// 아이디, 비밀번호, 이름, 나이, 성별 ( 추상화 진행 )
// 데이터 직접접근 불가원칙 -> 필드는 기본적으로 모두 private ( 캡슐화 진행 )
private String userId;
private String userPw;
private String userName;
private int userAge;
private char userGender;
// 기능 ( == 생성자 + 메서드 )
// 생성자 : new 연산자를 통해서 객체가 생성될 때
// 생성된 객체의 필드값 초기화 + 기능 수행 역할.
// 기본생성자
public User() {
// 기능
System.out.println("기본 생성자로 User 객체 생성");
// 필드 초기화
userId = "user01";
userPw = "pass01";
userName = "홍길동";
userAge = 20;
userGender = '남';
// 기본 생성자를 이용해서 User객체를 만들면
// 그 객체는 프린터 구문을 수행하고,
// 필드 초기화구문을 거쳐서 홍길동 하나가 만들어짐
}
// 캡슐화로 인한 간접 접근 기능 (getter/setter)
public String getUserId() {
return userId;
}
public void setUserId(String userId) {
this.userId = userId;
}
public String getUserPw() {
return userPw;
}
public void setUserPw(String userPw) {
this.userPw = userPw;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public int getUserAge() {
return userAge;
}
public void setUserAge(int userAge) {
this.userAge = userAge;
}
public char getUserGender() {
return userGender;
}
public void setUserGender(char userGender) {
this.userGender = userGender;
}
}06_OOP
