1. Java란?
1. c++의 장점만을 모아 만든 프로그래밍 언어
2. c++의 문법과 구문 + Small talk의 객체지향
3. 메모리 해제 -> Garbage collector
c에서 메모리 생성: malloc() - 메모리 해제: free()
c++에서 메모리 생성: new - 메모리 해제: delete
--> 포인터를 이용하여 메모리와 할당과 해제를 일일이 해줘야 했음.
--> Garbage collector라는 프로그램에 의해서 사용되지 않는 메모리 자동 해제됨.
Java의 구조
운영체제
JVM(Java Virtual Machine)
Java API(클래스 라이브러리)
Java 언어
-----------
Java 언어를 실행시키는 것은 JVM. JVM이 운영체제와 정보교환을 통해 프로그램 돌아감. 그래서 Java 코드는 운영체제에 상관없이 손상없이 돌아감.
자바의 탄생
가전제품을 제어하기 위해 고안했으나 웹의 등장으로 엄청난 발전을 하고 주류 언어로 급상승하게 되었다.
현재 한국에서는 정부나 기업의 시스템 통합(System Integration) 프로젝트가 대부분 자바로 구현되기 때문에 자바는 기업용 시장에서 두각을 나타내고 있다.
장점
1. 객체지향 언어이다.
- 객체지향 프로그래밍은 프로그램을 유연하고 변경이 용이하게 만들기 때문에 소프트웨어 개발과 보수를 간편하게 하여 대규모 소프트웨어 개발에 많이 사용된다.
2. 하드웨어와 운영체제에 독립적이다.
- 자바는 운영체제가 아닌 JVM(Java Virtual Machine)이라는 가상머신과 통신하고 JVM이 자바프로그램으로부터 전달받은 명령을 해당 운영체제가 이해할 수 있도록 변환하여 전달한다. 그래서 자바프로그램은 어디에서나 실행가능하다.
3. 여러 기술에 표준화된 공개 규격이 있다.
- 1,2번의 장점과 합해져, 기업의 웹 페이지, 국가정보망, 인터넷뱅킹, 기업 내 주요 전산 업무에 이용되는 웹 애플리케이션이나 서버 프로그램을 구축하는데 많이 사용된다.
4. 메모리 관리가 용이하다.
- c,c++에서는 메모리 생성 후 해제를 꼭 해줘야 했으나, 자바는 Garbage Collector라는 프로그램으로 사용되지 않는 메모리는 자동 해제된다.
- 자동 메모리 관리는 다소 비효율적인 면도 있지만, 프로그래머가 보다 프로그래밍에 집중할 수 있게 만든다.
5. 다중 쓰레드를 제공한다.
- 다중 쓰레드란 하나의 프로그램이 동시에 하나 이상의 일을 하는 것을 의미한다. 자바는 사용자가 쓰레드를 편리하게 작성하여 사용할 수 있도록 쓰레드와 관련된 라이브러리 클래스를 제공하고 있고 JVM은 다중 쓰레드를 동시에 처리한다.
단점
1. 느린 속도
- 자바는 하드웨어에 맞게 완전히 컴파일된 상태가 아니고, 실행 시에 해석되기 때문에 속도가 느리다. 그러나 현재 기능이 향상되어 하드웨어를 직접 건드리지 않는 이상 속도문제가 상당히 개선되었다.
2. 자바 프로그램의 시작과 표준 출력
---프로그램의 시작---
class 클래스명{
public static void main(String[] args){
// 코드
}
}
static: 함수에 붙게 되면 함수를 품은 class를 생성하지 않고 호출할 수 있게 함. main을 실행할 때마다 class생성(메모리 발생)하지 않고 바로 호출할 수 있음.
main: virtual machine에서 main만 실행함.
---표준 출력---
java.lang 패키지에 의해 일어남.
java.lang 패키지 안에 있는 클래스를 사용 가능. Object, System, Math, Thread 등등
Object: 자바에서 생성하는 클래스의 최상 클래스.
System: out을 포함한 클래스. 사용방법이 있음. System.out.println("aa");
3. 데이터와 연산자
---상수---
상수는
1. 숫자 상수 (정수형 상수(12,7,100,-11 등), 부동소수점형 상수(3.14, -4.34 등))
2. 문자 상수 ('a', 'b' 등) - 유니코드.
로 나눌 수 있음.
---데이터형---
1. 기본형
|
구분 |
크기 |
값의 범위 |
기본값 |
|
boolean |
1 byte |
true, false |
false |
|
char |
2 byte |
0 ~ 65535 |
null, \u0000,0 |
|
byte |
1 byte |
-128 ~ 127 |
0 |
|
short |
2 byte |
-32,768 ~ 32,767 |
0 |
|
int |
4 byte |
-2,147,483,648 ~ 2,147,483,647 |
0 |
|
long |
8 byte |
-9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807 |
0L |
|
float |
4 byte |
생략 |
0.0f |
boolean: java에선 무조건 true와 false의 값을 가짐. (C에선 0이외의 값:true, 0:false)
2. 참조형 (reference type)
-메모리 주소를 저장하는 데이터형(type)
->클래스, 배열, 인터페이스
-4byte 크기
클래스, 배열, 인터페이스 등이 생성된 직접적으로 접근할 수 있는 변수명(별명)
---변수---
상수를 저장하는 메모리 공간
형태: 데이터형 변수명;
ex) int nVar;
---연산자---
산술 연산, 비교 연산 등에 사용되는 키워드.
4. 반복문과 조건문
---반복문---
for(초기화; 조건식; 증감){
// 코드
}
ex)
for(int i=0; i<5; i++){
System.out.println("java");
}
while(조건식){ //조건식엔 무조건 true, false (1, -1 안됨)
// 코드
}
ex)
int i = 0;
while(i < 3){
System.out.println("java");
i++;
}
do{
// 코드
} while(조건식)
ex)
do{
System.out.println("java");
} while(false);
---선택문---
if, if else, if else if
switch(표현식){ // 표현식은 값에 들어갈 변수.
case 값1: // 값에는 정수형.
break;
case 값2:
break;
default:
break;
}
---break, continue---
break: 가장 가까운 반복문을 빠져나옴.
continue: 맨 끝으로 감.
label 기능.
label이 달린 반복문을 빠져나올 수 있게 함.
ex)
A: while(조건문){
while(조건문){
// 코드
break A; // 맨 위 반복문을 빠져나감.
}
}
5. 배열
배열이란
a. 기본 속성: 같은 변수명 + 같은 데이터형 + 다수의 변수
b. 언어적 특성
-C언어와 C++언어
int nArray[10]; ->일반 변수 -> 변수가 10개임.
-java 언어
int[] nArray; 또는 int nArray[]; -> 참조형 배열변수
nArray = new int[10]; -> 객체
객체 안에 변수와 함수가 있다. 함수는 변수를 바꿔주기 위해 존재. 내부적으로 변수의 값을 변경,저장하기 위한 기능이 있음.
nArray가 객체가 되었다는 얘기는 배열에 관련된 정보를 nArray를 통해 스스로 알 수 있음. c에서는 배열 10개를 알거나 변수에 값을 저장해서 계산했으나 객체를 생성해주기만 하면 몇 개인지 알 수 있다.
---일차원 배열
배열 선언 형식
1. int nArray[];
2. int[] nArray;
->참조형 배열변수.
->2번을 더 선호.
배열 생성
1. 배열변수명 = new 데이터형[개수];
nArray = new int[7];
-> nArray는 int형의 7개의 변수를 다룰 수 있는 객체임.
-> 선언한 후 생성함.
2. 데이터형[] 배열변수 = new 데이터형[개수];
int[] nArray = new int[3];
-> 선언과 동시에 생성함.
실행값:
12345
12345
두 번째 for문에서 nArray.length를 통해 nArray 스스로 길이를 얻을 수 있음을 알 수 있다.
초기화
1. 기본값
char형 -> null int형 -> 0
boolean형 -> false, float형 -> 0.0
2. 선언과 동시에 초기화하는 형식
int[] nArray = {1,2,3};
---이차원 배열
배열 선언 형식
1. 데이터형 배열변수명[];
int nArray[][];
2. 데이터형[][] 배열변수명;
int[][] nArray;
1,2--> 참조형 배열변수
a. 행과 열이 같은 배열 생성
1. 배열변수명 = new 데이터형[행개수][열개수];
nArray = new int[2][2];
2. 데이터형[][] 배열변수 = new 데이터형[행개수][열개수];
int[][] nArray = new int[2][2];
b. 행에 대한 열이 각각 다른 배열 생성
int[][] nArray;
nArray = new int[3][]; -> 행에 대한 정보를 다룸.
nArray[0] = new int[2]; -> 0 열에 대한 정보를 다룸.
nArray[1] = new int[3]; -> 1 열에 대한 정보를 다룸.
nArray[2] = new int[5]; -> 2 열에 대한 정보를 다룸.
초기화
a. 행과 열 단위로 초기화하는 방법으로 C언어와 동일하다.
int[][] nArray = new int[2][2];
nArray[0][0] = 1;
nArray[0][1] = 2;
nArray[1][0] = 3;
nArray[1][1] = 4;
b. 선언과 동시에 초기화
int[][] nArray1 = {{1,2}, {3,4}}; -> 2행2열
int[][] nArray2 = {{1,2}, {3,4,5,6}}; -> 2행4열
6. 클래스 (class)
---클래스란?
struct의 확장체라고 할 수 있음.
struct - 변수의 값만을 저장. 외부의 함수를 이용해 내부의 값을 세팅, 변경.
class - struct의 기능 + 변수, 함수
---클래스 형식
class 클래스명{ // 클래스명의 첫글자는 대문자로 하는 게 관례.
// field, constructor, and
// method declarations
}
---메소드 형식
void SetTitle(String strTitle){
m_strTitle = strTitle;
}
String GetTitle(){
return m_strTitle;
}
->함수와 동일
---객체 생성과 사용
Book JavaBook = new JavaBook(); -> 생성
JavaBook.SetTitle("Java"); -> SetTitle이라는 메소드 사용
JavaBook.m_setTitle = "Java"; -> m_setTitle이라는 변수에 직접 접근하여 사용
---접근 제어자
a. private: 같은 클래스 안에서만 접근 가능
b. public: 전체에서 접근 가능
c. protected: 같은 클래스와 패키지, 그리고 하위 클래스에 접근 가능
d. friendly 또는 생략된 제어자: 같은 클래스와 패키지 안에서만 접근가능
---오버로딩(overloading)
-중복되는 메소드명을 클래스 안에서 정의할 수 있도록 하는 것
-같은 함수명으로 다양한 값을 받아 처리
-함수명 하나만 기억하면 됨
-같은 함수명이 있을 때 구분하는 방법: 매개변수로 구분
---생성자(constructor)
-객체가 생성될 때 한 번 호출되는 메소드
-자동으로 호출되는 메소드
-리턴형이 없고 클래스명과 함수명이 같다
-public
class MyClass{
public MyClass(){
}
public MyClass(int nVar1, int nVar2){
}
}
---this
객체 자신을 참조하는 참조형 클래스변수 또는 키워드
this.멤버변수
this.메소드()
---this()
생성자에서 또 다른 생성자를 호출
생성자 첫 줄에서 호출
public A(){
this(3.14f); -> 아래의 생성자(또 다른 생성자) 호출
m_nVar = 12;
}
public A(float fVar){
m_fVar = fVar;
}
---static
접근제어자 static 데이터형 멤버변수명;
접근제어자 static 리턴형 메소드명(...);
1. static 멤버변수와 메소드의 공통점
객체가 생성되기 이전에 멤버변수와 메소드 사용가능
2. static 멤버변수의 특징
멤버변수는 생성되는 모든 객체에서 전역변수로 사용가능 -> 100개의 객체를 생성했어도 static으로 선언한 멤버변수는 100개의 객체에서 공용으로 사용가능함.
3. static 멤버변수와 메소드의 사용규칙
a. static 메소드 안에서 멤버 변수를 사용할 때 멤버 변수는 항상 static으로 선언된 것만을 사용할 수 있다.
b. static 메소드는 같은 클래스 안의 static 메소드만을 호출할 수 있다.
c. static 메소드 안에서는 this를 사용할 수 없다.
d. static 메소드는 오버라이딩을 할 수 없다.
---package
자주 사용되는 클래스를 모아 놓은 폴더
패키지명은 소문자를 사용하는 것이 관례
---import
클래스를 포함하고자 할 경우 사용
7. 상속(Inheritance)
상속이란?
객체와 객체를 연관시키고 계층구조를 만들어 코드를 재사용 -> 상위 클래스의 기능을 하위 클래스에서 사용가능함.
Object 객체는 최상위 클래스.
---형식
1. 상속 형식
class 클래스명 extends 상속클래스명{
└>자식 클래스 └>부모 클래스
}
상위 클래스의 접근지정자에 따라 접근이 제한
---멤버 상속
1. 상위 클래스에 지정된 private 멤버는 해당 클래스에서만 사용할 수 있고 하위 클래스에서는 사용할 수 없다.
2. 상위 클래스에 지정된 public 멤버는 해당 클래스뿐만 아니라 하위 클래스에서도 사용할 수 있으며 외부에서도 언제든지 사용할 수 있다.
3. protected의 상위 멤버는 같은 패키지일 때는 public 멤버처럼 사용되지만 다른 패키지인 경우는 상위 멤버를 하위 클래스 안에서만 사용할 뿐 외부 사용은 할 수 없다.
4. 상위 클래스에서 default 멤버들은 같은 패키지 안에 있을 때는 public 멤버처럼 사용할 수 있지만 패키지가 다른 경우는 하위 클래스에서 상위 클래스 default 멤버를 사용할 수 없고 외부에서도 사용할 수 없다.
---오버라이딩
부모 클래스의 메소드를 자식 클래스에서 다시 재정의하는 것
1. 함수명이 같아야함
2. 함수의 매개변수가 같아야함
3. 리턴형이 같아야함
---final
상속에서 주로 사용되는 키워드. final이 어디에 붙느냐에 따라 기능이 다름. 기존의 기능을 사용하지 못하게 하는 늬앙스가 있음.
1. final이 클래스와 메소드에 붙는 경우
- 상속과 오버라이딩 불가
- 클래스와 메소드의 맨 앞쪽에 위치
2. final이 변수에 붙는 경우
- 변수의 값이 고정됨.
---상속관계에서 생성자의 호출순서
1. 상위 클래스 생성자에서부터 하위 클래스 생성자 호출
public class Main {
public static void main(String[] args) {
C Test = new C();
}
}
class A{
public A() {System.out.println("constructor of the A class");}
}
class B extends A{
public B() {System.out.println("constructor of the B class");}
}
class C extends B{
public C() {System.out.println("constructor of the C class");}
}
-> 결과값:
constructor of the A class
constructor of the B class
constructor of the C class
2. 생성자에 매개변수가 있는 경우 자동호출 안됨 -> super 키워드 사용
---super
하위 클래스에서 상위 클래스를 참조하여 접근할 때 사용
1. 형식
super.멤버 변수명
super.메소드명(매개변수)
2. 사용
- 하위 클래스에서 상위 클래스의 메소드나 변수를 호출할 때 사용
public class Main {
public static void main(String[] args) {
B Test = new B();
Test.print();
}
}
class A{
public void print() {System.out.println("A class");}
}
class B extends A{
public void print(){
super.print();
System.out.println("B class");
}
}
->결과값:
A class
B class
- 하위 클래스에서 상위 클래스의 생성자를 호출할 때 super(매개변수) 또는 super()와 같이 사용
---참조 변수를 이용한 형 변환과 호출
- 캐스트 연산자 사용 ( )
- 형 변환의 규칙
1. 하위 클래스에서 상위 클래스로 형 변환할 수 있으며 접근지정자에 따라 접근이 결정된다.
B B_Test = new C();
-> 최하위 객체인 C를 생성하고, B클래스를 참조할 수 있게 됨.
2. 생성된 하위 클래스에서 상위 클래스 형 변환을 통해 하위 클래스의 멤버에 접근할 수 없다.
C C_Test = new C();
A A_Ref = C_Test;
A_Ref.PrintC(); -> 접근불가 에러.
A_Ref.PrintA(); -> Ok
3. 상위 클래스의 메소드가 하위 클래스에 오버라이딩(재정의)된 경우에 상위 클래스 참조변수에서 오버라이딩된 메소드를 호출하면 하위 클래스의 메소드가 실행
C C_Test = new C();
A A_Test = C_Test;
A_Test.Print();
-> 결과값: class C
Print 메소드 오버라이딩 되어있음.
8. 추상 클래스(abstract class)
추상 클래스란?
- 하위에서 구현할 메소드의 원형을 사진 상위 클래스이다.
- 상위 클래스로만 존재
- 자체를 객체로 생성할 수 없다.
자동차에 비유하자면 추상 클래스는 자동차의 틀. 어디에 뭐를 넣어라 하는 명세서같은 느낌.
---형식
abstract class 클래스명{
일반 멤버 변수;
메소드들;
생성자;
abstract 반환형 메소드명();
}
- extends 키워드를 이용하여 추상 클래스를 상속
- 추상 메소드를 하위에서 모두 구현할 필요 없다.
9. 인터페이스 (interface)
추상 클래스와의 비교.
공통점
1. 상위 클래스로만 사용 가능
2. 하위에서 구현할 함수의 원형을 선언
차이점
1. 추상 클래스 = 일반 멤버 + 추상 메소드
인터페이스 = 추상 메소드 + 상수
2. 추상 클래스는 추상 메소드를 일부 구현 가능
인터페이스는 모두 구현해야 함 (강제적)
3. 다중 상속 가능
4. 인터페이스가 인터페이스를 다중 상속
형식
-기본 형식
interface 인터페이스명{
public static final 데이터형 변수명 = 값;
public abstract 리턴형 메소드명 (매개변수 0...n);
}
->간소화:
interface 인터페이스명{
데이터형 변수명 = 값;
리턴형 메소드명 (매개변수 0...n);
}
인터페이스의 상속 형식
interface 인터페이스명{
데이터형 변수명 = 값;
리턴형 메소드명 (매개변수 0...n);
}
class 클래스명 implements 인터페이스명{
}
*인터페이스명 관례: ~able
인터페이스의 상속
1. 다중 상속
interface A{
void PrintA();
}
interface B{
void PrintB();
}
interface C extends A,B { // A,B 다중 상속
void PrintC();
}
2. 클래스 상속과 인터페이스 다중 상속
interface A{
void PrintA();
}
interface B{
void PrintB();
}
interface C{
void PrintC() { ... };
}
class D extends C implements A,B{
}
10. 예외 처리
- 예외 처리는 프로그램 실행 도중에 발생되는 오류를 처리하기 위한 부분이다.
- 에러: 수정할 수 없는 것. 다시 코딩해야함.
- 오류: 수정 가능, 알려주는 역할
- 키워드: try, catch, finally, throws
기본 형식
try {
예외가 발생할 수 있는 문장
} catch (Exception형 e) {
예외가 발생했을 때 처리하는 문장
}
자주 사용되는 Exception형 클래스
ArithmeticException - 0으로 나눌 때 발생
NegativeArraySizeException - 배열의 크기가 음수일 때 발생
NullPointerException - 객체를 생성하기 전에 사용할 때 발생
ArrayIndexOutOfBoundsException - 배열의 인덱스가 범위를 벗어났을 때 발생
finally
try ~ catch문의 예외처리와 상관없이 항상 실행해야 하는 문장이 있는 경우에 사용
형식
try{
} catch(Exception e){
} finally {
예외처리와 상관없이 항상 실행해야 하는 문장
}
throws
모든 예외 처리를 try ~ catch 안의 괄호에 넣어 처리하기에는 무리가 있다.
-> JVM 또는 예외 처리 클래스를 지정
형식
반환형 메소드() throws Exception{
}
-> JVM에서 처리함.
11. 내부 클래스와 익명 클래스
---내부 클래스 (inner class)
클래스 안에 클래스를 정의한 것
하나의 클래스 안에 하나의 클래스를 선언했기 때문에 위의 그림과 같이 포함구조를 가짐.
외부 클래스 안에서 정의된 내부 클래스는 멤버에 해당됨.
내부 클래스는 외부 클래스의 모든 자원 사용 가능
형식
class 클래스명
{
class 내부클래스명
{
//멤버 변수, 메소드, 생성자
}
}
특징
1. new로 생성
내부 클래스도 객체로 생성해야하기 때문에 new로 생성함.
2. 내부 클래스는 외부 클래스의 모든 자원 사용가능
내부 클래스는 외부 클래스의 멤버이기 때문에
3. 외부 클래스를 통해 내부 클래스 사용
외부 클래스가 있어야 내부 클래스를 사용할 수 있음.
4. 선언에 따라 인스턴스 내부 클래스, 정적 내부 클래스, 지역 내부 클래스로 나눌 수 있다.
선언되는 위치에 따라 나눌 수 있음.
사용 방법
1. 외부 클래스에서 new를 통해 내부 클래스를 생성하고 메소드를 호출하는 예
실행값 : Outclass nVar1 : 3
2. 외부에서 내부 클래스를 생성하여 호출하는 예 -> 드물게 사용
실행값 : Outclass nVar1 : 3
-> 객체라는 것 자체가 캡슐화이고 객체 내에서 모든 것을 처리해야 하는데, 객체를 외부로 노출시키고 다른 프로그램에 읽게 해야 하는데 이것은 좀 어려움. 그래서 드물게 사용
3. 정적 내부 클래스의 사용 예 (static)
객체를 생성하지 않더라도 메모리에 메소드들이 존재하기 때문에 사용 가능.
실행값: static inner class
실행값:
static inner class
out class static nVar1: 3
4. 외부 클래스 메소드에서 내부 클래스를 사용하는 예 (지역 클래스)
->지역 클래스
실행값:
static inner class
out class static nVar1: 3
실행값: OutClass nVar: 3
---익명 클래스 (anonymous class)
개념
1. 클래스명이 없는 클래스를 말함
일반 내부 클래스: 외부클래스명$내부클래스명.class로 저장
익명 클래스: 외부클래스명$1.class로 파일로 존재
2. 선언과 생성이 동시에 이뤄진다.
3. 일회성. 재활용이 안됨.
4. 안드로이드 프로그래밍에서 익명클래스 형식을 많이 사용한다.
형식
클래스명 클래스변수 = new 클래스명(){
멤버 변수와 메소드들 선언
}
인터페이스 인터페이스변수 = new 인터페이스명(){
변수와 메소드들 선언
}
사용 예
1. 인터페이스를 상속한 클래스 사용의 일반적인 형태
2. 인터페이스를 상속한 익명 클래스를 이용 형식
실행값:
HiGoodAnonymous interface
Anonymous Class
Anonymous Class
Anonymous Interface
3. 익명 클래스를 메소드의 매개변수로 사용하는 예 -> 좀 더 자주 사용
실행값: HiGood!
12. 유용한 클래스들
기존에 작성된 클래스를 가져오는 것. 이미 작성되어 있는 것을 잘 사용하는 것도 객체지향의 재사용성에 해당됨.
Wrapper 클래스
-역할
기본 데이터형을 객체로 다룰 수 있도록 해준다.
기본 데이터형 + 메소드
-> Integer클래스를 사용해보자.
- 역할
int형 값을 포장하는 클래스
- 상속도
java.lang.Object
java.lang.Number
java.lang.Integer
-Integer 메소드
int intValue() -> 현재 객체의 값을 int 형으로 반환
String toString() -> 현재 객체의 값을 string값으로 반환
static int parseInt(String s) -> 문자열을 int형으로 반환
static String toString(int i) -> int형 값을 String 객체로 반환
static Integer valueOf(String s) -> 문자열을 Integer 객체로 반환
실행값:
정수값 : 123
문자열 : 123
정수값 : 300
문자열 : 300
Integer에 저장된 정수값 : 100
---wrapper 클래스의 오토박싱(autoboxing)
-역할
1. wrapper 객체와 값 사이의 변환을 자동으로 처리해 주는 것
2. 기존 wrapper 클래스의 메소드를 간략하게 사용할 수 있게 해준다.
-사용법
실행값 :
autoboxing : 12
합 : 15
++ autoboxing 13
return : 23
---String 클래스 StringBuffer 클래스
String클래스는 데이터형 같이 많이 사용해 왔음.
StringBuffer는 메모리를 가지고 있어 문자에 대한 메모리를 줄였다 늘렸다 하지 않을까 하는 생각 가능
-공통점
문자열을 다루는 객체
-차이점
String 클래스 -> 고정 문자열
그 문자열을 할당했으면 중간에 빼고 수정하는 것이 아닌 그대로 사용하는 것.
String을 이용해서 유동 문자열을 만들 수 있지만 저효율.
StringBuffer 클래스 -> 유동 문자열
메모리를 늘리고 줄일 수 있어 수정가능함.
-String 클래스
1. 고정 문자열을 다룰 때 효율적.
2. 상속도
java.lang.Object
java.lang.String
3. 메소드 - 63가지가 있다.
자주 사용되는 메소드
char charAt(int index) -> 인덱스의 문자르 반환
String concat(Sting str) -> 문자열을 연결 --> 비효율적임.
boolean isEmpty() -> 문자열 체크, 문자열의 길이가 0이면 true
int length() -> 문자열 길이를 반환
String toLowerCase() -> 문자열을 소문자로 변환하여 반환
String toUpperCase() -> 문자열을 대문자로 변환하여 반환
String toString() -> 문자열 반환
boolean equals(Object anObject) -> 문자열 비교, 같으면 true 다르면 false
static String valueOf(char[] data) -> 배열을 문자열로 만들어 String 반환
static String valueOf(float f) -> float형 값을 String으로 반환
static String valueOf(int i) -> int형 값을 String으로 반환
static String valueOf(Object obj) -> Object 형을 String으로 반환
String 메소드 사용 예
1. 문자열을 설정하는 방법
-생성자를 통해서
-대입 연산자를 통한 직접 지정
실행값:
abcdefg
hijklmn
2. 문자열 연결
-새로이 String 객체 생성하여 연결
-concat() 또는 + 연산자 사용
실행값:
abcdefghijklmn
abcdefg12345
abcdefghijklmn
3. 기본형 값을 문자열로 변환 -> 많이 사용
-valueOf()
public static String valueOf(char c)
public static String valueOf(int i)
public static String valueOf(long l)
public static String valueOf(float f)
public static String valueOf(double d)
-StringBuffer 클래스
메모리이기 때문에 생성할 때 크기 지정 가능.
1. 역할
유동 문자열을 다룰 때 효율적.
충분한 버퍼 크기 설정
2. 상속도
java.lang.Object
java.lang.StringBuffer
3. 생성자
StringBuffer() -> 기본
StringBuffer(CharSequence seq)
StringBuffer(int capacity) -> 용량 지정해서 생성
StringBuffer(String str) -> String 객체를 넣어 생성
4. 메소드
자주 사용되는 메소드
StringBuffer append(String str) -> 문자열을 끝에 추가한다.
StringBuffer append(StringBuffer sb) -> 문자열을 끝에 추가한다.
int length() -> 문자열의 길이를 반환한다.
StringBuffer insert(int offset, String str) -> offset번째에 문자열을 삽입한다.
StringBuffer delete(int start, int end) -> start번째부터 end-1번째까지 문자열 삭제.
StringBuffer 사용 예
1. StringBuffer 객체 생성과 문자열을 추가하는 예제
실행값:
abcdefghijk 문자열 길이 : 11
abcdefghijklmn 문자열 길이 : 14
*Buffer의 길이를 100이나 준 이유: Buffer가 부족하면 가변적으로 늘어나긴 하지만 넉넉하게 주는 것이 더 좋음.
2. StringBuffer 객체의 삽입, 삭제 메소드를 이용하여 파일명을 변경하는 예제
*delete를 사용할 때 주의할 점: start에서부터 end-1까지 삭제
실행값:
test.txt
success.txt
---Arrays 클래스
-배열을 다루는 클래스
-정렬, 검색, 특정한 값으로 설정, 비교, 문자열 반환
문자열 또는 배열을 다룰 때 비교, 검색이 필요한데 이와 같은 클래스를 사용하는 것이 안정적이고 범용적인 코딩을 할 수 있음.
-java.util.* 포함 -> import 해야함.
1.상속도
java.lang.Object
java.util.Arrays
2. 주요 메소드
전부 static 메소드이다. -> 이 객체를 생성하지 않아도 배열에 대해 여러 가지를 다룰 수 있다. 귀찮은 일 줄일 수 있음.
static int binarySearch(int[] a, int key)
a배열에서 키에 해당하는 인덱스를 찾음
static boolean equals(int[] a, int[] a2)
배열과 배열이 같은지
static void sort(int[] a)
소트해줌,.
static void sort(int[] a, int fromIndex, int toIndex)
어디서부터 어디까지 소트할 것인가
static String toString(int[] a)
배열에 있는 정수의 값을 문자열로 변환하여 출력
static void fill(int[] a, int fromIndex, int toIndex, int val)
어디서부터 어디까지 val값으로 배열을 채운다.
사용예 1. int형 배열을 정렬과 검색, 치환하는 예제
실행값:
정렬전 :[1,4,7,2,6,3,5]
정렬후 :[1,2,3,4,5,6,7]
-8
4
치환결과 :[1,12,12,4,5,6,7]
13번째가 없기 때문에 음수를 반환.
5번째의 인덱스는 4이기 때문에 4를 반환
13. 컬렉션 클래스
컬렉션 = 컨테이너. 컨테이너 화물 안에다 물건을 실을 수 있는 느낌.
단일 구조 안에서 다수의 데이터를 그룹화하는 개체 --구현--> 컬렉션 클래스
모든 데이터를 품어서 다룰 수 있게 하는 것이 컬렉션 클래스
Vector 클래스, ArrayList 클래스, LinkedList 클래스가 있음.
컬렉션 프레임워크
-다수의 데이터를 다루기 위한 통합 구조
-기초 -> Collection 인터페이스
컬렉션 프레임워크를 구성하기 위한 것은 코드로 나타내야 하는데 그 코드가 Collection 인터페이스를 근간하고 있다.
---제네릭스(generics)
제네릭스
-컬렉션 클래스에 저장할 형(type)을 지정하고 데이터를 읽을 때 지정된 형으로 데이터를 입력 받게 하는 형식
타입을 지정해주면 따로 형변환을 통해서 변환할 필요없이 그대로 가져오면 됨.
-형식
컬렉션 클래스<type> 클래스 변수 = new 컬렉션 클래스();
-제네릭스 장점
1. 컬렉션 클래스로부터 데이터를 읽을 때 형변환 없이 읽을 수 있다.
2. 데이터 형이 다를 경우 error 발생.
-> 코드의 안정화
---Vector class
-역할
1. 기존 배열의 단점을 보완하기 위한 클래스
기존 배열의 수정을 위해 메소드가 필요한데 메소드가 없는 것을 보완하기 위함.
2. 유동적인 데이터 저장
3. 배열 + 메소드
4. 기본형은 wrapper 클래스로 변환하여 저장
-상속도
java.lang.Object
java.util.AbstractCollection<E>
java.util.AbstractList<E>
java.util.Vector<E>
-생성자
Vector() -> 기본 생성자
Vector(int initialCapacity) -> 벡터의 크기를 설정하는 생성자
Vector(int initialCapacity, int capacityIncrement) -> 벡터의 크기와 메모리가 부족할 때 capacityIncrement만큼 증가하도록 설정하는 생성자
-메소드 -> java API Document 참고
자주 사용되는 것들
void addElement(E obj) -> obj 객체를 벡터의 마지막에 추가
boolean add(E e) -> obj 객체를 벡터의 마지막에 추가
E elementAt(int index) -> index 위치의 객체를 반환
E get(int index) -> index 위치의 객체를 반환
E firstElement() -> 첫 번째 객체를 반환
E lastElement() -> 마지막 객체를 반환
void insertElementAt(E obj, int index) -> index 위치에 객체를 삽입
void add(int index, E element) -> index 위치에 객체를 삽입
void removeAllElements() -> Vector에 저장된 모든 객체를 삭제
void removeElementAt(int index) -> index 위치의 객체를 삭제
int size() -> Vector에 저장된 객체 개수를 리턴
String toString() -> Vector의 각 요소를 문자열로 리턴
int indexOf(Object o) -> 첫 번째 찾은 요소 o 객체의 위치를 반환
void setElementAt(E obj, int index) -> index에 obj객체로 설정
E set(int index, E element) -> index에 obj객체로 설정
Vector 예제
-기본 데이터형 -> wrapper 클래스로 변환
실행값:
[3, 3.14, java, 하이!]
java
3
저장된 객체 개수 : 4
실행값:
[3, 3.14, java, 하이!]
java
3
저장된 객체 개수 : 4
[java, programming, android, hope]
android
hope
-> generics를 이용하면 타입을 통일시킬 수 있음.
---ArrayList class
-역할
1. Vector 클래스의 업그레이드 된 클래스
2. Vector 보다는 ArrayList 사용
3. 유동적인 데이터 저장
4. 배열 +메소드
5. 기본형은 그대로 사용 가능하지만 제네릭스 사용
기본형은 원래 wrapper 클래스를 사용해서 변환했지만 ArrayList는 기본형을 그대로 사용가능. 그래도 제네릭스를 사용하는 것이 좋음.
-생성자
ArrayList() -> 기본 생성자
ArrayList(Collection c) -> 컬렉션 요소를 포함하는 생성자
ArrayListint initialCapacity) -> 초기 용량을 지정하는 생성자
-메소드
ArrayList는 26개 메소드
boolean add(E e) -> obj 객체를 리스트의 마지막에 추가
void add(int index, E element) -> index 위치의 객체를 삽입
void clear() -> 리스트 안의 모든 요소를 삭제
E get(int index) -> index의 객체를 반환
E remove(int index) -> index 위치의 객체를 삭제
E set(int index, E element) -> index 위치에 element객체를 설정
int size() -> 리스트 안에 있는 개체의 개수를 반환
int indexOf(Object o) -> 리스트 안에서 첫 번째 찾은 요소 o 객체의 위치를 반환
-ArrayList 예제
기본형 데이터를 다루는 부분과 Collections클래스로 정렬하는 예제
실행값:
개수: 7
리스트: [7, 3, 5, 1, 2, 4, 6]
sort된 List의 리스트: [1, 2, 3, 4, 5, 6, 7]
List1의 리스트: [1, 2, 3, 4, 5, 6, 11]
3
개수: 0
[java, programming, now, hope]
[java, programming, android, hope]
---LinkedList 클래스
-개요
데이터의 추가, 삭제, 삽입이 자주 발생하는 데이터를 다루기 위한 자료구조 클래스.
메모리와 메모리를 서로 연결 한다던가 어디서부터 l작할 것인지 지정하서 추가,삽입 등을 원활하게 해준다. 삽입, 추가, 삭제가 자주 발생하면 Vector나 ArrayList보다 LinkedList를 쓰는 것이 좋음. Index로 검색해서 바로 가져와서 더 효율적이다.
-상속도
java.lang.Object
java.util.AbstractCollection<E>
java.util.AbstractList<E>
java.util.AbstractSequentialList<E>
java.util.LinkedList<E>
-메소드
boolean add(E e) -> 리스트 끝에 객체 추가
void add(int index, E element) -> index 위치의 객체를 삽입
void addFirst(E e) -> 리스트 처음에 객체 추가
void addLast(E e) -> 리스트의 마지막에 객체 추가
void clear() -> 리스트의 요소를 삭제
E get(int index) -> index 위치의 객체를 반환
E getFirst() -> 리스트의 처음 객체를 반환
E getLast() -> 리스트의 마지막 객체를 반환
E remove(int index) -> index 위치의 요소를 삭제
E removeFirst() -> 리스트의 처음 요소를 삭제
E removeLast() -> 리스트의 마지막 요소를 삭제
E set(int index, E element) -> index 위치에 element 객체를 설정
int size() -> 리스트 안에 있는 요소 개수 반환
int indexOf(Object o) -> 리스트 안에서 첫 번째 요소 o 객체의 위치를 반환
-LinkedList 예제
1. 기본형 데이터를 저장하는 LinkedList와 제네릭스가 설정된 LinkedList를 비교하는 예제
실행값:
[7, 3, 5, 1, 2, 4, 6]
처음 노드: 7
끝 노드: 6
개수: 7
[7, 3, 5, 2, 4, 6]
[7, 3, 5, 12, 4, 6]
sort : [3, 4, 5, 6, 7, 12]
개수: 0
2. 사용자가 정의한 객체를 저장하고 검색하며 삽입과 삭제를 하는 예제
실행값:
14. GUI와 AWT 스리고 스윙(swing)
GUI와 AWT, 스윙의 개념
-GUI (Graphical User Interface)
그래픽 환경, 모든 운영체제의 기본 환경. 버튼, 이미지, 메뉴 등 제공
-AWT (Abstract Windowing Toolkit)
자바초기 GUI 프로그래밍 도구. 운영체제의 리소스 사용
-스윙(swing) -> 많이 다룸.
순수 자바 컴포넌트 패키지. 자체 리소스 사용, Jxxxx 클래스로 제공
운영체제로부터 독립되어 있음. 운영체제 바뀌어도 그래도 사용가능.
---컨테이너와 컴포넌트
컨테이너: 내용물을 포함하는 바구니같은 느낌
컴포넌트: 버튼, 체크박스, 리스트같은 프로그램에서 사용자의 조작을 받거나 출력을 해주기 위해 여러 가지 컨트롤들을 일컫는 말.
-개념
1. 컨테이너 (Container)
컴포넌트를 포함하는 클래스
AWT: Frame, Panel, Dialog, Window, Applet
스윙: JFrame, JPanel, JDialog, JWindow, JApplet
2. 컴포넌트 (Component)
버튼, 이미지, 리스트 등
컴포넌트는 반드시 컴테이너에 포함됨
---스윙을 활용한 자바 프로그래밍
-스윙을 위한 기본 패키지 포함문
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
-스윙 프로그램 순서
-1단계 : 프레임 생성
JFrame = Frame + 메뉴 + 컨텐트 팬(컨테이너 클래스)
--> 컴포넌트가 연결
1. JFrame 객체를 생성하여 프레임을 생성하는 소스
실행값:
2. JFrame을 상속하여 프레임을 생성하는 소스
실행값:
-2단계 : 컴포넌트 연결
컨텐트 팬에 컴포넌트 추가해서 연결.
JDK 1.5부터는 JFrame에 직접 추가
레이아웃 관리자 (FlowLayout, BorderLayout, GridLayout, CardLayout)
우리가 생성하는 프레임에는 컴포넌트를 나열할 수 있는 형태가 지정되어 있음. 그 방법을 이용할 수도 있고 없어도 위치나 좌표로 직접적으로 넣어줄 수 있음. 기본형으로 swing에서 제공해주는 나열 형태를 할 수 있도록 하는 클래스.
-예제
실행값: 사지방 한계로 결과 x
-자바 프로그램 종료
System.exit(0)
-스윙 프로그램 종료
닫기 버튼
setDefaultCloseOperation(Jframe.EXIT_ON_CLOSE);
-> 닫기 버튼을 누르면 창이 종료된다.
-3단계 : 이벤트 처리
버튼을 눌렀으면 누른거에 대한 메시지가 발생되고 그 메시지에 해당되는 메them가 호출.
이벤트 처리 -> 리스너(listener)
리스너의 실체 -> 인터페이스 (이벤트 처리를 위한 메소드 정의)
인터페이스를 상속하면 리스너를 사용가능함. 리스너 자체를 익명 클래스를 통해 사용가능함.
---레이아웃 관리자
개념
-컨테이너에 컴포넌트를 위치시키는 방법
-> 레이아웃 관리자
-기본 레이아웃 관리자 : setLayout() 메소드
|
컨테이너 |
기본 레이아웃 관리자 |
|
Window, JWindow |
BorderLayout |
|
Frame, JFrame |
BorderLayout |
|
Dialog, JDialog |
BorderLayout |
|
Panel, JPanel |
FlowLayout |
|
Applet, JApplet |
FlowLayout |
setLayout(null) -> 기본 레이아웃 관리자로 안하고 내가 원하는 형태로 지정한다.
1. BorderLayout 관리자
컨테이너를 5개의 영역(동,서,남,북,중앙)으로 분할하여 컴포넌트를 배치
|
BorderLayout.NORTH |
||
|
BorderLayout.WEST |
BorderLayout.CENTER |
BorderLayout.EAST |
|
BorderLayout.SOUTH |
||
분할 영역 설정 코드
setLayout(new BorderLayout());
add(new Button("North"), BorderLayout.NORTH);
add(new Button("South"), BorderLayout.SOUTH);
add(new Button("East"), BorderLayout.EAST);
add(new Button("West"), BorderLayout.WEST);
add(new Button("Center"), BorderLayout.CENTER);
-컴포넌트의 수직과 수평 간격 설정
BorderLayout(int hgap, int vgap)
void setHgap(int hgap)
void setVgap(int vgap)
2. GridLayout 관리자
컨테이너 공간을 격자 모양으로 나누는 관리자
setLayout(new GridLayout(3,2));
add(new Button("1"));
add(new Button("2"));
add(new Button("3"));
add(new Button("4"));
add(new Button("5"));
add(new Button("6"));
-컴포넌트의 수직과 수평 간격 설정
GridLayout(int rows, int cols)
GridLayout(int rows, int cols, int hgap, int vgap)
void setHgap(int hgap)
void setRows(int rows)
void setVgap(int vgap)
3. FlowLayout 관리자
컴포넌트를 왼쪽에서부터 오른쪽으로 순차적으로 위치시키는 관리자
FlowLayout(int align)
FlowLayout(in align, int hgap, int vgap)
void setHgap(int hgap)
void setVgap(int vgap)
4. CardLayout 관리자
컴포넌트가 겹쳐서 나열되는 레이아웃 관리자
CardLayout(int hgap, int vgap)
void setHgap(int hgap)
void setVgap(int vgap)
5. 레이아웃 관리자 없이 컴포넌트 설정하기
-기존 레이아웃 제거
setLayout(null);
15. 이벤트 처리
개념적인 내용에 집중해야함. 실제로 처리되는 것이 15강 내용임.
-용어
이벤트 소스 : 이벤트를 발생시킨 컴포넌트 - JButton, JList, JTextField 등
컨테이너에 들어가는 부품이라고 생각하면 댐.
이벤트 객체 : 이벤트 소스에 대한 모든 정보를 가지는 객체 - ActionEvent, ItemEvent 등
이벤트 발생했는데 이 이벤트가 어떤 객체에 어떤 정보가 들어있는지 알 수가 없는데 자바는 이를 이벤트 객체라는 것으로 제공해줌. 버튼이 눌렸다, 안눌렸다, 어떤 버튼이 있다 등
이벤트 리스너 : 이벤트에 따라 호출될 메소드 인터페이스 - ActionListener, ItemListener 등
인터페이스는 메소드를 구현해야 하는데 이 메소드에서 매개변수는 이벤트 객체임. 이벤트 객체를 넘겨받고 객체 안에 있는 정보를 읽음. -> 이벤트 처리가 됨.
-이벤트 관계
-이벤트 처리를 위한 import문
import java.awt.event.*;
import javax.swing.event.*;
---이벤트 객체
이벤트를 발생한 컴포넌트의 정보를 가진
이벤트 종류, 이벤트 소스, 좌표, 상태 등
---이벤트 소스에 대한 이벤트 객체
|
이벤트 객체 |
이벤트 소스 (컴포넌트) |
|
ActionEvent |
JButton, JList, JTextField, JMenuItem |
|
ItemEvent |
JCheckBox, JCheckBoxMenuItem, JList |
|
KeyEvent |
Component |
|
MouseEvent |
Component |
|
FocusEvent |
Component |
|
TextEvent |
TextField, TextArea |
|
WindowEvent |
Window |
|
AdjustmentEvent |
JScrollBar |
|
componentEvent |
Component |
-이벤트 객체의 구분
---이벤트 리스터 (event listener)
개념
-이벤트 리스터의 실체 = 인터페이스. 메소드 정의되어 있고 이 메소드를 상속받아 사용.
-역할 = 이벤트 처리. 실제적인 처리.
-이벤트 리스너를 사용하는 방법
1. 인터페이스를 상속한 클래스 사용
2. 익명 클래스로 구현
-이벤트 리스너 인터페이스
|
이벤트 리스너 인터페이스 |
메소드 |
|
ActionListener |
void actionPerformed(ActionEvent e) |
|
ItemListener |
void itemStateChanged(ItemEvent e) |
|
MouseListener |
void mouseClicked(MouseEvent e) void mouseEntered(MouseEvent e) void mouseExited(MouseEvent e) void mousePressed(MouseEvent e) void mouseReleased(MouseEvent e) |
-이벤트 리스너 만들기
1. 이벤트 리스너를 상속한 내부 클래스 구현
내부 클래스 또는 익명 클래스
-버튼의 제목을 클릭할 때마다 변경하는 예제 비교
1. 내부 클래스로 구현
2. 익명 클래스로 구현 -> 일회적으로 사용할 때 많이 사용
내부 클래스로 사용하려면 클래스 이름 나열해야하고 인터페이스 상속받아서 구현해야하는 번거러움이 있지만 익명 클래스는 바로 인터페이스에 대한 메소드를 바로 선언을 해서 이벤트 처리를 할 수 있음.
-마우스 이벤트 리스너
MouseListener : 5종류 이벤트 메소드
MouseMotionListener : 2종류 이벤트 메소드
처리 내용에 따라 메소드 사용
마우스 좌표를 출력하기 위해 JPanel과 JLabel 사용
->Container ->Component
-마우스 좌표 출력 예제
---이벤트 어댑터
리스너는 인터페이스이기 때문에 모든 메소드들을 불러줘야해서 번거러움. 이 번거러움을 해결하는 것이 이벤트 어댑터.
- 이벤트 리스너 -> 인터페이스 -> 하위에서 메소드 모두 구현 -> 번거러워...
- 리스너 메소드가 미리 구현된 클래스 -> 어댑터 클래스
- 전체 메소드의 일부 구현
- 메소드가 많은 경우에만 어댑터 클래스 제공
-리스너와 어댑터 클래스
|
이벤트 리스너 인터페이스 |
어댑터 클래스 |
|
ActionListener |
없음 |
|
ItemListener |
없음 |
|
KeyListener |
KeyAdapter |
|
MouseListener |
MouseAdapter |
|
MouseMotionListener |
MouseMationAdapter |
|
FocusListener |
FocusAdapter |
|
TextListener |
없음 |
|
WindowListener |
Window Adapter |
|
AdjustmentListener |
없음 |
-마우스 어댑터 사용 예
MouseAdapter class
void mouseClicked(MouseEvent e)
void mouseDragged(MouseEvent e)
void mouseEntered(MouseEvent e)
void mouseMoved(MouseEvent e)
void mousePressed(MouseEvent e)
void mouseWheelMoved(MouseEvent e)
void mouseReleased(MouseEvent e)
마우스 클릭할 때마다 좌표가 뜨는 예제
-키 어댑터 사용 예
키 이벤트는 포커스가 있는 컴포넌트로부터 발생 -> 포커스 설정이 필요 -> requestFocus() 호출
포커스는 전체 메소드 중에서 한 개만 설정
자바의 문자는 유니코드를 사용한다.
문자키 -> 작은 따옴표로 표현 -> 유니코드와 같은 값 사용
가상키 -> 문자키를 제외한 키 -> VK_F1, VK_LEFT 등
|
KeyAdapter class |
void keyPressed(KeyEvent e) 키를 누르는 순간 호출 |
|
void keyReleadsed(KeyEvent e) 키를 떼는 순간 호출 |
|
|
void keyTyped(KeyEvent e) 키를 떼는 순간 키가 유니코드이면 호출 |
-KeyAdapter 클래스 메소드
어댑터 클래스 안에 구현되어 있다는 것은 키 리스너. 키 리스너라는 것은 인터페이스 안에 메소드가 정의되어 있음을 알 수 있음.
-KeyEvent 메소드
KeyEvent.getKeyChar() : 대소문자 리턴
-> KeyEvent.CHAR_UNDEFINED 그 외의 값
KeyEvent.getKeyCode() : 가상 키 코드값 리턴
KeyEvent.getKeyText() : 키에 대한 설명을 문자열로.
-키 입력에 따라 문자키와 기능키를 구분하여 출력
키 입력되는 데로 출력이 됨.
댓글