[Java] 2주차 수업: 2024.02.26 - 2024.02.29

2024.02.26

 

*객체

-객체의 주소가 들어가 있는 변수: 참조변수

-객체도 배열과 같이 초기값(기본값)이 자동으로 생성됨

  e.g. String -> null, int -> 0

-println메서드로 참조변수를 출력하면 생성된 객체(인스턴스)의 참조값이 출력됨

 

*생성자

-객체 생성시 호출됨

-생략 가능하며 생략하면 컴파일 시 자동 생성

public InstanceMain() {}        // 클래스명과 동일

 

-객체를 생성하면 생성자는 메모리에 올라가지 않고 멤버 필드와 멤버 메서드만 올라감

-메인 메서드도 객체가 생성되는 장소일 뿐이지 객체에 포함되지 않음

 

*메서드

-소괄호 내의 인자를 통해 데이터를 받아 옴

-return 문을 통해 데이터를 반환함

	public int sum(int a, int b) {         // 함수의 입구
		return a + b;                 // 함수의 출구
	}

 

*다중 삼항연산자

		int result;
		if (x < 0) {
			result = -1;
		} else if (x > 0) {
			result = 1;
		} else {
			result =  0;
		}

이 코드를 다중 삼항연산자로 표현하면

		int result = (x < 0) ? -1 : (x > 0) ? 1 : 0;
		return result;

이렇게 간단하게 표현할 수 있음

-변수명 = (조건1) ? true : (조건2) ? true : false

-메서드에서는 값을 하나 밖에 반환하지 못함

 

public class StudentMain {
// 멤버 필드(속성)
	String name;
	int korean;
	int english;
	int math;
    
    public void printAll() {
		System.out.println("이름 : " + name);
		System.out.println("국어 : " + korean);
		System.out.println("영어 : " + english);
		System.out.println("수학 : " + math);
		System.out.println("총점 : " + makeSum());
		System.out.println("평균 : " + makeAverage());
		System.out.println("등급 : " + makeGrade());
		System.out.println("-------------------");
	}      
    }

 

 

-한 메서드에서 같은 클래스 내의 멤버변수나 멤버메서드를 읽어올 때는 참조변수와 닷 연산자없이 호출할 수 있음

-printAll()을 메서드로 만듦으로써 코드의 양을 줄이고 재활용성을 높임

 

-한 파일 안에 여러 개의 class를 만들면 주클래스에만 public을 붙일 수 있고 부클래스에는 public을 붙일 수 없음

-main 메서드는 주클래스 안에 만들어야 함

 

 

 

2024.02.27

 

*인자 전달방식

(1)값 호출(Call by value)

-기본 자료형의 값을 인자로 전달하는 방식

-값을 복사하여 전달

 

(2)참조 호출(Call by reference)

-메서드 호출시 참조(객체) 자료형을 인자로 전달하는 방식

 e.g. 객체, 배열 전달 (-> 자바에서는 배열도 객체로 생각)

-주소(reference)를 복사하여 전달

-참조변수를 return할 수 있음

 

(3)가변인자(Varibale Arguments)

-JDK 5.0~

-자료형이 일치할 때 전달하고자 하는 값의 갯수를 다르게 지정할 수 있음

-전달되는 데이터는 내부적으로 배열로 인식함 (자료형이 꼭 일치해야하는 이유)

-데이터를 보내지 않는 것도 가능 (객체가 만들어지긴 하지만 방이 없는 빈 배열이 만들어짐)

	public void argTest(int... n) { // n이 배열을 가리키는 배열명으로 전달됨
		for (int i = 0; i < n.length; i++) {
			System.out.println("n["+i+"]:" + n[i]);
		}
	}

 

*메서드 오버로딩(Method Overloading: 중복정의)

-하나의 클래스 내에서 같은 이름을 가지는 메서드가 여러 개 정의되는 것

 (원래는 같은 메서드명이 여러개 있으면 충돌)

-메서드 오버로딩의 조건

  1) 메서드명은 동일해야함

  2) 인자의 타입/개수/배치된 순서가 달라야 함

	public void print(int n) {
		System.out.println("정수 n = " + n);
	}

	public void print(double n) {
		System.out.println("실수 n = " + n);
	}

	public void print(double n, long a) {
		System.out.println("실수 n = " + n + ", 정수 a = " + a);
	}

	public void print(long a, double n) {
		System.out.println("정수 a = " + a + ", 실수 n = " + n);
	}

 

-다른 인자를 받지만 기능이 똑같은 메서드를 정의할 때 사용

  -> 기능이 같을 경우에는 같은 명칭을 부여하는 것이 더 직관적이고 쉽기 때문

-Java API 문서에서도 메서드 오버로딩을 사용하는 경우를 많이 찾아볼 수 있음

  e.g.

 

public class OverloadingMain02 {
	public void getLength(int n) {
		String s = String.valueOf(n); // int -> String
		getLength(s);
	}
	
	public void getLength(float n) {
		String s = String.valueOf(n);
		getLength(s);
	}
	public void getLength(String s) {
		System.out.println(s + "의 길이: " + s.length());
	}
	
	public static void main(String[] args) {
		OverloadingMain02 om = new OverloadingMain02();
		om.getLength("Hello");
		om.getLength(500000); // 500000 -> "500000"
		om.getLength(3.14f); // 3.14 -> "3.14" 
	}

 

-메서드 내부에서 다른 메서드를 호출하면 코드의 중복을 막고 쉽게 메서드오버로딩을 정의할 수 있음

 

*패키지와 import

-객체를 생성할 때 해당 클래스가 위치한 패키지의 경로를 모두 명시해서 생성하는 것이 원칙이나

  같은 패키지에 있으면 패키지명은 생략 가능

kr.s09.object.p1.PackOne p1 = new kr.s09.object.p1.PackOne();
PackOne p2 = new PackOne();    // 패키지 생략

 

-다른 패키지의 클래스를 호출할 때는 패키지를 반드시 명시해야 함

// PackTwo p2 = new PackTwo();    -> 에러!
kr.s09.object.p2.PackTwo p2 = new kr.s09.object.p2.PackTwo();

 

-import문을 사용하면 패키지명을 생략 가능

package kr.s09.object.p1;

// 호출하고자 하는 클래스의 패키지를 등록
import kr.s09.object.p2.PackTwo;

public class PackMain {
	public static void main(String[] args) {
		// kr.s09.object.p2.PackTwo p2 = new kr.s09.object.p2.PackTwo();
		PackTwo p2 = new PackTwo();
	}
}

 

-java.lang 패키지는 기본 패키지이기 때문에 컴파일 시 java.lang.*가 자동적으로 import됨

 e.g. java.lang.String, java.lang.System 은 생략 가능

 

*접근 제한자(Access Modifier)

 

클래스 : public, default 생성자 : public, protected, default, private 멤버 변수, 메서드 : public, protected, default, private

 

-접근 제한자가 붙어있지 않을 시 default

-메서드 안에 있는 변수(지역변수)에는 접근제한자를 붙이지 않음

  -> 이미 메서드에 접근제한자가 붙어있기 때문

 

*선언 위치에 따른 변수의 종류

 

*캡슐화(Encapsulation)

-캡슐화란 객체의 필드, 메서드를 하나로 묶고, 실제 구현 내용을 감추는 것

-주로 필드를 private으로 설정하여 외부에서  직접 접근하지 못하게 하고, public 메서드를 통해 필드에 접근할 수 있게 한다

	private int a;

	public void setA(int n) {
		if (n >= 0) {
			a = n;			
		} else {
			System.out.println("음수는 허용되지 않습니다.");
		}
	}
	public int getA() {
		return a;
	}

 

 

*생성자

-객체가 생성될 때 자동적으로 단 한번 호출되어 필드를 초기화하거나

  객체 생성시 반드시 호출되어야 하는 메소드를 호출하는 역할

 

*생성자의 특징

1) return Type이 전혀 정의되지 않는다.
2) 생성자의 이름이 클래스 명과 같아야 한다.
3) 생성자 내부에서  특정 작업을 수행할 수 있고 데이터를 인자에 전달하여 전달받은 데이터를 활용할 수도 있다.

 

-생성자는 객체 생성시 단 한 번만 실행되고 객체 생성 이후에는 호출이 불가능

 

*생성자 오버로딩

-기본 생성자 하나만을 명시할 수 있는 것이 아니라 다양한 인자를 전달 받아 가공할 수 있는 생성자를 여러개 정의할 수 있음

-생성자가 하나라도 있으면 컴파일러가 자동으로 생성자를 만들지 않기 때문에

  인자가 없는 생성자가 필요한 경우 명시적으로 작성해주어야 함

-메서드 오버로딩처럼 인자의 타입, 갯수, 배치 순서의 다를 경우 다른 생성자로 인식

 

-원래는 리턴 타입이 void라도 return; 이 와야하는데 생략하는 것

-원래 return이 보이면 메서드가 종료되는 것을 의미하는 것

-void형 메서드에서 특정 조건일 때 메서드를 빠져나감 (메서드 종료)

	public void deposit(int amount) {
		if (amount <= 0) {
			System.out.println("0보다 크게 입력해야 합니다.");
			return;
		}
		balance += amount;
		System.out.println("입금이 완료되었습니다.");
	}

-> return을 이용함으로써 else 블럭을 쓸 필요가 없음

반복문을 빠져나가는 것 -> break (void형) 메서드를 빠져나가는 것 -> return

 

*객체형 배열

-배열 안에 객체가 바로 저장되는 것이 아니라 객체의 주소가 저장됨 

  -> 각각의 객체는 메모리에 따로 따로 만들어지고 주소를 통해 객체에 접근

 

-리스트를 공부하게 되면 객체형 배열을 만드는 일이 그렇게 잦지는 않음

 

 

 

2024.02.28

 

*주요 메모리 공간

: static, stack, heap

 

*static 변수

-객체나 배열을 생성하면 heap 공간에 만들어지고 stack에 참조변수를 저장

-static 변수는 static 공간에 만들어짐

-static 공간에 있는 static 변수는 다시 만들지 않고 공유함

-static을 붙이면 객체에 포함되는 것이 아니라 static 영역으로 올라감

-static 변수는 '클래스명.static 변수'로 호출 (같은 클래스 내에서는 클래스명 생략)

 

*static 메서드

-main 메서드도 static이 붙어서 객체에 포함되지 않는 것

-static 메서드에서는 인스턴스 변수 사용 불가 (인스턴스 변수는 객체 생성시 생성되기 때문)

 

*this

-객체 내부에서 객체 자신을 칭하고 싶을 때나, 지역변수와 멤버변수를 구별해야 할 때 사용하는 참조변수

 

-멤버 변수: 클래스 블럭 내에서 정의된 변수

-지역 변수: 메서드, 생성자, 제어문 블럭 내에서 생성된 변수, 해당 블럭이 종료되면 변수는 소멸함

 

*this()

-현재 객체의 생성자

-this()를 이용하여 한 클래스내의 특정 생성자에서 Overloading되어 있는 다른 생성자를 호출할 수 있는 것

-생성자의 첫 행에 정의해야 한다는 것이며 그렇지 않으면 Compile시 오류가 발생

 

*이클립스에서 get(), set() 메서드 자동생성하기

우클릭 -> Source -> Generate getters and setters

 

*클래스의 상속

-상속(inheritance)은 기존 클래스를 확장해서 새로운 클래스를 만드는 기술

// 부모클래스
class Parent {
	int a = 100;
}

// 자식클래스
class Child extends Parent {
	int b = 200;
}

public class ExtensionMain01 {
	public static void main(String[] args) {
		Child ch = new Child();
		System.out.println(ch.a);  // Parent의 a
		System.out.println(ch.b);  // Child의 b
	}
}

 

 

*최상위 클래스 Object

-모든 클래스의 최고 조상

-클래스의 상속은 위에서부터 누적됨

e.g. toString() 메서드는 Object의 메서드

 

*메서드 오버라이딩

-메서드 재정의

-상속관계에서 조상클래스의 메서드를 자손클래스에서 덮어쓰는 것

 

*@Override 어노테이션

-오버라이딩이 제대로 됐는지 안됐는지 검증해줌

@Override
	public String getCar() {
		return "신형 자동차";
	}

 

*super

-현재 객체의 바로 상위인 super클래스(부모클래스)를 참조할 수 있는 참조변수

-super를 이용하면 부모 클래스가 가지고 있는 오버라이딩된 메서드를 호출 가능

	public String getRice() {
		// 부모클래스의 getLunch() 메서드를 호출
		return super.getLunch();
	}

 

-자식 클래스의 생성자를 호출하면 자식 클래스의 생성자의 가장 윗줄에 super() 가 있어서 부모 클래스의 기본생성자를 호출함

  (Object 클래스의 생성자를 호출할 때까지 반복)

// 부모클래스
class People {
	int a = 100;
	
	public People() {
		super(); // 부모클래스 Object의 기본 생성자 호출
	}
}

// 자식클래스
class Student extends People{
	int b = 200;
	
	// 생성자
	public Student() {
		super(); // 부모클래스의 기본 생성자 호출
	}
}

 

 

-부모클래스의 기본생성자가 없고 인자가 있는 생성자만 존재할 때는 명시적으로 부모클래스의 생성자를 호출해줘야 함

// 부모클래스
class People2 {
	int a;
	
	// 기본생성자가 없고 인자가 있는 생성자만 존재할 때
	public People2(int a) {
		this.a = a;
	}
}

// 자식클래스
class Student2 extends People2 {
	public Student2() {
		super(700);
	}
}

 

 

 

2024.02.29

 

*다형성

-참조자료형의 형변환은 부모-자식관계(상속관계)에서만 가능

-참조변수의 자료형으로 호출 범위 제한

 

*자식클래스타입 -> 부모클래스타입으로의 형변환

-업캐스팅. 자동적으로 형변환.

 (자료형만 바뀌는 것이지 같은 객체를 가리키고 있음)

		Parent p = ch;  // 자식클래스타입 -> 부모클래스타입 형변환
		                // 업캐스팅, 자동적으로 형변환
		System.out.println(p.a);
	//	System.out.println(p.b);  에러

 

-참조변수의 타입이 Parent 타입일 때는 전체 객체에서 Parent 영역만 호출이 가능함

-Child 영역은 메모리에 그대로 남아있지만 가려져 있는 것

 -> 참조변수를 Child 타입으로 다시 원상복구할 시에는 다시 호출이 가능해짐

 

*부모클래스타입 -> 자식클래스타입으로의 형변환

-다운캐스팅. 명시적으로 형변환 (강제적으로 호출범위를 늘려줘야함)

		Child ch2 = (Child) p;  // 부모클래스타입 -> 자식클래스타입 형변환
		                        // 다운캐스팅, 명시적으로 형변환
		System.out.println(ch2.b);   // 문제 없음

 

-부모클래스 -> 자식클래스 -> 부모클래스로 참조변수를 형변환했을 때 자식클래스에서 오버라이딩된 메서드는

 재정의된 메서드가 호출됨.

  -> 한번 오버라이딩하면 부모클래스의 메서드를 불러올 수 있는 방법은 super 참조변수를 사용하는 것 뿐

// 부모클래스
class Parent2 {
	public void make() {
		System.out.println("부모클래스의 make");
	}
}

// 자식클래스
class Child2 extends Parent2 {
	//메서드 재정의
	@Override
	public void make() {
		System.out.println("자식클래스의 make");
	}
}

public class PolyMain03 {
	public static void main(String[] args) {
		Child2 ch = new Child2();
		ch.make();
		
		Parent2 p = ch;  // 자식클래스타입 -> 부모클래스타입 형변환
		                 // 업캐스팅, 자동적으로 형변환
		p.make();   // 재정의된 자식클래스의 make()가 호출됨
	}
}

 

*다형성(Polymorphism)

-객체지향에서 다형성이란 '여러 가지 형태를 가질 수 있는 능력'을 의미하며,

 자바에서는 한 타입의 참조변수로 여러 타입의 객체를 참조할 수 있도록 함으로써 다형성을 프로그래밍적으로 구현

-부모클래스타입의 참조변수로 자식클래스의 인스턴스를 참조할 수 있도록 하였음

 

package kr.s18.object.poly;

// 부모클래스
class Product {
	int price;  // 제품 가격
	int bonusPoint; // 제품 구매시 제공하는 보너스 점수

	// 생성자
	public Product(int price) {
		this.price = price;
		bonusPoint = price / 10;
	}

	public String getName() {
		return "상품";
	}
}

class Tv extends Product {
	// 생성자
	public Tv() {
		super(100);
	}

	// Product 타입을 유지한 상태에서 자식클래스에서 이름을 가져오기 위해 재정의 방식 선택
	@Override
	public String getName() {
		return "TV";
	}
}

class Computer extends Product {
	// 생성자
	public Computer() {
		super(200);
	}

	@Override
	public String getName() {
		return "컴퓨터";
	}
}

class Audio extends Product {
public Audio() {
		super(300);
	}

	@Override
	public String getName() {
		return "오디오";
		
	}
}

class Buyer {
	private int money = 1000;  // 구매자 보유 금액
	private int bonusPoint = 0;  // 제품 구매시 누적 보너스 점수

	// 구매하기
	public void buy(Product p) {
		if (money < p.price) {
			System.out.println("잔액이 부족하여 물건을 구매할 수 없습니다.");
			return;
		}
		money -= p.price;
		bonusPoint += p.bonusPoint;

		System.out.println(p.getName() + "을/를 구입했습니다.");
		System.out.println("현재 남은 돈은 " + money + "만원입니다.");
		System.out.println("현재 보너스 점수는 " + bonusPoint + "점입니다.");
	}
}

public class PolyMain04 {
	public static void main(String[] args) {
		// 구매자 생성
		Buyer b = new Buyer();

		// 제품 생성
		Tv tv = new Tv();
		Computer com = new Computer();
		Audio au = new Audio();
		

		// 제품 구매
		b.buy(tv);  // Tv -> Product 업캐스팅. 자동적으로 형변환.
		b.buy(com);  // Com -> Product 업캐스팅. 자동적으로 형변환.
		b.buy(au);
	}
}

-Buyer 객체에서 모든 상품을 인자로 받기 위하여 Product 클래스를 만들어 Tv, 컴퓨터, 오디오 각각의 상품 객체가 Product 클래스를 상속하도록 만든다. 그러면 Buyer 객체의 buy() 메서드의 인자로 들어갈 때에 자동적으로 Product 타입으로 형변환이 된다. 이 때, Product 타입을 유지하면서 각각의 상품에서 name을 가져오려면 Product 객체에 getName() 메서드를 만들고 이를 각각의 상품 객체에서 오버라이딩하면 된다. 자식클래스에서 재정의된 메서드는 참조변수가 다시 부모클래스로 변경되더라도 자식클래스에서 재정의된 상태 그대로 호출되기 때문이다.

 

*instanceof 연산자

-좌측에 지정한 객체가 우측에 지정한 타입을 사용할 수 있는지 검증하는 연산자

		if (p instanceof Child3) {
			Child3 ch2 = (Child3) p;
			System.out.println(ch2);
			System.out.println("-----------------");
		} else {
			System.out.println(p);
			System.out.println("+++++++++++++++++");
		}

-상속 관계에서만 사용 가능

  -> 상속 관계가 있느냐 없느냐를 알아보기 위해 사용하는 것이 아니라, 이미 알고 있는 것을 확인하기 위해 쓰는 것임

 

*상수

-상수: 변수 형태인데 프로그램이 끝날 때까지 바뀌지 않는 것 (변수 + final)

-상수는 멤버 필드에 위치함 (멤버 필드는 변수와 상수로 구성)

	// 멤버 필드
	final int NUM = 10;   // 상수
	public static final int NUMBER = 20;  // static 상수

-상수는 공유의 개념을 가지기 때문에 static 상수를 많이 사용하게 됨

-메서드 안에서 상수를 정의하고 사용하면 지역 상수

 

*final 메서드

-메서드에 final을 적용 시 오버라이딩으로의 확장이 불가능

-상속은 가능하지만 재정의는 불가능

	public final void setVar(int var) {
		this.var = var;
	}

 

*final 클래스

-클래스에 final을 적용 시 더 이상의 상속 확장이 불가능

 

*Object 클래스

-Object.getClass()

public class ObjectMain01 {
	public static void main(String[] args) {
		ObjectMain01 ob = new ObjectMain01();
		System.out.println(ob.getClass()); // 클래스 정보를 가진 객체 반환
		System.out.println(ob.getClass().getName()); // 클래스 정보를 가진 객체에서 클래스명 반환
	}
}

 

-Object.hashCode()

System.out.println(ob.hashCode()); // 10진수의 유니크한 값 반환
System.out.println(Integer.toHexString(ob.hashCode())); // 10진수를 16진수로 변환

-hashcode: 객체를 식별하는 유니크한 값(10진수)

 

-Object.toString()

System.out.println(ob.toString());
System.out.println(ob);

-'getClass().getName()'과 'Integer.toHexString(ob.hashCode())'의 조합값

-toString() 메서드는 참조변수 명만 적고 메서드명을 생략해도 동일하게 동작함

 

-toString() 오버라이딩

class Car {
	private String name;

	public Car(String name) {
		this.name = name;
	}

	// Object의 toString 재정의
	@Override
	public String toString() {
		return name;
	}
}

public class ObjectMain02 {
	public static void main(String[] args) {
		Car c1 = new Car("스포티지");
		System.out.println(c1.toString());
		System.out.println(c1);
	}
}

-toString 메서드는 오버라이딩해서 많이 사용함. 참조값을 쓸 일이 거의 없기 때문.

 

String 클래스

*문자열 생성

1) 명시적으로 객체 생성

  :String s = new String("하늘");

   String s3 = new String("하늘");

  -명시적으로 객체를 생성할 시에는 메모리에 따로 따로 만들어짐

		//명시적으로 문자열 생성
		String str3 = new String("Hello");
		String str4 = new String("Hello");
		
		// 객체 비교
		if (str3 == str4) {
			System.out.println("str3과 str4는 같은 객체");
		} else {
			System.out.println("str3과 str4는 다른 객체");
		} // 결과 : 다른 객체!
		
		// 문자열 비교
		if (str3.equals(str4)) {
			System.out.println("str3과 str4의 내용이 같음");
		} else {
			System.out.println("str3과 str4의 내용이 다름");
		} // 결과 : 같은 내용!

 

2) 암시적으로 객체 생성

  :String s2 = "바다";

   String s4 = "바다";

  -암시적으로 객체를 생성할 시 내용이 같으면 여러 개의 참조변수가 하나의 객체를 공유함

		// 암시적으로 문자열 생성
		String str1 = "abc";
		String str2 = "abc";  // str1, str2가 같은 주소를 공유
		
		// 객체 비교
		if (str1 == str2) {
			System.out.println("str1과 str2는 같은 객체");
		} else {
			System.out.println("str1과 str2는 다른 객체");
		} // 결과: 같은 객체!
		
		// 문자열 비교
		if (str1.equals(str2)) {
			System.out.println("str1과 str2의 내용이 같음");
		} else {
			System.out.println("str1과 str2의 내용이 다름");
		} // 결과: 같은 내용!

 

-equalsIgnoreCase(): 대소문자 구분 없이 문자열 비교

		String str5 = "bus";
		String str6 = "BUS";
		
		// 대소문자 구분하지 않고 문자열 비교
		if (str5.equalsIgnoreCase(str6)) {
			System.out.println("[대소문자 구분없이 비교] str5와 str6의 내용이 같음");
		} else {
			System.out.println("[대소문자 구분없이 비교] str5와 str6의 내용이 다름");
		}

 

-indexOf(): 괄호 안의 값의 인덱스 반환

String s1 = "Kwon Sun Ae";

int index = s1.indexOf('n');
System.out.println("맨 처음 문자 n의 위치: " + index); // 3

		
index = s1.indexOf("Sun");
System.out.println("문자 Sun의 위치: " + index); // 5

-값이 여러 번 등장할 시 가장 앞의 인덱스 반환

-문자열의 경우에는 가장 앞 문자의 인덱스 반환

 

-lastIndexOf(): 괄호 안의 값의 인덱스를 뒤에서부터 찾아서 반환

String s1 = "Kwon Sun Ae";

index = s1.lastIndexOf('n');
System.out.println("마지막 문자 n의 위치: " + index); // 7

 

-charAt(): 괄호 안에 지정된 인덱스의 문자 추출

char c = s1.charAt(index); // index = 7
System.out.println("지정한 인덱스의 문자 추출 : " + c); // n

 

-substring(int i): 괄호 안의 인덱스부터 끝까지 문자열 추출

index = s1.indexOf('S');
String str = s1.substring(index); // index = 5
System.out.println("대문자 S부터 끝까지 문자열 추출: " + str); // Sun Ae

 

-substring(int i, int j): 인덱스 i부터 인덱스 j 전 까지 문자열 추출

str = s1.substring(index, index+3); // 5, 8
System.out.println("인덱스 5부터 인덱스 8 전까지 문자열 추출 : " + str); // Sun

 

-split(): 괄호 안의 구분자를 이용해서 문자열 잘라내기

// 구분자를 이용해서 문자열 잘라내기
String[] array = s1.split(" ");
for (int i = 0; i < array.length; i++) {
	System.out.println(array[i]);
}

// Kwon
// Sun
// Ae

 

-toUpperCase(): 대문자로 변환

-toLowerCase(): 소문자로 변환

-replace(String old, String new): old 문자를 new 문자로 대체

-trim(): 앞뒤 공백 제거

-contains(): 문자열이 괄호 안의 문자열을 포함하는지 검사

-startsWith(): 문자열이 괄호 안의 문자열로 시작하는지를 검사

-endsWith(): 문자열이 괄호 안의 문자열로 끝나는지를 검사

-String.valueOf(): 괄호 안의 인자를 문자열로 변환

 (int 의 문자열 변환은 빈문자열을 더해줌으로써도 실현 가능)

 e.g. msg = a + ""; // a = 100