TIL(22.4.02.SAT)

인터페이스

  • 다중 상속처럼 사용할 수 있는 기능
  • 추상 메소드와 상수만으로 이루어짐
    • 값 변경이 불가능한 변수 상수 지정할 때 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);
                   }
          • 무한루프 하나 만들고 그 안에 데이터를 한줄씩 읽어 오는데 읽어온 라인이 아무것도 없으면 더 이상 읽을 데이터가 없기에 이 반복문을 탈출하고 그게 아니면 그 라인을 출력하라는 명령

좋은 웹페이지 즐겨찾기