[FileReader를 이용하여 한 글자씩 읽기]

public class FileIOtest {
    public static void main(String[] args) {
        try {
            FileReader fr = new FileReader(new File("input.txt"));
            int oneChar = 0;
 
            while((oneChar = fr.read()) != -1) {
                System.out.print((char)oneChar);
            }
            
            fr.close();
        } catch(FileNotFoundException e) {
            System.out.println(e);
        } catch(IOException e) {
            System.out.println(e);
        }
    }
}
cs

- 파일의 내용을 읽어와서 char로 하나씩 끝까지 출력한다.



[BufferedReader를 이용하여 줄 단위로 읽기]

public class FileIOtest {
    public static void main(String[] args) {
        try {
            FileReader fr = new FileReader(new File("input.txt"));
            BufferedReader br = new BufferedReader(fr);
            String oneLine;
 
            while((oneLine = br.readLine()) != null) {
                System.out.println(oneLine);
            }
            br.close();
        } catch(FileNotFoundException e) {
            System.out.println(e);
        } catch(IOException e) {
            System.out.println(e);
        }
    }
}
cs


[Scanner를 이용해서 읽기]

Scanner scanner = new Scanner(new File("input.txt"));
cs

- 위와 같이 사용하면 System.in을 이용하여 Scanner를 사용하던 것과 똑같이 파일을 입력으로 받아서 사용할 수 있다.




[BufferedWriter를 이용해서 쓰기]

File file = new File("output.txt");
BufferedWriter bw = new BufferedWriter(new FileWriter(file));
 
bw.write("1번 줄 내용 작성");
bw.newLine();        // 줄 바꿈
//...
cs


[포스팅 내용]

1. 자바 기초 문법, 패키지 등에 대해 정리
2. C언어 등과 같이 다른 언어에서도 일반적으로 사용되는 것은 작성하지 않음 (조건문, 반복문 등)


[기본 구조]

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}
cs



[입력]

1. 표준 입력

System.in.read();
cs

하나의 문자를 읽어서 반환함. 반환할 것이 없으면 -1을 반환

2. 문자열 입력

InputStreamReader instr = new InputStreamReader(System.in);
BufferedReader inbr = new BufferedReader(instr);
cs


BufferedReader를 사용해서 입력받을 수 있다. 위와 같이 사용하거나, 아래와 같이 짧게 사용 가능


BufferedReader inbr = new BufferedReader(new InputStreamReader(System.in));
cs



선언한 BufferedReader의 readLine() 메소드를 이용하여 String을 입력받을 수 있다.


String name = inbr.readLine();
cs



3. C++에서의 stoi와 비슷한 역할을 하는 것들

String str;
// str에 임의의 숫자를 입력했다고 가정
 
int a = Integer.parseInt(str);
double b = Double.parseDouble(str);
cs


위와 같이 스트링에서 해당 자료형을 파싱할 수 있다.



4. Scanner

Scanner scanner = new Scanner(System.in);
cs

File, InputStream, Readable, String 등을 받을 수 있는 생성자들이 있다.

Scanner에서 사용할 수 있는 메소드들은 다음과 같다.


void close()
boolean hasNext()
String next()
String nextLine()    // '\n'을 포함한다.
Xxx nextXxx()        // Xxx는 Byte, Short, Int, Long, Float, Double
cs




[자료형]

1. JAVA에서는 char가 2 byte (유니코드를 사용)
2. 대신 byte 자료형이 따로 있다.
3. 정수형 상수 표현 방법
  (1) 2진법 : 0b
  (2) 8진법 : 0
  (3) 16진법 : 0x
  -> 숫자 앞에 붙여준다.
4. 정수형 상수 중 long 형은 뒤에 l이나 L을 붙여준다.
5. 숫자 상수를 표현할 때, 숫자 사이에 '_'를 사용 가능하다. 예를 들면 123456을 123_456과 같이 표기 가능하다. 하지만 숫자 사이에만 사용해야 한다.
6. 실수형 상수 (별도의 지정이 없으면 double) 표현 방법 4가지
  (1) -34.56
  (2) -34.56e+4
  (3) 34.56f / 34.56F
  (4) 34.56d / 34.56D



[관계 연산자]

1. 다른 언어에 있는 것들 있음.
2. instanceof : 해당 클래스로 생성한 객체이면 true를 반환 (c instance of d)



[비트 연산자]

1. ~ : 1의 보수
2. << : 왼쪽 shift (a << 4)
3. >> : 오른쪽 shift
4. &
5. |
6. ^



[배열]

1. 선언 방법

(1) 자료형[] 배열이름;
(2) 자료형 배열이름[];
int[] arr1;
int arr2[];
cs

2. 메소드가 배열을 반환하는 것이 가능


3. 자바에서 배열은 클래스이기 때문에 생성까지 해주어야 사용이 가능하다.

int[] intArr;
intArr = new int[5];
cs

4. 객체이기 때문에 length와 같은 인스턴스 변수의 사용이 가능


5. for(자료형 변수 : 배열명)과 같이 향상된 for문 사용 가능

for(int i : intArr) {
    // ...
}
cs

이 경우에는 배열의 값들을 순서대로 대입하며 반복해나간다.




[클래스와 객체]

1. 기본 구조

class 이름 [extends ~~~] {
    // 변수
    // 생성자
    // 메소드
}
cs


2. 특징

캡슐화 / 상속 / 다형성

3. 클래스를 이용한 객체의 생성

Car myCar = new Car();
cs

4. 가변 인자

(1) 지정자 반환형 메소드명(자료형 ... 변수명) { }
(2) 생성자명(자료형 ... 변수명) { }

 -> 배열로 관리된다.


5. 오버로딩

 - 같은 이름의 메소드를 여러 개 만들 수 있다.
 - 매개변수가 달라야 하고, 반환형이 다를 수 있다. (매개변수의 이름이 다르더라고 타입과 개수, 순서가 같으면 안 된다)



[패키지]

- 클래스들의 집합

- import하여 사용하거나, 패키지.클래스 형식으로 사용이 가능하다.



[Object 클래스]

- 모든 자바 클래스의 최상위 클래스이다.
- 자바의 모든 클래스는 Object 클래스를 상속받는다.
- 메소드
protected Object clone()            // 객체 복제
public boolean equals(Object obj)    // 두 객체의 내용이 동일한지 비교
public int hashCode()                // 객체 식별 해시코드 반환
protected void finalize()            // 참조하지 않는 객체 가비지 콜렉션
public Class getClass()                // 클래스 이름을 Class 형으로 반환
public String toString()            // 객체의 문자열 반환
cs
- equals : 내용이 동일한지
- == : 같은 객체를 가리키는지



[StringTokenizer 클래스]

-  사용
StringTokenizer st = new StringTokenizer(파싱 대상 문자열, 구분자);
cs

- 메소드

String nextToken()
String nextToken(String delim)
boolean hasMoreTokens()
int countTokens()
cs




[객체의 형 변환]

(1) 서브 클래스 -> 수퍼 클래스 (가능)
(2) 수퍼 클래스 -> 서브 클래스 (불가능)



[상속]

- 기본 구조
class SubClass extends SuperClass {
    // ...
}
cs

- 슈퍼 클래스의 변수와 메소드 사용 가능

- 단일 상속만을 허용한다. (보완 방법 : 인터페이스)

- 인터페이스 간에는 다중 상속이 가능하다.




[변수와 메소드]

1. 클래스 변수 (static)

 - static 수식자를 사용
 - 클래스 전체에서 모든 객체가 공유하는 1개만 생성
 - 클래스 변수는 서브 클래스에 상속

2. 인스턴스 변수

 - 각 객체에 속한 변수
 - 서브 클래스에 상속

3. 지역 변수

 - 메소드 내에서 선언
 - 제어가 해당 블록을 빠져나가면 자동으로 제거

4. 클래스 메소드 (static)

 - static 수식자를 사용
 - 객체가 없어도 사용 가능
 - 클래스 변수의 값을 참조하거나 설정하는데 사용

5. 인스턴스 메소드

 - 객체가 있어야 사용 가능

6. 메소드 오버라이딩 (치환)


7. 메소드 은닉 (hiding)

 - 형을 슈퍼 클래스로 바꾸면 원래 슈퍼 클래스에 있던게 호출된다.

8. this, super, super()


9. 다형성

 - 클래스 계층 구조상이나, 동일 클래스 상에서 동일한 이름을 가진 메소드의 다형성

10. 접근 제어 (접근자)

 - public : 임의의 패키지에서 접근이 가능
 - protected : 동일한 클래스/패키지, 서브 클래스에서 접근 가능
 - packaged (기본) : 해당 클래스[인터페이스]와 같은 패키지 내의 모든 코드가 접근 가능. 다른 패키지에서는 사용이 불가
 - private : 정의된 클래스에서만 접근 가능. 치환 불가



[final 클래스, 메소드, 변수]

1. final 클래스

 - 서브 클래스 생성 불가
 - 메소드도 final이 된다.

2. final 변수

 - 상수 변수를 정의할 때 사용
 - C언어에서 #define 같은 느낌

3. final 메소드

 - 서브 클래스에서 치환 불가
 - 빠른 호출이 가능하다.



[추상 클래스(abstract)]

abstract class Animal {
    String name;
    int age;
 
    abstract void move();
    abstract void sound();
}
cs
- 추상 메소드를 가진 클래스를 말한다.
- 메소드의 구현부가 없고 반환형, 이름, 메소드의 매개변수만을 정의한다.
- 추상 메소드가 하나라도 있으면 추상 클래스로 선언한다.
- 추상 클래스의 서브 클래스는 필요한 추상 메소드만 선택적으로 구현이 가능하다.
- abstract를 앞에 붙여서 한다.



[인터페이스]

interface Animal {
    void move();
    void sound();
}
cs
- 단일 상속의 단점을 보완하기 위해 사용한다.
- 추상 클래스보다 한 단계 더 추상화된 것이다.
- 객체가 가지고 있어야 하는 기능만을 명세
- 정의시 class 대신 interface를 사용
- 추상 메소드, 상수, 상수 변수로 구성
- 일반 변수나 구현된 메소드는 사용 불가
- 다중 상속 가능
- 클래스 계층 구조의 일부가 아님
- 인터페이스를 구현하는 클래스는 인터페이스 안의 모든 메소드를 구현해야 한다.
- 객체 변수를 인터페이스형으로 선언 가능



[제네릭]

public class[interface] 이름<T, M ...> {  ~~  }




[Thread]

1. Thread 클래스를 이용하여 구현하는 방법 (간단하게 구현이 가능하다)

- 기본 구조

class ThreadClass extends Thread {
    public void run() {
        // Thread 실행 시 동작할 내용을 여기에 작성
    }
}
cs


- 사용

ThreadClass t1 = new ThreadClass();
t1.start();
cs

  start() 메소드를 호출하면 run()에 있는 내용이 실행된다.



2. Runnable 인터페이스를 사용하여 구현하는 방법 (상속이 반드시 필요한 경우에 사용하기 좋다)

- 기본 구조
class RunnableThread extends ParentClass implements Runnable {
    public void run() {
        // Thread 실행 시 동작할 내용을 여기에 작성
    }
}
cs


- 사용

RunnableThread r1 = new RunnableThread();
Thread t1 = new Thread(r1);
t1.start();
cs



3. 메소드

void start()
void run()
static void sleep(long millis)
static void yield()        // 자신은 대기하고 다른 Thread 수행
String getName()
void setName(String name)
boolean isAlive()
void join()
long getId()
static int activeCount() // 현재 실행중인 Thread 수 반환
int getPriority()
void interrupt()        // 현재 Thread 강제 종료
cs


4. Thread Life Cycle

 (1) 준비
   - start()로 호출되면 준비 상태에 들어감
 (2) 실행
   - start()에 의해 시작
   - run() 내의 코드 실행
   - 쓰레드 스케줄러에 의해 준비->실행으로 넘어감
 (3) 실행 정지
   - 대기, 슬립, 조인, 지연
 (4) 종료



[동기화]

- 접근 지정자 synchronized 자료형 메소드 선언 { ... }


이번에는 삼항 연산자에 대해서 배워보겠습니다.

변수1=변수2==a?b:c; 이런식으로 사용하는데

변수2가 a랑 같으면 b를, 다르면 c를 변수1에 넣는 연산자입니다.

다음 코드를 통해서 확인해보겠습니다.



public class ExTest {

public static void main(String[] args) {

int x = 5;

int y

x == 5 ? 2:3;

System.out.println(y);

y =

x == 3 ? 2:3;

System.out.println(y);

}

}


다음은 실행결과입니다.





연산자 == 은 왼쪽 항과 오른쪽 항이 같으면 true 값이 되고

연산자 !=은 왼쪽 항과 오른쪽 항이 다르면 true 값이 됩니다.

연산자 &&는 왼쪽과 오른쪽이 모두 true 값이면 true이고

연산자 ||는 왼쪽과 오른쪽 중 하나만 true 값이어도 true가 됩니다.

다음 코드를 통해서 확인해보겠습니다.


public class ExTest {

public static void main(String[] args) {

int x=8;

int y=3;

boolean b1 = x==8 && y==3;

boolean b2 = x==8 && y==1;

boolean b3 = x==8 || y==1;

boolean b4 = x!=7;

System.out.println(b1);

System.out.println(b2);

System.out.println(b3);

System.out.println(b4);

}

}


다음은 실행결과입니다.




다음 코드를 보고 결과가 어떻게 나올지 생각해보세요.


public class ExTest {

public static void main(String[] args) {

int x = 8;

int y = 3;

int result = x+++--y-++x+--x+y++;

System.out.println(result);

}

}













결과는 11입니다.

첫번째 x++는 8로 계산되고 이후 9로 바뀝니다.

두번째 --y는 2로 계산됩니다.

세번째 ++x는 10으로 계산됩니다.

네번째 --x는 9로 계산됩니다.

다섯째 y++는 2로 계산되고 이후 3으로 바뀝니다.

그래서 결과는 8+2-10+9+2=11이 됩니다.

+ Recent posts