TIL(22.4.02.SAT)

기미노·2022년 4월 2일

Java 내부 클래스 종류 Java 상속과 인터페이스 동시사용 Java 익명 클래스 Java 인터페이스 Java 콘솔 입력 Java 콘솔 출력 Java 파일 입력 Java 파일 출력

인터페이스

상속과 인터페이스 동시 사용

인터페이스

다중 상속처럼 사용할 수 있는 기능
추상 메소드와 상수만으로 이루어짐
- 값 변경이 불가능한 변수 상수 지정할 때 final을 이용하는듯
- 추상메소드가 있는 구조가 인터페이스 구조

인터페이스 사용해보기

// Java 프로그래밍 - 인터페이스

// School 인터페이스
interface School {
    // final을 사용하여 상수값 고정
    // 인터페이스 안에는 상수 2개가 있다.
    public static final int MAX_CLASS = 20;
    public static final int MAX_PERSON_PER_CLASS = 40;
    // 추상메소드 하나가 있다.
    public abstract void printSchool();
}

// Student 클래스 - School 인터페이스 이용
class Student implements School {
    // School의 추상메소드를 오버라이딩해줘서 사용
    public void printSchool() {
        System.out.println("00 University");
    }
}

public class MyPrac {

    public static void main(String[] args) {

//      1. 인터페이스 기본 사용
        System.out.println("== 기본 인터페이스 ==");
        Student s1 = new Student();
        // 오버라이딩한 메소드 사용
        s1.printSchool();
        // 인터페이스 안에 있던 상수 사용
        System.out.println(s1.MAX_CLASS);
        System.out.println(s1.MAX_PERSON_PER_CLASS);
    }
}

School 인터페이스

final로 값 변경이 불가능한 변수 상수 2개를 설정해놈. 각각 학급 수와 학생 수
추상메소드하나도 있음

Student 클래스 - School 인터페이스 이용
추상메소드를 오버라이딩하기

1. 인터페이스 기본 사용
인터페이스를 받아 만든 클래스에서 오버라이딩한 메소드와 인터페이스에서 받은 상수들을 잘 끌어와서 출력함.

상속과 인터페이스 동시 사용

클래스내용도 가져올 수 있고, 인터페이스의 내용도 가져올 수 있음.
- 마치 다중 상속처럼 이용을 할 수 있게 됨.

상속과 인터페이스 동시 사용

// Java 프로그래밍 - 인터페이스

// School 인터페이스
interface School {
    // final을 사용하여 상수값 고정
    // 인터페이스 안에는 상수 2개가 있다.
    public static final int MAX_CLASS = 20;
    public static final int MAX_PERSON_PER_CLASS = 40;
    // 추상메소드 하나가 있다.
    public abstract void printSchool();
}

// Person 클래스
class Person {
    public String name;

    public void printName() {
        System.out.println("Name: " + name);
    }
}

// Student2 클래스 - Person 상속, School 인터페이스 이용
// extends로 Person상속을 먼저 해주고, School 인터페이스를 implements로 가져온다.
class Student2 extends Person implements School {
    // 생성자 하나 만들어주기
    Student2(String name) {
        // 부모 클래스의 String name으로 할당해준다.
        super.name = name;
    }
    // 추상메소드를 오버라이딩 안해주면 빨간밑줄이 생김 그래서 만들어줘야 해
    public void printSchool() {
        System.out.println("11 University");
    }
}

public class MyPrac {

    public static void main(String[] args) {
//      2. 다중 상속처럼 사용하기
        System.out.println("== Like 다중 상속 ==");
        Student2 s2 = new Student2("A");
            // Student2는 Person이라는 클래스를 상속받고, 인터페이스를 이용해서 만들어진 객체
            // A라는 데이터는 Student2에서 만든 생성자에서 받아서 super로 인해 Person으로 넘김
        s2.printSchool();
	         // printSchool()은 인터페이스 쪽에서 끌어와서 오버라이딩한 메소드
        s2.printName();

    }

}

Person 클래스

String name과 간단한 출력문구가 있는 클래스

Student2 클래스 - Person 상속, School 인터페이스 이용 다중 상속 느낌
추상메소드를 만들어준다
생성자 또한 만들어준다.

2. 다중 상속처럼 사용하기
Student2는 Person라는 클래스를 상속받고, 인터페이스를 이용하여 만들어진 객체이다.
A라는 데이터는 생성자에서 받아서 super를 이용해 Person으로 넘긴다.
prinschool()은 School 인터페이스를 이용해 끌어와서 오버라이딩한 메소드

내부 클래스

클래스안에 또 클래스가 있는 형태. 중첩클래스라고도 함.

내부 클래스 특징과 종류

안에서 밖은 접근 가능
- 밖에서 안은 접근 불가능
인스턴스 클래스
- 바깥 클래스와 안쪽 클래스가 있는데 바깥 클래스를 만들어야 안쪽 클래스를 만들 수 있는 형태를 말함
정적 클래스
- 내부 클래스에 static이라는 키워드가 붙어 메모리에 상주
- 바깥 클래스를 만들지 않아도 안쪽 클래스를 만들 수 있는 클래스를 말함.
지역 클래스
- 클래스안에 어떤 메소드안에 클래스가 있는 경우

내부 클래스 구조

// 내부 클래스 구조
class Outer {
    public void print() {
        System.out.println("Outer.print");
    }

    class Inner {
        // 출력 메소드를 하나 만듬
        public void InnerPrint() {
            // Outer에 접근하여 해당 메소드를 이용해봄.
            // 내부 클래스는 외부 클래스에 접근하여 사용 가능하다 했죠?
            Outer.this.print();
        }
    }
}

내부 클래스 구조

내부 클래스에서 Outer에 접근하여 Outer의 기능을 사용하여 출력하기
- 내부클래스는 외부클래스에 접근하여 사용이 가능
- Outer의 this 즉 자기 객체에 즉, this에 있는 print()를 실행?

외부 클래스 이용하기

public class MyPrac {

    public static void main(String[] args) {

//      외부 클래스
        // 객체 생성할 때 아래와 같이 만을어 주면 됨.
        Outer o1 = new Outer();
    }
}

외부 클래스 사용

외부 클래스의 객체 생성

내부 클래스 이용하기 - 인스턴스

public class MyPrac {

    public static void main(String[] args) {

//      내부 클래스 - 인스턴스
        // 내부 클래스를 사용할 때는 아래와 같이 만들어 주면 됨.
        // 타입은 맞춰준다. Outer.Inner
        // 객체 생성시 외부부터 만들어준다음 내부순으로 만들어준다.
        // 즉, 외부 객체를 만들고, 내부 객체를 만들어 접근한다!
        Outer.Inner i1 = new Outer().new Inner();
    }

}

내부 클래스 - 인스턴스 사용

타입을 먼저 맞춰주고, 객체 생성시 외부 객체부터 만든 다음 내부객체 생성해야 함.
외부 객체를 만들고 그 다음 내부 객체를 만들어 접근해야한다.

정적내부 클래스 구조

// 내부 클래스 구조
class Outer {
    public void print() {
        System.out.println("Outer.print");
    }

    class Inner {
        // 출력 메소드를 하나 만듬
        public void InnerPrint() {
            // Outer에 접근하여 해당 메소드를 이용해봄.
            // 내부 클래스는 외부 클래스에 접근하여 사용 가능하다 했죠?
            Outer.this.print();
        }
    }
    // 정적 클래스같은 경우 앞에 static을 붙여주면 내부클래스중에 정적클래스가 만들어짐
    static class InnerStaticClass {
        // 여기서도 한 번 출력을 해보자
        void InnerPrint() {
            // 정적클래스도 인스탠스클래스처럼 외부 클래스에 접근하여 사용되는지 확인해보자
            // Outer.this.print();
                // 근데 빨간줄이 생김
                // 내부 클래스인데 static이 붙어 정적특성을 갖기에 이 정적클래스는 바로 메모리에 올라감
                // 근데 Outer쪽은 static이 아니라서 메모리에 안 올라감
                // 그래서 Outer의 print()메소드는 바로 사용할 수 있는 형태가 아니기에 빨간줄이 생기는 것
                // 그래서 이 정적내부 클래스는 외부로 접근이 사실상 안 되는 부분이라서 주석처리해줌
        }
    }
}

정적내부 클래스 이용하기

public class MyPrac {

    public static void main(String[] args) {

//      내부 클래스 - 정적
        // 정적내부 클래스를 사용할 때는 아래와 같이 만들어 주면 됨.
        // 타입은 맞춰준다. Outer.InnerstaticClass
        // 객체 생성은 static이기에 Outer의 객체를 생성하지 않아도 됨.
        // 그래서 객체 생성은 안 하고, class이름으로 접근하면 됨.
        // 아래와 같이 만들면 정적내부 클래스 사용이 가능하다.
        Outer.InnerStaticClass is1 = new Outer.InnerStaticClass();
    }

}

내부 클래스 - 정적 사용

내부 클래스 중 정적 클래스를 만들어준다.
Outer.this.print()를 하면 빨간 밑줄이 생성됨
- 왜냐하면 Outer 클래스는 static 처리를 한게 아니므로 메모리에 올라가지 않아 바로 실행할 수 있는 형태가 아니기에 그런 것
  - 따라서 정적 클래스는 정황상 외부 클래스에 접근하여 사용할 수 없음.
사용
- 타입은 맞춰준다. 객체 생성은 static이기에 Outer의 객체는 생성하지 않아도 됌.
  - 따라서 객체생성은 안 해도 되고, 클래스 이름으로 접근

익명 클래스

선언과 동시에 객체 생성
이름이 없어 일회용으로 사용되고 끝남.
이전에 추상 메소드때 한 번 잠깐 사용해보긴 했는데 클래스이름 참조변수이름 = new 클래스 이름() { 이 클래스 정의부가 만들어지는 부분 }

익명 클래스 구조

// 익명 클래스를 사용하기 위해 간단한 추상 클래스를 만들어준다.
abstract class Person {
    // 추상 메소드로는 간단한 출력 메소드를 만들어준다
    public abstract void printInfo();
}

// 추상 클래스를 상속받아 만든 자식 클래스 만들기
class Student extends Person {
    // 반드시 추상 클래스의 메소드를 오버라이딩 해준다.
    public void printInfo() {
        System.out.println("Student.printInfo");
    }
}

익명 클래스 이용하기

public class MyPrac {

    public static void main(String[] args) {

//      익명 클래스
        // Person p1 = new Pe까지 적어주면 자동완성부분이 옆에 띄어져 enter누르면
        // 아래와 같이 자동완성 됨. 끝 중괄호에 세미클론 붙여준다
        Person p1 = new Person() {
            @Override
            public void printInfo() {
                System.out.println("Main.printInfo");
            }
        };
            // new Person이라는 클래스를 받아서
            // 익명클래스를 {}안에 만들어서 사용해주는것이기에
            // 내부 클래스의 한 종류임. 단 한 번만 쓸 수 있는 클래스!(일회용)
    }

}

익명 클래스

익명 클래스를 사용하기 위해 추상클래스를 생성 21~23
추상 클래스를 상속받아서 만드는 과정 25~29
사용
- new Person이라는 클래스를 받아서 익명클래스를 안쪽에 만들어 사용해주는 것이기에 내부 클래스의 한 종류

콘솔 입력

콘솔로 입력을 받는 방법
- 키보드를 생각하면 됨.
주로 Scanner사용

입력

많이 사용은 안 하나 코드를 읽고, 해석할 수는 있어야 하는 내용

System.in

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;

public class MyPrac {

    public static void referInputStream() throws IOException {
//      System.in
        System.out.println("== System.in ==");
        System.out.print("입력 :");
            // 우선 사용자에게 입력 받기 위한 출력을 콘솔에 한 번 해주기
            // 여기서는 enter를 빼고 입력 메세지를 출력해준다.
        int a = System.in.read() - '0';
            // int값을 하나 받아본다
            // System.in.read()를 하면 character값 하나를 받아 올 수 있다
            // 숫자 값을 받아 오면은 그게 이제 문자라서 어떤 아스키코드값에 맵핑되어 있어
            // 그 아스키코드값 만큼 빼서 숫자로 변환해주는 부분임
        System.out.println("a = " + a);
            // 그 데이터를 출력해주기
        System.in.read(new byte[System.in.available()]);
            // 한줄 더 작성해줘야 하는데 데이터를 입력하고 enter키를 누르면
            // enter키까지 포함되서 데이터를 읽어옴
            // in.read는 입력 스트림에서 하나만 가져올 수 있기에 뒤에 enter키가 남게되는 현상 발생
            // 그래서 그 부분(enter키)을 소진해서 없애줘야 함
            // 위의 코드를 작성하면 입력 스트림에 남아있는 갯수만큼 bite형태로 읽어서 데이터를 소진시켜주는 코드
    }
}

System.in
- 사용자에게 입력받기 위한 출력을 콘솔에 한 번 해주기
  - System.*out*.print("입력 :");
- int값을 하나 받는다
  - int a = System.*in*.read() - '0';
    - System.*in*.read() 하면 캐릭터값하나를 받아올 수 있음
    - 숫자값을 받아오면 그게 이제 문자라서 어떤 아스키 코드값에 맵핑되어 있는데,
    - - '0'
      - 그 아스키 코드값 만큼 빼서 숫자로 변환해주는 부분
- a 데이터를 출력해보기
  - System.*out*.println("a = " + a);
  - 한줄 더 작성해줘야 함.
    - 우리가 데이터를 입력하고 엔터를 누르면 엔터키까지 포함되서 데이터를 읽어옴
    - 그러나 in.read는 입력 스트림에서 하나만 가져올 수 있기 때문에 뒤에 엔터키가 남게 됨. 그래서 그부분을 소진해서 없애줘야 함.
      - System.*in*.read(new byte[System.*in*.available()]);
        
        입력 스트림에 남아 있는 갯수만큼 byte형태로 읽어서 데이터를 소진 시켜줌.

InputStreamReader

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;

public class MyPrac {

    public static void referInputStream() throws IOException {

//      InputStreamReader
        System.out.println("== InputStreamReader ==");
        InputStreamReader reader = new InputStreamReader(System.in);
            // 객체를 만들어 줄때 InputStreamReader의 매개변수로 System.in을 넣어줘야 함
        // 하나의 문자가 아니라 여러개의 데이터를 받아올 수 있는데
        // 그 값을 받아오기 위한 배열이 필요하다
        // 배열을 데이터3개 받아올 수 있게 만들어 준다.
        char[] c = new char[3];
        // 입력 메세지 하나를 출력해준다.
        System.out.print("입력: ");
        reader.read(c);
            // reader.read로 데이터를 읽어오면 되는데 여기다가 위에서 만들어준 배열 c를 작성
            // 그러면 데이터를 읽어서 배열c에다가 데이터를 넣어줌
        // 데이터를 한 번 출력해보겠다
        System.out.println(c);
    // 결론: 더 많은 데이터를 입력받아 출력하고 싶으면 배열로 받아올 수 있는 데이터 사이즈를 더 크게 만들어주면 됨.
    }
}

읽고자 하는 데이터 갯수만큼 배열을 만들고 난 후에 읽어야 함
객체를 만들어 줄때 InputStreamReader 의 매개변수로 System.*in* 을 넣어줘야 함.
하나의 문자만 받는게 아니라 여러개의 데이터를 받아 올 수 있는데 그 값을 받아 오기 위한 배열이 필요
- 배열을 3개의 값만 가져오게 만들어 준다.
  - char[] c = new char[3];
- 입력메세지 하나를 출력한다.
  - System.*out*.println("입력: ");
- reader.read(); 로 데이터를 읽어오면 됨. 따라서 c의 데이터를 읽어 오기 위해
  - reader.read(c);
    - 데이터를 읽어서 c 배열에다가 데이터를 넣어준다.
- c데이터 출력하기
  - System.*out*.println(c);
System.*in*.read(new byte[System.*in*.available()]); 가 없다면 초반에 입력값 입력하고 남은 엔터키가 입력 스트림에 남아 있어 reader.read()에 걸려서 즉, reader.read(c); 에 영향을 주어 입력값을 입력도 못하고 넘어가는 일이 발생할 수 있음
- System.in 은 따라서 남아 있는 데이터를 소진시키는 System.*in*.read(newbyte[System.*in*.available()]); 을 해줘야 함.

BufferedReader

public class MyPrac {

    public static void referInputStream() throws IOException {
        //      BufferedReader
        System.out.println("== BufferedReader ==");
            // BufferedReader같은 경우는
            // InputStreamReader는 우리가 읽고자 하는 갯수만큼 배열을 만들어주고 나서 읽었어야 했음
            // BufferedReader는 그런 불편함 없이 원하는 갯수만큼 자유자재로 읽어들일 수 있음
        // BufferedReader 사용하려면 BufferedReader객체를 만들어준다
        // BufferedReader매개변수쪽에 new InputStreamReader(System.in)을 넣어줘야 함
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            // 객체 생성이 어려울 수 있으나 사용 편리성은 이 친구가 갑
        // 입력값 받기
        System.out.print("입력: ");
        // 데이터를 읽을시 String에 다가 데이터를 읽어보겠다.
        String s1 = br.readLine();
            // br.readLine()을 해주면 되는데
        // 출력해보기
        System.out.println("s1 = " + s1);
    // 결론: 입력받을 때는 자유자재로 입력해주면 되고, 입력한 모든 데이터값들이 받아져서 출력되어 나오는것을 확인할 수 있음
    }
    }
}

읽고자 하는 데이터 갯수만큼 배열을 만들고 난 후에 읽어야 함과 같은 불편함 없이
- 원하는 갯수만큼 자유자재로 읽어 들일 수 있음
  - BufferedReader 객체 만들기
    - 매개변수 쪽에 new InputStreamReader(System.*in*) 을 넣어준다
      - BufferedReader br = new BufferedReader(new InputStreamReader(System.*in*));
    - 야간 앞에 것들을 다 짬뽕한 느낌
  - 데이터 읽기
    - String s1 = br.readLine();
  - 데이터 출력하기
    - System.*out*.println("s1 = " + s1);

주석 처리하여 위의 코드들이 실행되지 않도록 하기

public static void main(String[] args) throws IOException {

//      1-1. 다른 입력 방식 참고
//        referInputStream();
}

많이 사용되는 것

Scanner

public static void main(String[] args) throws IOException {

//      1-2. Scanner
        System.out.println("== Scanner ==");
        // Scanner의 경우에는 객체를 만들어준다.
        // 마찬가지로 Scanner 매개변수에 System.in을 사용
        Scanner sc = new Scanner(System.in);
        // 데이터를 읽을 때 몇 가지 방법으로 읽을 수 있는데
        // 1. 데이터를 바로 입력받아서 출력 시키기
        System.out.print("입력1: ");
            // 입력 받기위한 메세지 입력
        System.out.println(sc.next());
            // sc.next() 데이터를 받아올 수 있다.
        sc.nextLine();
            // 이 경우에도 enter키 소진을 위해 써준다.

        // 2.
        System.out.print("입력2: ");
            // 입력 받기위한 메세지 입력
        System.out.println(sc.nextInt());
            // sc.nextInt()는 Integer값만 입력해야함.
            // 다른 자료형값을 입력하면 에러가 발생
        sc.nextLine();
            // 이 경우에도 enter키 소진을 위해 써준다.

        // 3. 이 방법을 가장 많이 사용
        System.out.print("입력3: ");
            // 입력 받기위한 메세지 입력
        System.out.println(sc.nextLine());
            // BufferedReader처럼 자유자재로 데이터 자료형들을 받아다 읽어서 출력해줌.
    }
}

객체 만들기, 매개변수에는 System.in 을 사용해줘야
- Scanner sc = new Scanner(System.*in*);
- 데이터 읽을시 몇 가지의 방법
  - 데이터를 입력 받아 바로 출력
    - 데이터 입력받기 위한 메세지 출력하기
      - System.*out*.print("입력1: ");
    - 데이터를 하나 받아와 출력하기
      - sc.next() 이용
        
        System.*out*.println(sc.next());
      - 엔터키 소진을 위해
        
        sc.nextLine(); 이용
  - 다른 방법
    - 데이터 입력받기 위한 메세지 출력하기
      - System.*out*.print("입력2: ");
    - System.*out*.println(sc.nextInt()); 사용
      - integer값만 입력해야함. 다른 값 넣을 경우 에러 발생
    - 엔터키 소진을 위해
      - sc.nextLine(); 이용
  - 다른 방법(이 방법을 가장 많이 사용)
    - 데이터 입력받기 위한 메세지 출력하기
      - System.*out*.print("입력3: ");
    - System.*out*.println(sc.nextLine()); 사용
      - BufferedReader 처럼 자유자재로 데이터를 읽어다가 쓸 수 있음

참고

정수, 문자열 변환

// 빈번하게 사용되는 case들임
        int num = Integer.parseInt("12345");
            // ()안에 String값들을 적어준다.
            // ()안 문자열값이 정수형으로 변환되어 반환됨.
        String str = Integer.toString(12345);
            // ()안에 Int값들을 적어준다.
            // ()안 숫자값이 문자열형으로 변환되어 반환됨.

빈번하게 사용되는 case
- int num = Integer.*parseInt*("12345");
  - 문자열을 정수형으로 변환
- 숫자값이 문자열로 변환
  - String str = Integer.*toString*(12345);

콘솔 출력

콘솔로 출력하는 방법
- 모니터로 출력되는 화면으로 확인했었죠? 그 부분을 의미하는것
System.out.println();
- 엔터키가 포함되어 출력해주는 방법
System.out.print();
- 엔터키 없음
System.out.printf();
- 포맷을 지정하여 출력해주는 방법

출력

public static void main(String[] args) throws IOException {

//      2. 출력
        System.out.println("== 출력 ==");
        // println같은 경우는 enter키가 포함되어 출력되는 코드
        // 자동 줄바꿈이 됨.
        System.out.println("Hello");
        System.out.println("World!");

        // print같은 경우는 줄바꿈이 안 됨.
        // 입력받아 출력한 데이터들이 옆으로 배치됨.
        System.out.print("Hello ");
        System.out.print("World!");
        System.out.println();

        // printf같은 경우는 포맷을 지정한 다음 그 형식에 맞게 작성하여 출력함
        // 포맷 지정한게 없는 경우네는 print처럼 출력됨.
            // 단 엔터키가 없어서 추가 메세지들 또한 옆으로 출력됨을 확인 할 수 있음
        System.out.printf("Hello ");
        System.out.printf("World!");
        System.out.println();
      
    }
}

System.*out*.println();
- 줄바꿈(엔터키)이 되어 출력됨
System.*out*.print();
- 줄바꿈이 되지 않고, 옆으로 출력됨

System.*out*.printf();

포맷을 지정한 다음 거기에 맞춰서 출력하게 함.
포맷이 없는 경우 print와 똑같이 옆으로 출력됨.

System.*out*.printf(); 에 대한 추가 설명. println() 과 비교해보기

```java
String s = "자바";
        int number = 3;
        // 두 가지 방식으로 출력 해보기

        // 먼저 기존 방식
        // println쪽에 같이 포함하여 출력하고 싶을 때
        System.out.println(s + "는 언어 선호도 " + number + "위 입니다.");
        // printf로 포맷을 지정하여 출력하는 방식
        System.out.printf("%s는 언어 선호도 %d위 입니다.\n", s, number);
            // printf는 엔터키가 없어 줄넘기기가 안되므로 엔터키를 추가해준다.
                // \n을 해줌
                    // 안 해주면 다음 입력 스트림이 이 출력문 옆에 출력됨.
```

![Untitled](https://s3-us-west-2.amazonaws.com/secure.notion-static.com/f5583c04-78d5-47a6-a521-9fd5da18ef91/Untitled.png)

서식문자(변환하여 반환된 것을 출력해줌)

public static void main(String[] args) throws IOException {

        // 서식문자
            // 입력받은 데이터를 서식문자 형태에 맞게 변환하여 반환

        // 정수형
        System.out.printf("%d\n", 10);

        // 8진수
        System.out.printf("%o\n", 10);

        // 16진수
        System.out.printf("%x\n", 10);

        // 실수형
        System.out.printf("%f\n", 5.2f);

        // 문자값
        System.out.printf("%c\n", 'A');

        // 문자열형
        System.out.printf("%s\n", "안녕하세요");
    }
}

줄맞춤, 공백맞춤

5개의 공간을 확보하고 오른쪽으로 정렬하여 출력하기

// Java 프로그래밍 - 입출력_1

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;

public class MyPrac {

        // 서식문자
            // 입력받은 데이터를 서식문자 형태에 맞게 변환하여 반환
     

        // 줄맞춤&공백맞춤
        System.out.printf("%5d\n", 123);
            // 5개의 공간을 확보하고, 거기서 123을 출력해줌
        System.out.printf("%5d\n", 1234);
            // 5개의 공간을 확보하고, 거기서 1234을 출력해줌
        System.out.printf("%5d\n", 12345);
            // 5개의 공간을 확보하고, 거기서 12345을 출력해줌
    }

5개의 공간을 확보하고 왼쪽으로 정렬하여 출력하기

// Java 프로그래밍 - 입출력_1

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;

public class MyPrac {

        // 서식문자
            // 입력받은 데이터를 서식문자 형태에 맞게 변환하여 반환
     

        // 줄맞춤&공백맞춤
        System.out.printf("%-5d\n", 123);
            // 5개의 공간을 확보하고, 거기서 123을 출력해줌
        System.out.printf("%-5d\n", 1234);
            // 5개의 공간을 확보하고, 거기서 1234을 출력해줌
        System.out.printf("%-5d\n", 12345);
            // 5개의 공간을 확보하고, 거기서 12345을 출력해줌
    }

원하는 소숫점 자릿수 출력하기

// Java 프로그래밍 - 입출력_1

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;

public class MyPrac {

    public static void main(String[] args) throws IOException {
        // 서식문자
            // 입력받은 데이터를 서식문자 형태에 맞게 변환하여 반환

        // 소수점 자릿수 표현
        System.out.printf("%f\n", 1.12345123f);
            // %f에서 출력하면 소수점 출력
        System.out.printf("%.2f\n", 1.1264123f);
            // %.원하는 소수점자릿수f하면 원하는 소수점자리까지만 반올림되어출력
    }
}

2번째 자리까지만 표현(반올림해서 출력됨)
- System.*out*.printf("%.2f\n", 1.1234123f);
- System.*out*.printf("%.2f\n", 1.1264123f);

파일 출력

파일로 출력하는 방법

FileWriter

파일 쓰기

import java.io.*;

public class MyPrac {

    public static void main(String[] args) throws IOException {

    // FileWriter

        // 먼저 객체 하나를 만든다. == 작성한 데이터를 넣을 파일 생성과 같은 맥락인듯
        FileWriter fw = new FileWriter("./memo.txt");
            // 매개변수에는 어떤 파일에 데이터를 입력할건지 파일확장자를 써준다.
            //./memo.txt
                // 현재 폴더에 memo라는 이름의 텍스트파일을 만들겠다는 것

        // 작성한 데이터 파일에 넣기
        String memo = "헤드 라인\n";
            // 텍스트파일에 입력할 데이터 작성
        fw.write(memo);
            // fw.write()를 통해 파일에 작성한 데이터 넣기
            // ()안에 넣고자 하는 데이터 변수를 작성
        memo = "1월 1일 날씨 맑음\n";
            // 텍스트파일에 입력할 데이터 하나 더 작성
        fw.write(memo);
            // fw.write()를 통해 파일에 작성한 데이터 넣기

        // 작성한 데이터 파일에 넣는 작업 완료후 파일 닫기
        fw.close();
            // 파일 쓰기가 완료되면 항상 이 코드를 써줘야 함.

    }
}

객체 만들어주고, 매개변수안에는 어떤 파일을 쓸건지 이름을 씀. 즉, 현재폴더에 메모라는 txt파일을 만드는것
- FileWriter fw = new FileWriter("./memo.txt");
파일 쓰기가 완료되면 항상 fw.close(); 해줘야 함.

데이터를 파일에 넣기

fw.write(); 쓰기

String memo = "헤드 라인\n";
        fw.write(memo);

파일 이어쓰기

import java.io.*;

public class MyPrac {

    public static void main(String[] args) throws IOException {
// FileWriter
    // 1. 파일 쓰기

        // 먼저 객체 하나를 만든다. == 작성한 데이터를 넣을 파일 생성과 같은 맥락인듯
        FileWriter fw = new FileWriter("./memo.txt");
            // 매개변수에는 어떤 파일에 데이터를 입력할건지 파일확장자를 써준다.
            //./memo.txt
                // 현재 폴더에 memo라는 이름의 텍스트파일을 만들겠다는 것

        // 작성한 데이터 파일에 넣기
        String memo = "헤드 라인\n";
            // 텍스트파일에 입력할 데이터 작성
        fw.write(memo);
            // fw.write()를 통해 파일에 작성한 데이터 넣기
            // ()안에 넣고자 하는 데이터 변수를 작성
        memo = "1월 1일 날씨 맑음\n";
            // 텍스트파일에 입력할 데이터 하나 더 작성
        fw.write(memo);
            // fw.write()를 통해 파일에 작성한 데이터 넣기
            // ()안에 넣고자 하는 데이터 변수를 작성

        // 작성한 데이터 파일에 넣는 작업 완료후
        fw.close();
            // 파일 쓰기가 완료되면 항상 이 코드를 써줘야 함.

		// 2. 파일 이어 쓰기

        // 새로운 객체 만들기
        FileWriter fw2 = new FileWriter("./memo.txt",true);
						// new FileWriter객체 만들때 
						// 파일명 생성까지는 파일쓰기 부분이랑 같음. 오른쪽에다가 true입력
            // 도움말로 append가 뜨는데 이걸 true라고 해서 이어쓰겠다라고 의미하는것

        // 추가로 작성한 데이터 파일에 넣기
        memo = "1월 10일 날씨 완전 맑음\n";
            // 텍스트 파일에 추가로 입력할 데이터 작성
        fw2.write(memo);
            // fw.write()를 통해 작성한 데이터 파일에 넣기
            // ()안에 넣고자 하는 데이터 변수를 작성

        // 작성한 데이터 파일에 넣는 작업 완료후 파일 닫기
        fw2.close();
            // 파일 쓰기가 완료되면 항상 이 코드를 써줘야 함.

    }
}

객체를 만들고, 매개변수에 파일명까지 쓰는것 동일하고, 오른쪽에 true를 씀
- FileWriter fw2 = new FileWriter("./memo.txt",true);
파일 쓰기가 완료되면 항상 fw.close(); 해줘야 함.

데이터를 파일에 넣기

fw.write(); 쓰기

memo = "1월 2일 날씨 완전 맑음\n";
        fw2.write(memo);

PrintWriter

파일 쓰기

import java.io.*;

public class MyPrac {

    public static void main(String[] args) throws IOException {
// 1. 파일 쓰기
    // PrintWriter
        // 객체를 만들어준다. == 작성한 데이터를 넣을 파일 생성과 같은 맥락인듯
        PrintWriter pw = new PrintWriter("./memo.txt");
        // 매개변수에는 어떤 파일에 데이터를 입력할건지 파일확장자를 써준다.
        //./memo.txt
            // 현재 폴더에 memo라는 이름의 텍스트파일을 만들겠다는 것

        // 작성한 데이터 파일에 넣기
        String memo = "헤드 라인";
            // 텍스트파일에 입력할 데이터 작성
            // println이 지원되기에 \n을 따로 작성 안 해도 됨.
        pw.println(memo);
            // pw는 줄넘기기 기능이 포함되어 있는 println이 지원
            // pw.println()를 통해 파일에 작성한 데이터 넣기
            // ()안에 넣고자 하는 데이터 변수를 작성
        memo = "1월 2일 날씨 맑음";
            // 텍스트파일에 입력할 데이터 하나 더 작성
        pw.println(memo);
            // pw.println()를 통해 파일에 작성한 데이터 넣기
            // ()안에 넣고자 하는 데이터 변수를 작성

        // 작성한 데이터 파일에 넣는 작업 완료후 파일 닫기
        pw.close();
            // 파일 쓰기가 완료되면 항상 이 코드를 써줘야 함.

    }
}

객체를 만들어 주고, 똑같이 매개변수안에 파일명 쓰기
- PrintWriter pw = new PrintWriter("./memo.txt");
파일쓰기가 완료되면 항상 pw.close(); 해주기

데이터 파일에 넣기

여기서는 \n을 따로 할 필요없음. 그냥 아래와 같이 해주면 됨 pw.println();

memo = "헤드 라인";
        pw.println(memo);
memo = "1월 1일 날씨 맑음";
        pw.println(memo);

결과

파일 이어쓰기

import java.io.*;

public class MyPrac {

    public static void main(String[] args) throws IOException {
    // 1. 파일 쓰기

        // 객체를 만들어준다. == 작성한 데이터를 넣을 파일 생성과 같은 맥락인듯
        PrintWriter pw = new PrintWriter("./memo.txt");
        // 매개변수에는 어떤 파일에 데이터를 입력할건지 파일확장자를 써준다.
        //./memo.txt
            // 현재 폴더에 memo라는 이름의 텍스트파일을 만들겠다는 것

        // 작성한 데이터 파일에 넣기
        String memo = "헤드 라인";
            // 텍스트파일에 입력할 데이터 작성
            // println이 지원되기에 \n을 따로 작성 안 해도 됨.
        pw.println(memo);
            // pw는 줄넘기기 기능이 포함되어 있는 println이 지원
            // pw.println()를 통해 파일에 작성한 데이터 넣기
            // ()안에 넣고자 하는 데이터 변수를 작성
        memo = "1월 2일 날씨 맑음";
            // 텍스트파일에 입력할 데이터 하나 더 작성
        pw.println(memo);
            // pw.println()를 통해 파일에 작성한 데이터 넣기
            // ()안에 넣고자 하는 데이터 변수를 작성

        // 작성한 데이터 파일에 넣는 작업 완료후
        pw.close();
            // 파일 쓰기가 완료되면 항상 이 코드를 써줘야 함.

    // 2. 파일 이어 쓰기
       
        // 새로운 객체 만들기
        PrintWriter pw2 = new PrintWriter(new FileWriter("./memo.txt",true));
            // new PrintWriter의 ()안에 FileWriter를 만들어서 넣어준다.
                // new FileWriter("./memo.txt",true)를 넣어준다.

        // 추가로 작성한 데이터 파일에 넣기
        memo = "1월 20일 날씨 또 맑음!";
            // 텍스트 파일에 추가로 입력할 데이터 작성
        pw2.println(memo);
            // pw.println()를 통해 작성한 데이터 파일에 넣기
            // ()안에 넣고자 하는 데이터 변수를 작성

        // 작성한 데이터 파일에 넣는 작업 완료후 파일 닫기
        pw2.close();
            // 파일 쓰기가 완료되면 항상 이 코드를 써줘야 함.

    }
}

객체를 만들고, 매개변수에 FileWriter 를 만들어서 넣어줘야 함.
- PrintWriter pw2 = new PrintWriter(new FileWriter("./memo.txt",true));
파일쓰기가 완료되면 항상 pw.close(); 해주기

데이터를 파일에 넣기

pw.println();

memo = "1월 3일 날씨 또 맑음!";
        pw.println(memo);

결과

파일 입력

파일로부터 데이터를 입력받는 방법

BufferedReader

파일로부터 작성된 데이터를 읽어오는 방법

import java.io.*;

public class MyPrac {

    public static void main(String[] args) throws IOException {

// 2. 파일 입력
    // 파일로 부터 데이터를 읽어오는 방법
        // BufferedReader 이용하기

        // 객체 만들기
        BufferedReader br = new BufferedReader(new FileReader("./memo.txt"));
            // 콘솔창으로부터 입력받은 데이터를 받을올 때는
                // ()안에 System.in을 넣어줬었음
                    // 이렇게 하면 console창으로부터 입력받은 데이터를 받아 오는것이고
            // 파일로부터 입력돼있는 데이터를 받아올 때는
                // ()안에 new FileReader("./memo.txt")를 넣어준다.
                    // new FileReader의 ()안에 어떤 파일로부터 데이터를 받아올지 파일명을 작성

        // memo.txt 파일 안에 여러줄의 데이터가 있을 시 이 여러줄의 데이터를 읽어들이는 법
        // 반복문 이용 - while문 사용해보기
        while (true) {
            // 무한 루프

            String line = br.readLine();
                // 파일로 부터 데이터를 한줄씩 읽어들일 때 사용
            if (line == null) {
                // 만약에 읽어올 라인이 아무것도 없다면
                // 더 이상 읽을 데이터가 없는것이니
                break;
                    // 반복문을 탈출 하라
            }

            System.out.println(line);
                // 읽어올 라인 있다면 라인을 출력하라
        }
        // 파일에 있는 데이터 다 읽은 후 파일 닫아주기
        br.close();

    }
}

객체를 생성하고, 매개변수 안에 FileReader 의 매개변수 안에서 어떤 파일로부터 데이터를 읽을 건지 명시하기
- BufferedReader br = new BufferedReader(new FileReader("./memo.txt"));
데이터를 읽어오고 나서는 항상 닫아주기
- br.close();
파일로부터 데이터를 한줄씩 읽어 들일때
- String line = br.readLine();
여러줄을 전부 읽어오는
- 반복문 사용
```
while (true) {
            String line = br.readLine();
            
            if (line == null) {
                break;
            }

            System.out.println(line);
         }
```
  - 무한루프 하나 만들고 그 안에 데이터를 한줄씩 읽어 오는데 읽어온 라인이 아무것도 없으면 더 이상 읽을 데이터가 없기에 이 반복문을 탈출하고 그게 아니면 그 라인을 출력하라는 명령

기미노

인풋보다는 아웃풋을 중점적으로

이전 포스트

TIL(22.4.02.SAT)

인터페이스

상속과 인터페이스 동시 사용

내부 클래스

내부 클래스 특징과 종류

익명 클래스

콘솔 입력

콘솔 출력

파일 출력

파일 입력

TIL(22.4.01.FRI)

0개의 댓글

관련 채용 정보