230804 배열, 객체 배열, 문자열 String, Wrapper class
[23.08.04] 10일차
<<진도>>
- 과제풀이 (Constructor, Array)
- 배열
: 1차원 배열, 2차원 배열, 배열명.length
- 문자열 String
.toString();
메서드 .equals();
- Wrapper
boxing, unboxing
<<오늘의 팁>>
- ConstructorQuiz01
class Car {
// field 멤버변수 : 인스턴스(객체) 변수
int door;
String color;
// constructor
// 참조변수 : this.멤버
// 생성자 호출 : this()
Car() {
// this.door = 4; // < 클래스 내에서 접근 = 내부접근
// this.color = "black";
this(4, "black");
}
Car(int door) {
this(door, "black");
}
Car(String color) {
this(4, color);
}
Car(int door, String color) {
this.door = door;
this.color = color;
}
// method 인스턴스(객체) 메서드
void info() {
System.out.printf("문 개수 : %d, 색 : %s\n", door, color);
}
}
public class ConstructorQuiz01 {
public static void main(String[] args) {
// 클래스 Car 정리
Car c1 = new Car();
c1.info(); // 문 개수 : 4, 색 : black - 필드 데이터 기본값
Car c2 = new Car(2);
c2.info(); // 문 개수 : 2, 색 : black
Car c3 = new Car("white");
c3.info(); // 문 개수 : 4, 색 : white
Car c4 = new Car(6, "grey");
c4.info(); // 문 개수 : 6, 색 : grey
}
}
- ArrayEx02Develop 향상된 for문
public class ArrayEx02Develop {
public static void main(String[] args) {
// [2차원 배열] 길이가 2개인 배열 ==================================
int[][] arr2 = new int[2][3];
// 자료형[][] 배열명 = new 자료형[행길이][열길이]
System.out.println("arr2 : " + arr2); // arr2[0], arr2[1] 1차원 배열 2개 행를 가진 배열의 주소
// 주소에 ( [[I@~~~~ ) [[ 2차원배열
System.out.println("arr2[0] : " + arr2[0]); // arr2 [0]행의 시작주소 : 특정 행을 찾아온 주소
System.out.println("arr2[1] : " + arr2[1]); // arr2 [1]행의 시작주소 : 특정 행을 찾아온 주소
arr2[0][0] = 2;
arr2[0][1] = 4;
arr2[0][2] = 6;
arr2[1][0] = 8;
arr2[1][1] = 10;
arr2[1][2] = 12;
// 2 4 6
// 8 10 12
// 형태 뽑기
// [향상된 for문] 2차원 배열
// =================================================================================
for (int element : arr2[0]) {
System.out.print(element + " ");
}
System.out.println();
for (int element : arr2[1])
System.out.print(element + " ");
// [풀이] ==============================================================
// 중첩 for문 사용 배열열 출력하기
System.out.println("향상된 for문");
System.out.println("[행의 시작주소] arr2 >> " + arr2);
System.out.println("[열의 시작주소] arr2[0] >> " + arr2[0]);
System.out.println("[열의 시작주소] arr2[1] >> " + arr2[1]);
for (int[] ar : arr2) { // int[] : 1차원 배열의 자료형
// arr2에 담겨있는 1차원 배열 arr2[0], arr2[1]을 찾아가는 개념
for (int a : ar) // ar : 참조변수에 arr2[] index 값들 복사
System.out.print(a + " ");
System.out.println();
}
}
}
- ArrayEx02CleanCode
// [1차원 배열] 길이가 1개인 배열 ==================================
//배열생성과 동시에 초기화 -> 배열은 한번 길이가 정해지면 변경하지 못한다.
int[] arr = new int[] {2, 4, 6, 8, 10};
// [2차원 배열] 길이가 2개인 배열 ==================================
// 2차원 배열생성과 동시에 초기화
int[][] arr2 = new int[][] {{2, 4, 6}, {8, 10, 12}};
// 자료형[][] 배열명 = new 자료형[][]{{1차원배열 1}, {1차원배열 2}}
// int[][] arr3 = new INT[][] {{2, 4}, {6, 8, 10, 12}};
int[][] arr3 = {{2, 4}, {6, 8, 10, 12}};
// 자료형[][] 배열명 = {{1차원배열 1}, {1차원배열 2}};
arr2[0][0] = 2;
arr2[0][1] = 4;
arr2[0][2] = 6;
arr2[1][0] = 8;
arr2[1][1] = 10;
arr2[1][2] = 12;
// 2 4 6
// 8 10 12
// 형태 뽑기
// 일반 for문
for (int i = 0; i < arr2.length; i++) {// [행]
for (int j = 0; j < arr2[i].length; j++) {
System.out.print(arr2[i][j] + " ");
}
System.out.println();
}
// 향상된 for문
for (int[] ar : arr2) { // int[] : 1차원 배열의 자료형
// arr2에 담겨있는 1차원 배열 arr2[0], arr2[1]을 찾아가는 개념
for (int a : ar) // ar : 참조변수에 arr2[] index 값들 복사
System.out.print(a + " ");
System.out.println();
}
}
- ArrayEx03
public class ArrayEx03 {
public static void main(String[] args) {
// [2차원 배열 생성]
// : 열 길이 생략가능
// : 행 길이 생략불가능
int[][] arr =new int[2][];
System.out.println("arr : " + arr); // 주소
System.out.println("arr[0] : " + arr[0]); // 비어있으므로 null
System.out.println("arr[1] : " + arr[1]); // 비어있으므로 null
//2차원 배열 열의 길이 다르게 설정입력
arr[0] = new int[3]; // 0 0 0
arr[1] = new int[] {5}; // 5
// 향상 for문 출력
for(int[] ar: arr) {
for(int a: ar)
System.out.print(a + " ");
System.out.println();
}
//결과 0 0 0
// 5
}
}
- ArrayInstanceEx01
class Student {
// field
int age;
String name;
// constructor
Student(int age, String name) {
this.age = age;
this.name = name;
}
// method
void showInfo() {
System.out.println("나이 : " + this.age);
System.out.println("이름 : " + this.name);
System.out.println("===================\n");
}
}
public class ArrayInstanceEx01 {
public static void main(String[] args) {
// [객체 배열]
// 타입[] 배열명 = new 타입[길이];
Student[] smart = new Student[3]; // 객체 생성이 아닌 !!!배열생성!!! [] heap
// Student class형태의 1차원배열
// System.out.println("smart : " + smart); // 객체 주소
// System.out.println("smart[0] : " + smart[0]); // null
// System.out.println();
// 2차원 배열과 유사한 형태
smart[0] = new Student(26, "hong"); // 배열 형태의 !!!객체 생성!!! () heap
smart[1] = new Student(32, "park");
smart[2] = new Student(55, "lee");
// 배열 자리에 단순 자료형이나 객체가 아닌! -> class 객체의 "주소"가 저장된다 (호출가능!)
// (= ex)
// Student one = new Student(26, "hong");
// Student two= new Student(32, "park");
// Student three = new Student(55, "lee");
// 원래 위 처럼 객체 1개 당 참조변수 1개로 관리했었는데!
// 객체 배열을 통해 여러개의 객체를 배열로 관리가능!!
// 객체 배열 생성과 동시에 초기화 ***
// Student[] smart = new Student[] {new Student(26, "hong"), new Student(32, "park"), new Student(55, "lee")};
// 생략가능
Student[] smart = {new Student(26, "hong"), new Student(32, "park"), new Student(55, "lee")};
// smart[0].showInfo(); //참조변수(주소).메서드 호출
// smart[1].showInfo();
// smart[2].showInfo();
// 1) 일반 for문
for(int i = 0; i < smart.length; i++) // length 처럼 이미 만들어져있는 변수 : 내장변수
smart[i].showInfo();
// 2) 향상된 for문
for (Student student : smart)
student.showInfo();
- ArrayInstanceEx02
class Fruit {
// field
String sort;
int count;
// constructor
Fruit(String sort, int count) {
this.sort = sort;
this.count = count;
}
// method
void fruitInfo() {
System.out.println(sort + "가 " + count + "개 있습니다.");
}
}
public class ArrayInstanceEx02 {
public static void main(String[] args) {
// 길이가 3인 객체 fruit 배열 생성
// 첫번째 과일 정보 : 사과 5개
// 두번째 과일 정보: 바나나 2개
// 세번째 과일 정보 : 망고 3개
Fruit[] fruit = new Fruit[3];
fruit[0] = new Fruit("사과", 5);
fruit[1] = new Fruit("바나나", 2);
fruit[2] = new Fruit("망고", 3);
// = Fruit[] fruit = new Fruit[] {new Fruit("사과", 5), new Fruit("바나나", 2), new Fruit("망고", 3)};
// = Fruit[] fruit = {new Fruit("사과", 5), new Fruit("바나나", 2), new Fruit("망고", 3)};
for(Fruit fr : fruit)
fr.fruitInfo();
}
}
- StringEx01
fpublic class StringEx01 {
public static void main(String[] args) {
// 문자열(String)은 시작주소로 가서 리터럴을 쭉 읽어버린다. (주소가 안보임)
// 문자 '리터럴'은 RAM의 constant 영역에 저장된다
String s = "안녕";
String s2 = "안녕";
String s3 = new String("안녕");
String s4 = new String("안녕");
// 네개는 모두 같다! (but, s3, s4의 heap에 할당된 객체들의 주소는 다르다)
// 매번 다른 클래스처럼 new String을 안하는 이유 : " " 따옴표를 붙이면 String으로 취급하기로 약속
// float fo =3.5F의 접미사 F처럼
// System.out.println("s : " + s);
if (s3 == s4)
System.out.println("주소가 같다");
else
System.out.println("주소가 다르다");
// String 객체에 저장된 문자열 비교//
System.out.println("문자열 비교 : " + s3.equals(s4));
// ** .equals() : 문자열 리터럴 "안녕"이 같은지 비교.
// **heap에있는 두 객체의 참조 변수의 주소를 비교하는 ' == '와 다름
System.out.println("문자열 비교2 : " + "안녕".equals(s4));
System.out.println("문자열 비교3 : " + "안녕".equals("안녕"));
// String 객체 배열 생성
// =====================================================================
String[] strArr = new String[3];
strArr[0] = new String("Java");
strArr[1] = new String("HTML");
strArr[2] = new String("Python");
// 2) 배열 생성과 동시에 초기화
String[] strArr = new String[] {new String("Java"),
new String("HTML"),
new String("Python")
};
// 2-1) 단축
String[] strArr = {"Java", "HTML", "Python"};
// [문자열 춢력]
// System.out.println(strArr[0]);
// System.out.println(strArr[1]);
// System.out.println(strArr[2]);
// 향상된 for문
for (String sa : strArr)
System.out.println(sa);
}
}
- StringEx02
public class StringEx02 {
public static void main(String[] args) {
// main 메서드의 매개변수는 문자열 배열 String[]로 형태가 정해져있다.
// java에서 메인 메서드를 호출하는 것은 'JVM (Java Virtual Machine) : (자바)가상머신'
// 사용자가 실행을 했기 때문에
// main 메서드의 매개변수를 통한 출력
//일반 for문 (메인 메서드 출력 arguments : 인수)
for(int i=0; i<args.length; i++)
System.out.println(args[i]);
System.out.println("args.length : " + args.length);
// 공백을 단위로 개수 나눠지므로 띄어쓰기는 " " 하나로 묶어준다.
}
}
자료형(Type) 중
기본형 – int, float, boolean 등
참조형 – class
- StringEx03
class Animal {
}
public class StringEx03 {
public static void main(String[] args) {
Animal animal = new Animal();
System.out.println(4); // 입력인수는 정수이나, 사실 출력된 4는 "4" 문자열이다
System.out.println(animal); // Animal 객체의 주소출력
System.out.println(animal.toString());
// 참조변수뒤에.toString() : 문자열로 출력하시오 // animal = animal.toString();
System.out.println(animal.getClass()); // 해당 class(animal의 type)를 get! // -> class Animal
System.out.println(animal.getClass().getName()); // 그 class의 이름만 get! // -> Animal 이름만
String str = "안녕";
System.out.println(str); // str에 들어있는 주소는 "안녕" 문자열의 맨앞 "시작주소"!
System.out.println(str.toString());
// str은 바로 문자열로 연결되기때문에 본인 String 데이터에 그대로 toString // ( str = str.toString() )
//** println()에 참조변수를 넣어주면 보이지않아도 사실 뒤에 .toString()이 붙어있다.
}
}
- WrapperClassEx01
/*
* [primitive type]
* byte - short - char - int - long
*
*
* [Wrapper class]
* Byte - Short - Character - Integer - Long
* Float - Double
* Boolean
*
* <<자동형변환>>
* boxing
* 기본형 ---> 참조형
* primitive type <--- reference type
* unboxing
*
* 기본형이 박싱된 객체형태 참조형을 Wrapper class 랩퍼 클래스라고한다.
*
*/
public class WrapperClassEx01 {
public static void main(String[] args) {
int num = 5;
Integer num2 = 5; // 형변환(boxing) : int -> Integer
//** int[][] 배열의 int도 사실 Integer형태로 방식된 Wrapper 클래스이다.***
Integer num3 = new Integer(5);// << deprecated 이제 사용되지않아서 취소선 (사장된)
Integer num3 = Integer.valueOf(5); // << 개선버전
System.out.println(num); // 5
System.out.println(num2); // 5
System.out.println(num2.toString()); // " 5 "
int num4 = num2; // 형변환(unboxing) : Integer -> int
}
}