1. Object 클래스
더보기
- object 클래스는 모든 클래스의 최고조상
== object 클래스의 멤버들은 모든 클래스에서 바로 사용 가능
| Object 클래스의 메서드 | 설명 |
| protected Object clone() | 객체 자신의 복사본을 반환 |
| public boolean equals(Object obj) | 객체 자신과 객체obj가 같은 객체인지 알려줌 (참조변수의 주소값을 비교) |
| protected void finalize() | 객체가 소멸될 때 가비지 컬렉터에 의해 자동 호출 |
| public Class getClass() | 객체 자신의 클래스 정보를 담고 있는 Class 인스턴스를 호출 |
| public int hashCode() | 객체 자신의 해시코드를 반환 |
| public String toString() | 객체 자신 정보를 문자열로 반환 |
| public void notify() | 객체 자신을 사용하려고 기다리는 쓰레드를 하나만 깨움 |
| public void notrifyAll() | 객체 자신을 사용하려고 기다리는 쓰레드를 모두 깨움 |
| public void wait() public void wait(long timeout) public void wait(long timeout, int nanos) |
다른 쓰레드가 notify() / notifyAll()을 호출할 때까지 현재 쓰레드를 무한히 or 지정된 시간 기다리게 함 |
>> equals(Object obj)
- 객체 자신과 주어진 객체를 비교
- Object 클래스에 정의된 equals()는 참조변수의 값(객체의 주소)를 비교
=> 인스턴스 변수 값을 비교하려면 오버라이딩 해야함
=> equals 메서드가 Person 인스턴스의 주소값이 아닌 멤버변수 id를 비교하도록 오버라이딩
>>hashCode()
- 해시함수를 구현한 것
- 찾고자하는 값을 입력하면 그 값이 저장된 위치를 알려주는 해시코드를 반환
- Object에 정의된 hashCode => 객체의 주소값으로 해시코드를 만들어 반환
---- 32bit JVM은 각각 독립적인 해시코드를 지님
---- 64bit JVM은 중복된 해시코드가 존재할 수 있음
ex1) String에서의 hashCode
=> 같은 문자열을 지니면 같은 hashCode가 나오게 오버라이딩 되어 있음
=> System.identityHashCode()의 경우, 객체 주소를 기반으로 하기 때문에
모든 객체에 대해 항상 다른 해시코드 값을 반환할 것을 보장함
>> toString ()
-인스턴스의 정보를 문자열로 제공할 목적으로 정의
=> Object 클래스의 toString == 클래스이름@해시코드
class Card{
String kind;
int number;
Card(){
this("SPADE",1);
}
Card(String kind, int number){
this.kind=kind;
this.number= number;
}
}
public class CardToString {
public static void main(String[] args) {
Card c1= new Card();
Card c2= new Card();
System.out.println(c1.toString());
System.out.println(c2.toString());
}
}
>>실행결과
ch9.Card@36baf30c
ch9.Card@7a81197d
-> 오버라이딩된 toString(String/Date 클래스)
public class toStringTest {
public static void main(String[] args) {
String str = new String("KOREA");
java.util.Date today= new java.util.Date();
System.out.println(str);
System.out.println(str.toString());
System.out.println(today);
System.out.println(today.toString());
}
}
>>실행결과
KOREA
KOREA
Sat Jan 06 23:09:32 KST 2024
Sat Jan 06 23:09:32 KST 2024
-> String 클래스의 toString == String 인스턴스가 가진 문자열 반환
-> Date 클래스의 toString == 갖고있는 날짜와 시간을 문자열로 변환
>>toString override => 접근제어자는 public(Object 클래스에서 public이므로)
public String toString(){
return ("KIND : "+kind+" Num : "+ number);
}
=> Override할 때는 접근제어자가 public이어야 한다는 점 주의
>>clone()
--clone을 위해 필요한 것들
1) implements Cloneable
2) 접근제어자 : public
3) 조상클래스 clone
=> 자신을 복제하여 새로운 인스턴스를 생성
=> 인스턴스 변수의 단순한 값만 복사
=> 참조변수의 경우, 깊은 복사를 위한 오버라이드가 필요
class Point implements Cloneable{
int x,y;
Point (int x, int y){
this.x=x;
this.y=y;
}
public String toString(){
return "x="+x+" y="+y;
}
public Object clone(){
Object obj= null;
try{
obj= super.clone();
}catch(CloneNotSupportedException e) {}
return obj;
}
}
public class CloneEx1{
public static void main(String[] args) {
Point original = new Point(3,5);
Point copy= (Point)original.clone();
System.out.println(original);
System.out.println(copy);
}
}
>> 실행결과
x=3 y=5
x=3 y=5
>>공변 반환타입
: 자손클래스의 타입으로 반환값 타입변경을 허용하는 것
public Point clone(){
Object obj= null;
try{
obj= super.clone();
}catch(CloneNotSupportedException e) {
}
return (Point)obj;
}
}=> Point로 반환
=> (Point) obj로 형변환
>clone과 배열복사
-- 일반 배열(얕은 복사로도 가능)
public class CloneEx2 {
public static void main(String[] args) {
int [] arr={1,2,3,4,5};
int [] arrClone = arr.clone();
arrClone[0]=6;
System.out.println(Arrays.toString(arr));
System.out.println(Arrays.toString(arrClone));
}
}
>>실행결과
[1, 2, 3, 4, 5]
[6, 2, 3, 4, 5]
-- 객체 배열 => 깊은 복사를 해야함
=> 단지 주소값만 복사하면 복사본 변경이 원본에 영향을 줌(같은 객체를 가르키기에)
=> 아예 새로운 인스턴스를 만들어 초기화가 필요함
package ch9;
class Circle implements Cloneable{
Point p;
double r;
Circle(Point p, double r){
this.p=p;
this.r=r;
}
public Circle shallowCopy(){
Object obj=null;
try{
obj=super.clone();
}catch(CloneNotSupportedException e){};
return (Circle)obj;
}
public Circle deepCopy(){
Object obj=null;
try{
obj=super.clone();
}catch(CloneNotSupportedException e){};
//깊은 복사 => 객ㅊ가 필요한 부분은 생성하여 복사
Circle c= (Circle)obj;
c.p= new Point(this.p.x, this.p.y);
return c;
}
public String toString(){
return "[p="+p+", r="+r+"]";
}
}
class Point{
int x,y;
Point (int x, int y){
this.x=x;
this.y=y;
}
public String toString(){
return "x="+x+" y="+y;
}
}
public class CloneEx1{
public static void main(String[] args) {
Circle c1= new Circle(new Point(1,1), 2.0);
Circle c2= c1.shallowCopy();
Circle c3= c1.deepCopy();
System.out.println("c1 = "+c1);
System.out.println("c2 = "+c2);
System.out.println("c3 = "+c3);
c1.p.x=9;
c2.p.y=9;
System.out.println("=c1의 변경 후 =");
System.out.println("c1 = "+c1);
System.out.println("c2 = "+c2);
System.out.println("c3 = "+c3);
}
}
>>실행결과
c1 = [p=x=1 y=1, r=2.0]
c2 = [p=x=1 y=1, r=2.0]
c3 = [p=x=1 y=1, r=2.0]
=c1의 변경 후 =
c1 = [p=x=9 y=9, r=2.0]
c2 = [p=x=9 y=9, r=2.0]
c3 = [p=x=1 y=1, r=2.0]
=> 깊은 복사가 필요한 부분은 반드시 갱신해주어야 한다.
>>getClass()
- 자신이 속한 클래스의 Class 객체를 반환
- Class 객체는 클래스의 모든 정보를 담고 있으며 클래스 당 1개만 존재
--class 객체를 얻는 3가지 방법
1) Class c= Card.class
2) Class c= new Card().getClass()
3) Class c= Class.forName("Card");
2. String 패키지
더보기
- 문자열 배열 (char []) 와 그에 관련된 메서드들이 정의되어 있음
- immutable(읽기만 가능하고 수정이 불가하다.)=> 바꾸기 위해서는 Stringbuffer class 사용
=> 결합이나 추출 등이 많다면 StringBuffer 클래스를 사용하는 것이 좋음
>> 문자열의 비교
- 문자열을 만들때 : 리터럴 값 vs 생성자
<리터럴> =>같은 객체를 공유
String str1="abc";
String str2="abc";
<생성자>=> 항상 새로운 인스턴스 생성
String str3= new String("abc");
String str4= new String("abc");
public class StringEx1 {
public static void main(String[] args) {
String str1="abc";
String str2="abc";
System.out.println(str1.equals(str2));
System.out.println(str1==str2);
String str3= new String("abc");
String str4= new String("abc");
System.out.println(str3.equals(str4));
System.out.println(str3==str4);
}
>>문자열 리터럴
- 컴파일 시에 클래스 파일에 저장
- 같은 내용의 문자열 리터럴은 한번만 저장
>>빈 문자열
- 길이가 0인 배열이 존재가능 => 길이가 0인 char[] 배열 존재 가능 == 길이가 0인 문자열 존재가능
>>String 클래스의 생성자와 매서드
| 메서드/설명 | 예제 | 결과 |
| String(String s) | String s= new String("Hello"); | s="Hello" |
| 문자열(s)를 갖는 String 인스턴스 생성 | ||
| String(char [] value) | char [] c={'H', 'e', 'l', 'l', '0'}; String s= new String(c); |
s="Hello" |
| 문자열(value)를 갖는 String 인스턴스 생성 | ||
| String (StringBuffer buf) | Stringbuffer sb= new StringBuffer("Hello"); String s= new String(sb); |
sb="Hello" s="Hello" |
| Stringbuffer인스턴스가 가지고 있는 문자열과 동일한 내용의 String 인스턴스 생성 | ||
| char charAt(int idx) | String s="Hello"; char c= s.charAt(1); |
c='e' |
| idx에 있는 문자 반환 | ||
| int compareTo(String str) | int i1 = "aaa".compareTo("aaa"); int i2 = "aaa".compareTo("bbb"); int i3 = "bbb".compareTo("aaa"); |
i1= 0 i2=-1 i3= 1 |
| 문자열과 사전순서 비교 = strcmp | ||
| String concat(String str) | String s="Hello"; String s2= s.concat(" World!"); |
s= "Hello" s2= "Hello World!" |
| 문자열 뒤에 덧붙인다. | ||
| boolean contains(CharSequence s) | String s= "abcdefg"; boolean b= s.contains("bc"); |
b=true |
| 지정된 문자열 s가 포함되었는지 | ||
| boolean startsWith(String prefix) | String file="Hello.txt"; boolean b= file.startsWith("Hello"); |
b=true |
| 지정된 문자열로 시작하는지 | ||
| boolean endsWith(String suffix) | String file="Hello.txt"; boolean b= file.endsWith("txt"); |
b=true |
| 지정된 문자열로 끝나는지 | ||
| boolean equals(Object obj) | String s="Hello"; boolean b= s.equals("Hello"); boolean b2= s.eqauls("hello"); |
b= true b2= false; |
| obj와 인스턴스 문자열 내용이 같은지 | ||
| boolean equalsIgnoreCase(Object obj) | String s="Hello"; boolean b= s.equals("Hello"); boolean b2= s.eqauls("hello"); |
b= true b2= true; |
| obj와 인스턴스의 문자열 내용이 같은지 (대소문자 구분x) |
||
| int indexOf(int ch) | String s="Hello"; int idx1= s.indexOf("o") int idx2 = s.indexOf("k"); |
idx1=4; idx2=-1; |
| 주어진 ch의 위치 반환 못찾으면 -1반환 |
||
| int indexOf(int ch, int pos) | String s="Hello"; int idx1= s.indexOf("e", 0) int idx2 = s.indexOf("e", 2); |
idx1=1; idx2=-1; |
| pos부터 찾은 주어진 ch의 위치를 반환 못찾으면 -1 반환 |
||
| int indexOf(String str) | String s="ABCDEFG"; int idx= s.indexOf("CD") |
idx=2 |
| 문자열의 위치 반환 못찾으면 -1 반환 |
||
| String intern() | String s= new String("abc") String s2= new String("abc") boolean b= (s==s2) boolean b2= s.equals(s2); boolean b3= s.intern() == s2.intern() |
b=false b2=true b3=true |
| 문자열을 상수풀에 등록 이미 상수풀에 같은 내용의 문자열이 있으면 주소값을 반환 |
| 메서드/설명 | 예제 | 결과 |
| int lastIndexOf(int ch) int lastIndexOf(String str) |
String s="java.lang.Object"; int idx1= s.lastIndexOf('.'); int idx2- s.indexOf('.'); |
idx1=9 idx2=4 |
| 끝에서부터 찾음 못찾으면 -1 반환 |
||
| int length() | String s= "Hello"; int length = s.length() |
length= 5 |
| 문자열 길이를 알려준다 | ||
| String replace(char old, char nw) String replace(CharSequence old, Char sequence new) |
String s="Hello"; String s1= s.replace('H', 'C'); String s= "Hellollo"; String s2= s.replace("ll", "LL"); |
s1= "Cello" s2= "HeLLoLLo" |
| 문자열 old -> new로 변환 | ||
String replaceAll(String regex, String replacement) |
String ab= "AABBAABB"; String r= ab.replaceAll("BB", "bb"); |
r= AAbbAAbb |
| 정규표현식에 일치하는 문자열을 모두 새로운 걸로 바꿈 | ||
| String replaceFirst(String regex, String replacement) | String ab= "AABBAABB"; String r= ab.replaceFirst("BB", "bb"); |
r= AAbbAABB |
| 정규표현식에 일치하는 첫번째 문자열을 바꿈 | ||
| String [] split(String regex) | String animals="dog,cat, bear"; String [] arr= animals.split(','); |
arr[0]="dog" arr[1]="cat" arr[2]="bear" |
| 문자열을 지정된 분리자로 나누어 문자열 배열에 담아 반환 | ||
| String [] split(String regex, int limit) | String animals="dog,cat, bear"; String [] arr= animals.split(',' , 2); |
arr[0]="dog" arr[1]="cat, bear |
| 분리자로 나누어 문자열 배열 반환 => 문자열 전체를 지정된 수로 자름 |
||
| String substring(int begin) String substring(int begin, int end) |
String s="java.lang.Object" String c= s.substring(10) String b2 = s.substring(5,9); |
c="Object" p="lang" |
| 주어진 시작 위치부터 끝 위치 범위에 포함된 문자열을 얻는다. 이때 시작위치는 범위에 포함되지만 끝 위치는 포함x | ||
| String toLowerCase() String to UpperCase() |
String s="Hello"; String s1= s.toLowerCase(); String s2= s.toUpperCase(); |
s1="hello" s2="HELLO"; |
| 소문자 혹은 대문자로 변환 | ||
| String toString() | String s="Hello"; String s1= "s.toString(); |
s1= "Hello" |
| String 인스턴스에 저장된 문자열 반환 | ||
| String trim() | String s= " Hello Wrold " String s1= s.trim() |
s1="Hello Wrold" |
| 양 끝의 공백을 없앤 결과 반환 중간에 있는 공백은 유지 |
||
| static String valueOf (boolean b) static String valueOf (char c ) static String valueOf (int i) static String valueOf (long l) static String valueOf (float f) static String valueOf (double d) static String valueOf (Object o) |
String b= String.valueOf(true); String c= String.valueOf('a'); String i= String.valueOf(100); String l= String.valueOf(100L); String f= String.valueOf(10f); String d= String.valueOf(10.0); String o= String.valueOf(new Date()); => toString 호출결과 반환 |
b="true" c='a' i="100" l="100" f="10.0" d="10.0" |
| 문자열로 변환하여 반환 => 참조변수의 경우 toString의 호출한 결과를 반환 |
>> join() 과 StringJoiner
join() - 구분자를 넣어 결합
StringJoiner(구분자, 첫글자, 마지막글자) => sj.add(문자열)을 통해 하나씩 원소 추가
import java.util.StringJoiner;
public class StringEx4 {
public static void main(String[] args) {
String animals="dog,cat,bear";
String [] arr= animals.split(",");
//join으로 묶기
System.out.println(String.join("-"));
//StringJoiner사용하기
StringJoiner sj= new StringJoiner(",","[", "]");
for(String s: arr){
sj.add(s);
}
System.out.println(sj.toString());
}
}
>> String.format
: format()은 형식화된 문자열을 만들어내는 간단한 방법 => printf와 같은 사용법
[기본형 -> String으로 변환]
=> valueOf가 더 빠름
[기본형<-String으로 변환]
-> Integer.parseInt() / Float.parseFloat()의 경우, 문자열에 공백이나 문자가 포함되어 있는 경우
=> 변환 시 예외가 발생할 수 있으므로 주의!
3. Stringbuffer 클래스
더보기
- String처럼 문자열 배열 (char[])을 내부적으로 지님
- String과 달리 변경이 가능함
- 버퍼의 크기를 충분히 지정해주는 것이 좋음
- String 클래스와 달리 equals를 오버라이딩 하지 않음
>>생성자
| 생성자 | 예제/결과 |
| StringBuffer() | StringBuffer sb= new StringBuffer() |
| 16 길이의 버퍼를 가진 인스턴스 생성 | sb="" |
| StringBuffer(int length) | StringBuffer sb= new StringBuffer(10); |
| 지정된 버퍼 길이를 가진 인스턴스 생성 | sb="" |
| StringBuffer(String str) | String sb= new StringBuffer("Hi"); |
| 문자열 값을 갖는 인스턴스 생성 버퍼 길이는 str.length+16 |
sb="Hi"; |
>>equals를 오버라이딩 하지 않음
=> 그렇기 때문에 비교하기 위해서toString()을 통해 문자열로 변환
public class StringEx5 {
public static void main(String[] args) {
StringBuffer sb= new StringBuffer("abc");
StringBuffer sb2= new StringBuffer("abc");
System.out.println("sb==s2 : "+ (sb==sb2));
System.out.println("sb.equals(s2) : "+ sb.equals(sb2));
//StringBuffer의 내용은 String으로 변환한다.
String s= sb.toString();
String s2= sb2.toString();
System.out.println("s.equals(s2) : " + s.equals(s2));
}
}
>>메소드
| 메소드 | 예제/결과 |
| Stringbuffer(append(boolean b) String buffer(append(char c) String buffer(append(int i) String buffer(append(long l) String buffer(append(char [] str) String buffer(append(double d) String buffer(append(float f) String buffer(append(Object obj) String buffer(append(String str) |
StringBuffer sb= new StringBuffer("abc"); StringBuffer sb2= sb.append(true); sb.append('d').append(10.0f); StringBuffer sb3= sb.append("ABC").append(123); => 주소값을 반환하므로 같은 객체를 가키게 됨 |
| 매개변수로 입력된 값을 문자열로 반환하여 Stringbuffer가 가진 문자열 값에 추가 | sb=" abcd10.0ABC123" sb2=" abcd10.0ABC123" sb3=" abcd10.0ABC123" |
| int capacity() int length() |
StringBuffer sb= new StringBuffer(!00); sb.append("abcd"); int bufferSize = sb.capacity() int stringSize = sb.length(); |
| capacity : 버퍼의 전체 크기 length는 : 버퍼에 담긴 문자열의 길이 |
bufferSize=100 stringSize=4 |
| char charAt(int index) | StringBuffer sb= new StringBuffer("abc"); char c= sb.charAt(2); |
| 지정된 위치(index)에 있는 문자 반환 | c='c' |
| StringBuffer delete(int stat, in end) | StringBuffer sb= new StringBuffer("0123456"); StringBuffer sb2= sb.delete(3,6); => 같은 주소값 반환 |
| start -end-1까지 제거 | sb="0126"; sb2="0126" |
| StringBuffer deleteCharAt(int index) | StringBuffer sb= new StringBuffer("0123456"); sb.deleteCharAt(3); |
| 지정된 위치(index)의 문자 제거 | sb="012456" |
| StringBuffer insert(int pos, boolean b) StringBuffer insert(int pos, char c) StringBuffer insert(int pos, char [] st) StringBuffer insert(int pos, double d) StringBuffer insert(int pos, float f) StringBuffer insert(int pos, int i) StringBuffer insert(int pos, long l) StringBuffer insert(int pos, Object obj) StringBuffer insert(int pos, String str) |
StringBuffer sb= new StringBuffer("0123456") sb.insert(4, ',') |
| 두번째 매개변수로 받은 값을 문자열로 반환하여 지정된 pos에 추가한다. | sb="0123.456" |
| StringBuffer replace(int start, int, end, String str) | StringBuffer sb= new StringBuffer("0123456")' sb.replace(3,6, "AB"); |
| start-end까지의 문자들을 str로 바꾼다. | sb= "12AB6" |
| StringBuffer reverse() | StringBuffer sb= new StringBuffer("0123456")' sb.reverse() |
| 문자열의 순서를 거꾸로 저장하여 나열 | sb="6543210" |
| void setCharAt(int index, char ch) | StringBuffer sb= new StringBuffer("0123456")' sb.setCharAt(5,'o'); |
| 지정된 위치의 문자를 ch로 바꿈 | sb="01234o6" |
| void setLength(int newLength) | StringBuffer sb= new StringBuffer("0123456")' sb.setLength(5); StringBuffer sb2= new StringBuffer("0123456")' sb2.setLength(10); String str=sb2.toString().trim() |
| 지정된 길이로 문자열의 길이를 변경 | sb="01234" sb2="012356 " str="0123456" |
| String toString() | StringBuffer sb= new StringBuffer("0123456")' sb.toString() |
| 문자열을 String으로 반환 | str="0123456" |
| String substring(int start) String substring(int start, int end) |
StringBuffer sb= new StringBuffer("0123456")' String str1 = sb.substring(3); String str2 = sb.substring(3,5); |
| 시작위치-끝까지 반환 | str1="3456" str2="34" |
package ch9;
public class StringBufferEx2 {
public static void main(String[] args) {
StringBuffer sb= new StringBuffer("01");
StringBuffer sb2= sb.append(23);
sb.append('4').append(56);
StringBuffer sb3= sb.append(78);
sb3.append(9.0);
System.out.println("sb= "+sb);
System.out.println("sb2= "+sb2);
System.out.println("sb3= "+sb3);
System.out.println("sb = "+ sb.deleteCharAt(10));
System.out.println("sb = "+ sb.delete(3,6));
System.out.println("sb = "+ sb.insert(3,"abc"));
System.out.println("sb = "+ sb.replace(6, sb.length(), "END"));
System.out.println("capacity = "+ sb.capacity());
System.out.println("length = "+sb.length());
}
}
>>실행결과
sb= 0123456789.0
sb2= 0123456789.0
sb3= 0123456789.0
sb = 01234567890
sb = 01267890
sb = 012abc67890
sb = 012abcEND
capacity = 18
length = 9
4. Math 클래스
더보기
- 수학계산에 유용한 메서드로 구성 => 모두 static 메서드
- 인스턴스 변수가 없기 때문에 생성자가 private으로 정의됨
>> 반올림하는 법
- 10의 n 제곱을 통해 수를 올림
- round를 통해 반올림
- 다시 100.0으로 나누어줌
ex)
1. 원래 값에 100을 곱한다. -- 90.7552 * 100 = 9075.52
2. Math.round()를 사용 -- Math.round(9075.52) = 9076
3. 다시 100.0을 나누어줌 -- 9076/100.0 = 90.76
=> 100으로 나누면 정수값으로 튀어나옴
>> 예외를 발생시키는 메서드 : 연산Exact
-- 메서드 이름에 exact가 포함된 메서드들이 JDK1.8부터 추가
int addExact(int x, int y) // x+y
int subtractExact(int x, int y) // x-y
int multiplyExact(int x, int y) // x*y
int incrementExact(int x) // x++
int decrementExact(int x) // x--
int negateExact(int x) // -x
int toIntExact(int x) // (int)value
=> 정수형 간의 연산에서 발생할 수 있는 오버플로우 감지
=> 오버플로우가 발생하면 예외 (ArithmeticExceptin)을 발생시킴
ex)
public class MathEx2 {
public static void main(String[] args) {
int i= Integer.MIN_VALUE;
System.out.println("i="+i);
System.out.println("-i="+(-i)); //오버플로우 감지 x
try {
System.out.printf("negateExact(%d)= %d%n", 10, negateExact(10));
System.out.printf("negateExact(%d)= %d%n", -10, negateExact(-10));
System.out.printf("negateExact(%d)= %d%n", i, negateExact(i)); //오버플로우 감지
}catch(ArithmeticException e){
System.out.printf("negateExact(%d%) =%d%n", (long)i, negateExact((long) i));
}
}
}
>> 실행결과
i=-2147483648
-i=-2147483648
negateExact(10)= -10
negateExact(-10)= 10
negateExact(-2147483648) =2147483648
>> 메서드
=> rint() -- 가운데 있는 값은 짝수를 반환
>> 래퍼(wrapper) 클래스
- 기본형을 클래스로 정의한 것
- 기본형 값을 객체로 다룰 때
-- 내부적으로 기본형 변수를 가짐
-- equals가 오버라이딩 되어 있음 ==> 객체 주소가 아닌 값을 비교
-- Number 클래스 : 숫자를 멤버변수로 갖는 래퍼 클래스
>>Wrapper 클래스에서 진법에 맞게 숫자 변환하기
=> 진수를 생략하면 10진수로 간주하기 때문에 예외 발생
ex) Integer.parseInt("FF") => NumberFormatException 예외
int i4 = Integer.parseInt("100" , 2) => 100(2) -> 4
int i4 = Integer.parseInt("100" , 8) => 100(8) -> 64
int i4 = Integer.parseInt("100" , 16) => 100(16) -> 256
int i4 = Integer.parseInt("FF" , 16) => FF(16) -> 255
>>autoboxing & unboxing
-autoboxing : 기본형 값 => 객체화
-unboxing : 기본형 값 <= wrapper 객체
컴파일러가 자동으로 변경해줌
| 컴파일 전 코드 | 컴파일 후 코드 |
| Integer intg= (Integer) i; Object obj = (Object)i Long lng = 100L; |
Integer intg= Integer. valueOf(i).; Object obj = (Object) Integer.valueOf(i) Long lng = new Long(100L); |
'기술 서적 > 자바의 정석' 카테고리의 다른 글
| [자바의 정석] 11-2.컬렉션 프레임워크 : iterator / Arrays / Comparator / Set (0) | 2024.01.16 |
|---|---|
| [자바의 정석] ch11-1 : 컬렉션프레임워크 -- List / Stack-Queue (0) | 2024.01.14 |
| [자바의 정석] ch8. 예외처리 (0) | 2024.01.06 |
| [자바의 정석] ch7. 객체지향 프로그래밍 II (0) | 2024.01.05 |
| [자바의 정석] ch5. 배열 (0) | 2023.12.02 |
