자바의 data 관리
-
자바에서 사용되는 3가지 변수에 관한 내용
-
1) 변수 (variable)
- 하나의 값 저장
- 종류:
- 로컬 변수
- 인스턴스 변수
- 클래스 변수 (static 변수)
- 변수 선언
- 변수 초기화
배열, 컬렉션 ==> 참조형 변수
- 2) 배열 (array)
- 여러 개 값 저장 (동일한 자료형)
- 크기 변경 x (삭제, 추가, 삽입 불가)
- 종류
- 1차원 배열
- 2차원 배열
- 배열 선언
- 배열 생성
- 배열 초기화
- 3) 컬렉션(Collection Api)
- 여러 개 값 저장 (자료형의 제약 없음)
- 크기 변경 가능 (삭제, 추가, 삽입 가능)
- 종류
- List 계열: 순서 존재 => 중복 가능
- Set 계열 : 순서 없음 => 중복 불가
- Map 계열 : 값, 이름(key) 쌍으로 저장
cf. Lis, Set은 값을 저장
배열
- 1) 1차원 배열
- 가) 배열 선언
int [ ] n;
String [ ] s;=> stack 할당
- 나) 배열 생성
n = new int [3]; (int형 -> 0으로 자동초기화)
s = new String[2]; (참조형 -> null로 자동 초기화)=> heap 할당 , 자동 초기화
- 다) 배열 초기화
- 가) 배열 선언
- 리터럴을 사용한 배열 선언 및 초기화
int n [] = {1,2,3}; - new, 리터럴을 사용한 배열 생성 및 초기화
int n [] ;
n = new int[] {1,2,3};
package array.test;
public class Ex05_4 {
public static void main(String[] args) {
// new
int [] num;
num = new int[4];
num[0] = 1;
num[1] = 2;
num[2] = 3;
// literal
int [] num = {1,2,3,4};
/*int [] num;
* num = {1,2,3};
*/
for(int x :num) {
System.out.println("정수 배열 값: "+x);
}
// new, literal 사용
int [] num;
num = new int[] {1,2,3};
for(int x : num) {
System.out.println(" 정수 배열 값: "+x);
}
}2차원 배열
- 1) new 이용
-
가) 배열 선언
int [][] n;
String [][] s;
대괄호의 갯수가 차원을 결정 -
나) 배열 생성 (1):
정방형-
모든 열의 크기가 동일
n = new int [3][2];
-
행의 길이 구하기: n.length
-
열의 길이 구하기: n[0].length
-
-
다) 배열 생성 (2):
비정방형(행의 열 크기가 다름)-
행의 크기만 지정해주고, 열의 크기는 동적으로 할당하는 방식
n = new int [3][ ];
=> 열 크기 지정 x
-
라) 배열 생성 : 열 생성
n[0] = new int [2] ;
=>0행에 2열을 삽입
n[1] = new int [1];
=>1행에 1열을 삽입
n[2] = new int [3];
=>2행에 3열을 삽입
-
-
2차원 배열 메모리 구조
int[][] scores = {{1, 2}, {3, 4, 5}};
new 이용한 2차원 배열 생성
- 1) 배열 선언 및 행 생성
- 배열명 num은 참조변수이면서 로컬변수이기 때문에 스택(stack) 메모리에 생성
- 배열 변수 num이 스택 메모리에 생성되며, num이 가리키는 배열 객체는 힙 메모리에 생성됩니다. num 변수가 힙 메모리에 생성된 배열 객체를 참조하고 있으므로, num 변수를 통해 배열 객체에 접근할 수 있습니다.
int [][] num = new int[3][];
-
2) 열 생성
- 각 행의 열을 동적으로 생성할 수 있다. 1행은 3개의 열을 가지고 2행은 2개의 열을 가지며 3행은 1개의 열을 가지게 된다.
- int형이기 때문에 0으로 모두 초기화 된다.
-
3) 초기화
강의 실습
- 정방형
package workshop;
import java.util.Scanner;
public class Test16 {
public static void main(String[] args) {
// 2차원 배열
// 가. new 이용
int [][] n;
String [][] s;
// 나. 배열 생성 ( 정방형 : 모든행의 열 크기가 동일)
n = new int[3][2];
s = new String[3][2];
// 다. int형 배열 초기화 (자동 초기화x)
n[0][0]=1;
n[0][1]=2;
n[1][0]=3;
n[1][1]=4;
n[2][0]=5;
n[2][1]=6;
// 다. String형 배열 초기화 (자동 초기화x)
s[0][0]="A1";
s[0][1]="A2";
s[1][0]="A3";
s[1][1]="A4";
s[2][0]="A5";
s[2][1]="A6";
// for each 문 사용해 초기화
for (int[] arr : n)
{
for (int x : arr)
System.out.println(x);
}
System.out.println();
// for each 문 사용해 초기화
for (String[] arr : s)
{
for (String x : arr)
System.out.println(x);
}
System.out.println();
// 이중 for 문 사용해 초기화 (int형 배열)
for(int i =0; i<n.length;i++) {
for(int j =0;j<n[i].length;j++)
{
System.out.println("n["+i+"]"+"["+j+"]"+"="+n[i][j]);
}
}
System.out.println();
// 이중 for 문 사용해 초기화 (String형 배열)
for(int i =0; i<s.length;i++) {
for(int j =0;j<s[i].length;j++)
{
System.out.println("s["+i+"]"+"["+j+"]"+"="+s[i][j]);
}
}
}
}
-
실행 결과
-
비정방형
-
new
package exam02;
public class ArrayTest8 {
public static void main(String[] args) {
// 2차원 배열
// 가. new 이용
int [][] n;
String [][] s;
// 나. 배열 생성 - 행크기 생성 (비정방형 : 행의 열 크기가 다름)
n = new int [3][];
s = new String [3][];
// 다. 배열 생성 - 열 생성 (서로 다른 크기의 열을 동적으로 생성함)
n[0] = new int[2];
n[1] = new int[2];
n[2] = new int[3];
s[0] = new String[2];
s[1] = new String[2];
s[2] = new String[3];
// 라. 배열 초기화
n[0][0] = 1;
n[0][1] = 2;
n[1][0] = 3;
n[1][1] = 4;
n[2][0] = 5;
n[2][1] = 6;
s[0][0] = "A1";
s[0][1] = "A2";
s[1][0] = "A3";
s[1][1] = "A4";
s[2][0] = "A5";
s[2][1] = "A6";
for (int[] arr : n) {
for (int x : arr) {
System.out.println(x);
}
}
for (int i = 0; i < n.length; i++) {
for (int j = 0; j < n[i].length; j++) {
System.out.printf("n[%d][%d] = %d \n", i, j, n[i][j]);
}
}
}
}- literal
package exam02;
import java.util.Scanner;
public class ArrayTest9 {
public static void main(String[] args) {
// 2차원 배열
// 가. literal 이용
// 선언과 동시에 초기화
int [][] n = {{1,2},{3},{4,5,6}}; // 비정방형 => 열의 크기가 다름
String [][] s = {{"A", "B"}, {"C"},{"D", "E", "F"}};
// 이중 for 문 사용해 초기화 (int형 배열)
for(int i =0; i<n.length;i++) {
for(int j =0;j<n[i].length;j++)
{
System.out.println("n["+i+"]"+"["+j+"]"+"="+n[i][j]);
}
}
System.out.println();
// 이중 for 문 사용해 초기화 (String형 배열)
for(int i =0; i<s.length;i++) {
for(int j =0;j<s[i].length;j++)
{
System.out.println("s["+i+"]"+"["+j+"]"+"="+s[i][j]);
}
}
}
}
- new + literal
package exam02;
public class ArrayTest8 {
public static void main(String[] args) {
// 2차원 배열
// 가. new 이용
int [][] n;
String [][] s;
// 나. 배열 생성 - 행크기 생성 (비정방형 : 행의 열 크기가 다름)
n = new int [3][];
s = new String [3][];
// 다. 배열 생성 - 열 생성 (서로 다른 크기의 열을 동적으로 생성함)
n[0] = new int[2];
n[1] = new int[1];
n[2] = new int[3];
s[0] = new String[2];
s[1] = new String[1];
s[2] = new String[3];
// 라. 배열 초기화
n[0][0] = 1;
n[0][1] = 2;
n[1][0] = 3;
n[2][0] = 4;
n[2][1] = 5;
n[2][1] = 6;
s[0][0] = "A1";
s[0][1] = "A2";
s[1][0] = "A3";
s[2][0] = "A4" ;
s[2][1] = "A5" ;
s[2][2] = "A6" ;
for (int[] arr : n) {
for (int x : arr) {
System.out.println(x);
}
}
for (int i = 0; i < n.length; i++) {
for (int j = 0; j < n[i].length; j++) {
System.out.printf("n[%d][%d] = %d \n", i, j, n[i][j]);
}
}
}
}배열 유틸리티 클래스 활용한 배열 값 출력
http://www.tcpschool.com/java/java_api_arrays
package exam02;
// 배열 사용시 도움을 받을 수 있는 배열 유틸리티 클래스
import java.util.Arrays;
import java.util.List;
public class ArrayTest11 {
public static void main(String[] args) {
// 1. 배열값 출력 (문자열로 출력)
int [] n = {10, 20, 30};
String [] s = {"A", "B", "C"};
System.out.println(Arrays.toString(n));
System.out.println(Arrays.toString(s));
// 2. 값 변경: 모든 배열 값이 변경
String [] s2 = {"A", "B", "C"};
Arrays.fill(s2, "X");
System.out.println(Arrays.toString(s2));
// 3. 값 변경: 일부분 배열값이 변경
String [] s3 = {"A","B","C", "D", "E", "F"};
Arrays.fill(s3, 0,4,"X");
System.out.println(Arrays.toString(s3));
//4. 값 비교
int [] x = {1,2,3};
int [] x2 = {1,2,3};
System.out.println(Arrays.equals(x, x2));
//5. 정렬 (오름차순(기본), 내림차순)
int [] k = {54,2,1,57,9,74};
Arrays.sort(k);
System.out.println(Arrays.toString(k));
//6. 특정값의 위치 :binarySearch()
//이진 검색 알고리즘을 사용하므로, 매개변수로 전달되는 배열이 sort() 메소드 등을 사용하여
// 미리 정렬되어 있어야만 제대로 동작합니다.
int [] k2 = {54,2,1,57,9,74};
for(int i = 1; i < k2.length; i++) {
k2[i] = i;
}
Arrays.sort(k2);
System.out.println(Arrays.binarySearch(k2, 2));
//7. 배열 길이 변경 (배열 복사) ==> 원래 배열을 복사하면서 배열 길이를 늘리는 방식
int [] y = {1,2,3};
int [] y2 = Arrays.copyOf(y, 5);
System.out.println(Arrays.toString(y));
System.out.println(Arrays.toString(y2));
// 8. 개별적인 값들을 컬렉션 API로 생성 ( ******* )
// import 필
// import java.util.List;
List<String> list = Arrays.asList("A", "B", "C");
System.out.println(list); // [A, B, C]
List<Integer> list2 = Arrays.asList(10, 20, 30);
System.out.println(list2); // [10, 20, 30]
}
}
- 실행 결과
리터럴을 이용한 이차원 배열 생성
- 안쪽 블록 갯수가 행 갯수를 의미하고 안쪽 블록내의 값이 각 행의 열을 의미한다.
package array.test;
public class Ex05_5 {
public static void main(String[] args) {
int [][] num = {{1,2},{3,4},{5,6,7}};
for(int i =0; i<num.length;i++)
for(int j =0;j<num[i].length;j++)
{
System.out.println("num["+i+"]"+"["+j+"]"+"="+num[i][j]);
}
}
}
- 실행 결과
new, 리터럴을 이용한 이차원 배열 생성
- 주의 사항
: [][] => 배열 크기를 지정하면 안됨int [][] num = new int[][]{{1,2},{3,4},{5,6,7}};
package array.test;
public class Ex05_5 {
public static void main(String[] args) {
int [][] num = new int[][]{{1,2},{3,4},{5,6,7}};
for(int i =0; i<num.length;i++)
for(int j =0;j<num[i].length;j++)
{
System.out.println("num["+i+"]"+"["+j+"]"+"="+num[i][j]);
}
}
}
- 실행 결과
클래스 (Class)
-
클래스 구성요소 3가지 : 인스턴스 변수(필드), 메서드, 생성자
- 생성자 호출 시 객체 생성 키워드 new 사용 필
- 생성자 생성은 인자 리스트 구분으로 여러 개 생성 가능 (오버로딩 생성자)- 추후 핸들링 클래스의 main() { }내 호출하여 사용 필
- 호출 시 인자리스트의 갯수, 자료형을 맞춰 기재해야 함.
-
-
-
oop(object oriented programming)
- 1) 객체 지향 프로그래밍 (객체를 사용해서 프로그래밍 수행하는 방법론)
- 2) 객체 (object) ?
: 현실 세계에 존재하는 사물, 물건 의미- 예) 모니터 객체, 책상 객체, 학생 객체, 강사 객체
- 예) 모니터 객체, 책상 객체, 학생 객체, 강사 객체
- 3) 객체 구성 요소 (2)
- 3.1) 속성 : 객체를 나타내는 특성(성질)
- 3.2) 동작 : 객체의 기능을 표현
예1.) 모니터 객체 :
속성: 색상, 가격, 크기, 제조사
동작: on/off
예2.) 학생 객체
속성: 학번, 이름, 주소
동작: 공부하기
- 4) 추상화 (모델링)
-
프로그램 개발하기 위해
필요한객체 추출/ 속성 추출/ 동작 추출하는 작업 (필요 없는 것들을 구분해낸다)
- 예) 학생 관리 프로그램을 개발
의뢰=>분석=>설계=>
- 예) 학생 관리 프로그램을 개발
-
1)
분석: 현실 세계의 객체 추출 -
예) 학생 객체, 교수 객체 추출
추출한 객체에서 기능, 속성을 추출
학생 객체=>속성: 학번, 이름, 나이, 주소학생 객체=>동작: 공부,운동
-
2)
설계: 객체를 프로그래밍 언어(가상세계 java)에 맞게끔 설계하는 과정 -
분석 단계에서 추출한 학생이라는 객체가, 설계 단계에서 클래스로 변환됨
즉, 설계 단계에서 학생클래스가 생성됨
분석 단계에서 추출한 객체의속성은변수(=인스턴스 변수, 필드)로 생성됨.
분석 단계에서 추출한 객체의동작은메서드로 생성됨.
-
상속: 상위 클래스의 특성을 하위 클래스가 물려 받음.
-
- 1) 객체 지향 프로그래밍 (객체를 사용해서 프로그래밍 수행하는 방법론)
-
애완동물 관리 프로그램
주문=>분석=>설계
1)
분석- 고양이 객체
- 속성: 이름, 나이, 성별
- 동작: 먹기, 자기, 뛰기
- 강아지 객체
- 속성:
- 동작:
2)
설계- cat 클래스
- 인스턴스 변수: name, age, sex
- 메서드: void eat(),void sleep(), void run()
- cat 클래스는 main 메서드가 없음 => 실행 불가(메모리에 못올라감)
- main() { } 핸들링 클래스 사용 필
- 설계 단계에서 고양이 객체는 Cat 클래스로, 속성은 인스턴스 변수로, 동작은 메서드로 대응됨.
- 생성된 Cat 클래스는 독자적으로 실행되지 못하고, 핸들링 클래스인 TestCat 클래스의 main() { }에 의해서 실행됨 (이 단계에서 객체가 heap 메모리에 올라가게 됨)
- 이때 Cat 클래스(Cat 클래스 내부에 여러 가지 인스턴스 변수가 정의되어 있음)에 의해 생성된 하나의 객체를 인스턴스라고 함
- +) 참조형 변수 vs 기본형 변수
- Cat은 8가지 기본형 자료형에 포함 x => 참조형
- Cat 자료형이클래스 형이므로 (변수 앞에 있는 자료형으로 구분) 참조형 변수에 해당
- Cat은 로컬변수 이므로 Stack 영역에 해당
- 로컬변수는 초기화 필 (초기화 안하면 에러 발생)
- 참조형이면 무조건new로 변수 생성
- 클래스, 객체, 인스턴스 구별
- 물리세계에 존재하는게 객체
- 그걸 추상화하기위해 만든 틀이 클래스
- 클래스를 통해 메모리에 만들어낸 객체가 인스턴스
클래스 구성 요소(1) : 생성자
- 사용 용도: 인스턴스 변수의 초기화
- 인스턴스 변수의 초기값 설정
- 클래스 문법:
public class Cat{
String name; // 인스턴스 변수(멤버 변수) !
// 메서드 (멤버 메서드)
// 생성자
}
// 인스터스 변수와 메서드는 data 저장
// 생성자는 멤버 변수와 멤버 메서드 변경, 조회, 초기화 가능 - 생성자 문법
public 클래스명() {
}
public Cat() {
} // 생성자 - 생성자 특징
- 반드시 호출해야한다.
- 생성자 호출 방법 :
new생성자 호출- 즉, 객체가 생성되며 생성자가 호출됨을 알 수 있다.
- 클래스가 생성할때 호출
- 생성자는 하나만 만들 수 있는 것이 아닙니다. 파라미터를 다르게 하여 여러개의 Car 생성자를 만들 수 있습니다.
- 명시적으로 생성자를 작동안하면 자동으로 생성된다 (기본 생성)
- 예)
package test.mypac;
public class Car {
//필드 정의하기
public Engine engine;
//객체를 new(생성) 할때 호출되는 생성자
public Car() {
System.out.println("Car() 생성자 호출됨");
}
// Engine 객체를 인자로 전달 받는 생성자
public Car(Engine engine) {
//지역변수에 담긴 값을 필드에 저장하기
this.engine = engine;
System.out.println("Car(Engine engine) 생성자 호출됨");
}
//달리는 메소드
public void drive() {
if(this.engine==null) {
System.out.println("Engine 이 없어서 달릴수가 없어요!");
return; //메소드를 여기서 끝내기
}
System.out.println("신나게 달려요~");
}
}- 기본 생성자 vs 명시적 생성자 차이
- 매개 변수가 있으면 명시적 생성자
- 매개 변수가 없으면 기본 생성자
- 생성자는 명칭이 같더라도 매개변수의 종류, 순서에 따라 구분되기 때문에 중복 명칭을 사용할 수 있다.
- Cat.java
package p01;
// 애완동물 관리 프로그램 개발
// 1. 분석 단계에서 추출한 객체
/*
* 고양이 객체
* 속성: 이름, 나이, 성별
* 동작: 먹기(), 자기(), 뛰기()
*
* 2. 설계 단계에서 표현 => 클래스로 이용 (main 메서드가 없다)
*
* Cat 클래스 ========> public class
* 고양이 객체에 대응되는 Cat 클래스 생성
*
* 변수(인스턴스변수):
* String name;
* int age;
* String sex;
*
* 메서드: 먹기(), 자기(), 뛰기()
*
*
* */
public class Cat {
// 인스턴스 변수
String name;
int age;
String sex;
// 메서드
}
/* Cat c = new Cat(); // 생성자 호출
* 명시적으로 생성자를 작동안하면 자동으로 생성된다 (기본 생성자)
*
* cf. 명시적 생성
* public Dog() {
System.out.println("Dog 생성자");
}
* */
public Shirt(){} // Default Constructor(기본 생성자)
public Shirt(String m, boolean longs, char c){
// Explicit Constructor(명시적 생성자)
maker = m; // 명시적 생성자가 하는 일 = 필드 초기화(Field Initialization)
longSleeved = longs;
color = c;
}- Test.Cat
package p01;
/*
* Cat 클래스를 관리하는 클래스
*
* 1. Cat 클래스를 메모리에 올림 (객체 생성)
*
* 클래스명 변수명 = new 클래스명();
*
* 예> Cat c = new Cat();
*
* 2. Cat 정보를 저장
*
*
* */
public class TestCat {
public static void main(String[] args) {
//Cat 클래스 객체 생성
Cat c = new Cat(); // 생성자 호출
c.name = "야옹이";
c.age = 2;
c.sex = "암컷";
Cat c2= new Cat();
c2.name = "나비";
c2.age =1;
c2.sex = "암컷";
System.out.printf("고양이 이름: %s, 나이: %d, 성별: %s", c.name, c.age, c.sex);
System.out.println();
System.out.printf("고양이 이름: %s, 나이: %d, 성별: %s", c2.name, c2.age, c2.sex);
}
}
- Dog.java
package p02;
// 애완 동물
public class Dog {
String name;
int age;
String sex;
// 생성자 : 인스턴스 변수 초기화
public Dog() {
System.out.println("Dog 생성자");
}
}
- TestDog
package p02;
public class TestDog {
public static void main(String[] args) {
Dog d = new Dog(); // 생성자 호출
}
}
-
생성자 정리
-
객체 생성할 때 타입이 있어야 하고, new라는 키워드가 있어야 하고, 생성자가 호출되어야 한다.
-
객체를 생성하면 객체의 멤버(필드, 메소드)가 가상 메모리 JVM 안에 있는 Heap이라는 공간에 올라간다. Heap에는 반드시 new라는 키워드를 통해서 생성된 객체만 올라간다.
-
객체 생성의 결론 -> Stack에 주소값 할당! 저장된 객체의 위치값이 지정된다.
-
생성자가 하는 일은 필드 초기화(Field Initialization)이다.(X) - null값을 가지는 기본 생성자도 있음.
-
★명시적 생성자가 하는 일은 필드 초기화(Field Initialization)이다.(O)
-
생성자는 메소드 중에서 set메소드와 기능이 같다.(아래 setter 참고) 애초부터 값을 넣어서 만드는 것.
-
오버로딩 생성자
- 여러 생성자를 중복 사용하는 것
- 생성자 명칭은 중복이고, 각 생성자는 argument list에 의해 식별된다 (인자의 자료형, 순서가 다르면 생성자 명칭이 중복되더라도 식별되어 문법 에러가 발생하지 않음)
public Cat() { };
public Cat(int n ) { };- 오버로딩 생성자(over loading) 생성
package p02;
// 애완 동물
public class Dog {
String name;
int age;
String sex;
// 생성자 : 인스턴스 변수 초기화
// 오버로딩 생성자(over loading)
// ==> 하나의 클래스에 같은 이름의 생성자를 여러 개 지정 가능.
// ==> 구별위해 argumnet list (갯수, 타입, 순서) 달라야 한다.
public Dog() {
System.out.println("Dog 생성자1");
}
public Dog(int a) {
System.out.println("Dog 생성자2");
} // 오버로딩 생성자
public Dog(int a, String a2) {
System.out.println("Dog 생성자3");
} // 오버로딩 생성자
public Dog(String a2, int a) {
System.out.println("Dog 생성자4");
} // 오버로딩 생성자
public Dog(String n, int a, String s) {
System.out.println("Dog 생성자5");
} // 오버로딩 생성자
}
- 오버로딩 생성자(over loading) 호출
package p02;
public class TestDog {
public static void main(String[] args) {
// 생성자 호출시 설정하는 값: 인자 (argument)
// 인자 안에 설정되어 전달되는 실제 값(즉, 인자의 값을 저장하는 변수): 매개변수(parameter)
Dog d = new Dog(); // 생성자 호출
/*
Dog d1 = new Dog(int a);
Dog d2 = new Dog(int a, String a2);
Dog d3 = new Dog(String a2, int a);
Dog d4 = new Dog(String n, int a, String s);
*/
Dog d1 = new Dog(20);
Dog d2 = new Dog(20, "AA");
Dog d3 = new Dog("AA", 20);
Dog d4 = new Dog("AA",30, "BB");
}
}
- 실행 결과
클래스 생성 총 정리
- 1) 클래스(main함수 X) 생성
package p03;
public class Cat {
// 인스턴스 변수 (필드)
String name;
int age;
String sex;
// 생성자
// 명시적으로 지정해주지 않으면, 기본 생성자가 자동으로 제공됨
// 명시적으로 만들면 기본 생성자는 자동생성 안됨
// public Cat() {} ;
// 명시적으로 여러 생성자 생성 ==> 오버로딩 생성자 (핸들링 클래스 내 호출 해 사용)
public Cat() {}
public Cat(int n) {}
public Cat(String n) {}
public Cat(String n, int a) {}
public Cat(String n, int a, String s) {
name = n;
age = a;
sex = s;
}
// Cat c = new Cat("야옹이", 2, "암컷"); <= Dog.java
// 야옹이가 n에 저장되고, n을 인스턴스 변수 name에 저장 (인스턴스 변수 초기화 수행)
}
- 2) 핸들링 클래스(main함수 O) 내 호출을 통한 인스턴스 변수 값 초기화, 메서드 호출해 실행
package p03;
public class TestCat {
public static void main(String[] args) {
// 객체의 인스턴스 변수 초기화 방법 2가지
// 1. 생성자 사용
// 생성자 이용해서 초기화 하는 방법은 초기화 시점이 가장 빠른 방법이다.
//heap 메모리에 인스턴스 변수 할당 후(객체 생성)과 동시에 값이 초기화 됨
// 생성자 생성 후 핸들링 클래스의 main() { }내 호출하여 사용 필
Cat c = new Cat("야옹이", 2, "암컷");
// 인스턴스 변수에 직접 접근해서 초기화하는 방법은 초기화 시점이 매우 늦다
/* c.name = "야옹이"; // 객체 생성 이후에 name 변수에 값을 할당
c.age = 2;
c.sex = "암컷";
*/
}
}
-
의문점) 인스턴스 변수를 인자로 모두 포함하는 생성자로 인스턴스 변수 값 초기화 가능한데,굳이 오버로딩 생성자를 만드는 이유는?
-
현실 세계에서 모르면 명부를 비워두는 논리와 유사~
-
Cat c = new Cat("야옹이", "암컷");
=> 성별을 모르는 경우
=> 명시적으로 인스턴스 변수 sex에 null을 기재하지 않아도 자동으로 null로 형 변환 발생함 -
Cat c = new Cat("야옹이");
=> 이름만 아는 경우
=> 명시적으로 인스턴스 변수 sex, age에 null을 기재하지 않아도 자동으로 null로 형 변환 발생함
-
this 키워드
- heap 메모리에 생성된 자신의 instance를 참조할 때 this를 사용한다.
- Cat c = new Cat("야옹", 2, "암컷");
