diff --git "a/\354\244\200\355\230\201/chapter_10.md" "b/\354\244\200\355\230\201/chapter_10.md" new file mode 100644 index 0000000..4bf93b1 --- /dev/null +++ "b/\354\244\200\355\230\201/chapter_10.md" @@ -0,0 +1,60 @@ +## 12. 컬렉션 프레임워크 +### 12-1 제네릭 +여러 참조 자료형을 사용할 수 있도록 프로그래밍 하는 것 + +제네릭 + +```java +// 제너릭 클래스의 선언 +public class Generic { + // 제너릭 타입의 멤버변수 + private T i; + + // 제너릭 타입의 매개변수 + public void setI(T i) { + this.i = i; + } + + // 제너릭 타입을 반환하는 함수 + public T getI() { + return i; + } +} +``` + +제네릭 클래스의 사용 + +```java +Generic i = new Generic(); +i.setI(new Integer(100)); +Integer j = i.getI(); +``` + +제너릭 타입을 특정 자료형으로 제한할 수 있다 +```java +public class Generic +``` + +### 12-2 컬렉션 프레임워크 + +자바에서 제공하는 자료구조 라이브러리 + +`Collection` 인터페이스와 `Map` 인터페이스을 기반으로 구성되어 있음 + +- `Collection` 인터페이스 + - `List` 인터페이스 + - `Set` 인터페이스 +- `Map` 인터페이스 + - `key`와 `value`를 가짐 + +### 12-3 List 인터페이스 +- ArrayList 클래스 : 객체 배열을 구현한 클래스, 컬렉션 인터페이스와 List 인터페이스를 구현 +- LinkedList 클래스 : 링크드 리스트를 클래스를 구현한 클래스 + +### 12-4 Set 인터페이스 +- HashSet 클래스 : 집합 자료 구조를 구현하고 중복을 허용하지 않음 +- TreeSet 클래스 : 자료의 중복을 허용하지 않으면서 출력 결과 값을 정렬하는 클래스 + +### 12-5 Map 인터페이스 +- HashMap 클래스 : Hash 형태로 자료를 관리하는 Map 인터페이스를 구현한 클래스 +- TreeMap 클래스 : 이진 검색 트리로 구성된 key 값으로 자료를 정렬한 클래스 \ No newline at end of file diff --git "a/\354\244\200\355\230\201/chapter_11.md" "b/\354\244\200\355\230\201/chapter_11.md" new file mode 100644 index 0000000..fdd891c --- /dev/null +++ "b/\354\244\200\355\230\201/chapter_11.md" @@ -0,0 +1,99 @@ +## 13. 내부 클래스, 람다식, 스트림 +### 13-1 내부 클래스 + +> 클래스 내부에 선언된 클래스 + +```java +class outer { + class inner {} +} +``` + +- 익명 내부 클래스 +```java +class outer { + type getType() { + return new type() { + @override + public void run() { + // todo + } + }; + } +} +``` + +### 13-2 람다식 + +> 익명 함수 + +```java +(int x, int y) -> {return x + y}; +``` + +- 괄호 생략 문법 (매개변수가 2개 이상인 경우 불가) +```java +str -> {System.out.println(str);} +``` + +- 중괄호 생략 문법 (구현이 한 줄일 경우만 가능) +```java +str -> System.out.println(str); +``` + +- return 예약어 생략 문법 +```java +(x, y) -> x + y; +str -> str.length(); +``` + +- 함수형 인터페이스 생성 시 내부 메서드는 하나만 존재해야한다. +```java +@FuntionalInterface // 함수형 인터페이스에 2개 이상의 메서드 선언을 막기위한 어노테이션 +interface Inter { + int add (int a, int b); +} + +public class a { + public static void main(string[] args) { + int a = 1; + int b = 2; + // 람다식 사용 시 인터페이스를 정의하는 클래스없이 바로 인스턴스를 만들어 사용한다. + Inter inter = (x, y) -> {return x + y}; + System.out.println(inter.add(a, b)); + } +} +``` + +### 13-3 스트림 + +> 여러 자료 처리에 대한 기능을 구현해 놓은 클래스 + +```java +int[] arr = {1,2,3,4,5}; +// stream을 이용해 배열의 요소를 하나씩 출력하는 foreach문 +Arrays.stream(arr).foreach(n -> System.out.println(n)); +``` + +- 스트림 연산 + - 중간 연산 + ```java +// filter 연산 +sList.stream().filter(s -> s.length() >= 5).foreach(s -> System.out.println(s)); +// map 연산 +customerList.stream().map(c -> c.getName()).foreach(s -> System.out.println(s)); + ``` + + - 최종 연산 +```java +Arrays.stream(arr).sum(); // 요소의 총합 +Arrays.stream(arr).count(); // 요소의 개수(long 타입) +Arrays.stream(arr).foreach(n -> System.out.println(n)); +// 등등... +``` + +#### 스트림 특징 +- 대상과 관련없이 동일한 연산 수행 +- 재사용 불가 +- 기존 자료 변경 X +- 중간 연산과 최종 연산이 존재함 \ No newline at end of file diff --git "a/\354\244\200\355\230\201/chapter_12.md" "b/\354\244\200\355\230\201/chapter_12.md" new file mode 100644 index 0000000..4692e10 --- /dev/null +++ "b/\354\244\200\355\230\201/chapter_12.md" @@ -0,0 +1,152 @@ +## 14. 예외 처리 +### 14-1 예외 클래스 + +> 예외 클래스의 계층 구조 +> ![](./img/chapter_12.png) + +### 14-2 예외 처리하기 + +- try-catch 문 +```java +try { + // 예외가 발생할 수 있는 코드 구현 +} catch(예외 타입 e) { + // 예외가 발생했을 때 예외를 처리할 코드 +} +``` + +- 예외 처리 실습 +```java +public static void main(String[] args) { + int[] arr = new int[5]; + // ArrayIndexOutOfBoundsException 예외 발생 + try { + for (int i = 0; i <= 5; i++) { + arr[i] = i; + } + } catch (ArrayIndexOutOfBoundsException e) { + System.out.println(e); + } + System.out.println("프로그램 종료"); +} +``` + +```bash +# 결과 +java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5 +프로그램 종료 +``` + +- finally 실습 +```java +public static void main(String[] args) { + int[] arr = new int[5]; + // ArrayIndexOutOfBoundsException 예외 발생 + try { + for (int i = 0; i <= 5; i++) { + arr[i] = i; + } + } catch (ArrayIndexOutOfBoundsException e) { + System.out.println(e); + } finally { + System.out.println("예외 여부 관계 없이 항상 실행"); + } +} +``` + +```bash +# 결과 +java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5 +예외 여부 관계 없이 항상 실행 +``` + +- try-with-resources문 + 시스템 리소스를 close 하지 않아도 try 내부에서 열린 리소스를 자동으로 닫아줌 (python `with`랑 비슷한 듯) +```java +try(ReSrc obj = new ReSrc()) { +} catch { +} +``` + +### 14-3 예외 처리 미루기 + +- throw 사용하기 +```java +// throws 를 사용하여 예외 상황 정의 +public Class loadClass(String s1, String s2) throws FileNotFoundException, ClassNotFoundException { + FileInputStream fis = new FileInputStream(s1); + Class c = Class.forName(s2); + return c; +} + +public static void main(String[] args) { + day11 test = new day11(); + try { + test.loadClass("a.txt", "java.lang.String"); + // 예외 처리 + } catch (FileNotFoundException | ClassNotFoundException e) { + System.out.println(e); + } +} +``` + +- 다중 예외 처리 + catch를 여러번 넣으면서 예외 처리를 여러번 할 수 있다. +```java +try { +} catch(FileNotFoundException e) { +} catch(ClassNotFoundException e) { +} catch(Exception e) { +} +``` + +### 14-4 사용자 정의 예외 + +- 상속을 통한 예외 상황 정의 +```java +class IDFormatException extends Exception { +    public IDFormatException(String message) { +        super(message); +    } +} +``` + +- 실습 코드 작성 +```java +private String userId; + +String getUserId() { + return userId; +} + +void setUserId(String userId) throws IDFormatException { + if (userId == null) { + throw new IDFormatException("ID는 비울 수 없습니다."); + } else if (userId.length() < 8 || userId.length() > 20) { + throw new IDFormatException("아이디는 8자 이상 20자 이하여야 합니다."); + } + this.userId = userId; +} + +public static void main(String[] args) { + day11 day11 = new day11(); + String userid = null; + try { + day11.setUserId(userid); + } catch(IDFormatException e) { + System.out.println(e); + } + userid = "aaaa"; + try { + day11.setUserId(userid); + } catch(IDFormatException e) { + System.out.println(e); + } +} +``` + +```bash +# 결과 +IDFormatException: ID는 비울 수 없습니다. +IDFormatException: 아이디는 8자 이상 20자 이하여야 합니다. +``` diff --git "a/\354\244\200\355\230\201/chapter_13.md" "b/\354\244\200\355\230\201/chapter_13.md" new file mode 100644 index 0000000..da05934 --- /dev/null +++ "b/\354\244\200\355\230\201/chapter_13.md" @@ -0,0 +1,70 @@ +## 15. 자바 입출력 +### 15-1 자바 입출력과 스트림 +- 입출력 장치의 호환성을 보장하기 위해 만들어진 스트림 +- 입력, 출력, 바이트, 문자, 기반, 보조 스트림이 존재함 + +### 15-2 표준 입출력 +- `System.out` : 표준 출력 스트림 +- `System.in` : 표준 입력 스트림 +- `System.err` : 표준 오류 스트림 + +그 외 클래스 + +- `Scanner` : `java.util` 에서 제공하는 입력 스트림 클래스 +- `Console` : 입력 스트림 클래스 + +### 15-3 바이트 단위 스트림 + +- `InputStream` : 바이트 단위로 읽는 스트림 중 최상위 +- `FileInputStream` : 파일 읽기 +```java +public static void main(String[] args) { + FileInputStream fis = null; + try { + fis = new FileInputStream("input.txt"); + System.out.println(fis.read()); + } catch(IOException e) { + System.out.println(e); + } finally { + try { + fis.close(); + } catch(IOException e) { + System.out.println(e); + } catch(NullPointerException e) { + System.out.println(e); + } + System.out.println("end"); + } +} +``` +- `OutputStream` +- `FileOutputStream` + +### 15-4 문자 단위 스트림 + +- `Reader` +- `FileReader` +- `Writer` +- `FileWriter` + +### 15-5 보조 스트림 + +- `FilterInputStream`, `FilterOutputStream` : 보조 스트림의 상위 클래스 +- `BufferdStream` : 버퍼 기능을 추가해 더 빠른 입출력을 제공 +- `Data[Input, Output]Stream` : 메모리에 저장된 0, 1 상태를 그대로 읽고 씀. + +### 15-6 직렬화 + +> 인스턴스의 순간 상태를 그대로 저장하거나 네트워크를 통해 전송하는 것. + +- 역직렬화 : 저장된 내용이나 전송받은 내용을 다시 복원하는 것 + +생성자 + +- `ObjectInputStream` +- `ObjectOutputStream` + +### 15-7 그 외 입출력 클래스 + +- `File` 클래스 +- `RandomAccessFile` 클래스 diff --git "a/\354\244\200\355\230\201/chapter_14.md" "b/\354\244\200\355\230\201/chapter_14.md" new file mode 100644 index 0000000..7733977 --- /dev/null +++ "b/\354\244\200\355\230\201/chapter_14.md" @@ -0,0 +1,392 @@ +## 최종 프로젝트 - 학점 산출 프로그램 만들기 + +- 학생 클래스 +```java +class Student { + private int studentId; + private String studentName; + private Subject majorSubject; + + private ArrayList scoreList = new ArrayList<>(); + + public Student(int studentId, String studentName, Subject majorSubject) { + this.studentId = studentId; + this.studentName = studentName; + this.majorSubject = majorSubject; + } + + public void addSubjectScore(Score score) { + scoreList.add(score); + } + + public int getStudentId() { + return studentId; + } + + public void setStudentId(int studentId) { + this.studentId = studentId; + } + + public String getStudentName() { + return studentName; + } + + public void setStudentName(String studentName) { + this.studentName = studentName; + } + + public Subject getMajorSubject() { + return majorSubject; + } + + public void setMajorSubject(Subject subject) { + this.majorSubject = subject; + } + + public ArrayList getScoreList() { + return scoreList; + } + + public void setScoreList(ArrayList arr) { + this.scoreList = arr; + } +} +``` + +- 강의 클래스 +```java +class Subject { + private String subjectName; + private int subjectId; + private int gradeType; + + private ArrayList studentList = new ArrayList<>(); + + public Subject(String subjectName, int subjectId, int gradeType) { + this.subjectName = subjectName; + this.subjectId = subjectId; + this.gradeType = Define.AB_TYPE; + } + + public String getSubjectName() { + return subjectName; + } + + public void setSubjectName(String subjectName) { + this.subjectName = subjectName; + } + + public int getSubjectId() { + return subjectId; + } + + public void setSubjectId(int subjectId) { + this.subjectId = subjectId; + } + + public ArrayList getStudentList() { + return studentList; + } + + public void setStudentList(ArrayList studentList) { + this.studentList = studentList; + } + + public int getGradeType() { + return gradeType; + } + + public void setGradeType(int gradeType) { + this.gradeType = gradeType; + } + + public void register(Student student) { + studentList.add(student); + } +} +``` + +- 점수 클래스 +```java +class Score { + int studentId; + Subject subject; + int point; + + public Score(int studentId, Subject subject, int point) { + this.studentId = studentId; + this.subject = subject; + this.point = point; + } + + public int getStudentId() { + return studentId; + } + + public void setStudentId(int studentId) { + this.studentId = studentId; + } + + public Subject getSubject() { + return subject; + } + + public void setSubject(Subject subject) { + this.subject = subject; + } + + public int getPoint() { + return point; + } + + public void setPoint(int point) { + this.point = point; + } + + public String toString() { + return "학번 : " + studentId + ", " + subject.getSubjectName() + " : " + point; + } +} +``` + +- 상수 클래스 +```java +class Define { + public static final int KOREAN = 1001; + public static final int MATH = 2001; + + public static final int AB_TYPE = 0; + public static final int SAB_TYPE = 1; +} +``` + +- 점수 산출 인터페이스 및 기능 구현 클래스 +```java +interface GradeEvaluation { + public String getGrade(int point); +} + +// 일반 과목 +class BasicEvaluation implements GradeEvaluation { + @Override + public String getGrade(int point) { + String grade; + + if (point >= 90 && point <= 100) grade = "A"; + else if (point >= 80) grade = "B"; + else if (point >= 70) grade = "C"; + else if (point >= 55) grade = "D"; + else grade = "F"; + return grade; + } +} + +// 전공 과목 +class MajorEvaluation implements GradeEvaluation { + @Override + public String getGrade(int point) { + String grade; + if (point >= 95 && point <= 100) grade = "S"; + else if (point >= 90) grade = new String("A"); + else if (point >= 80) grade = "B"; + else if (point >= 70) grade = "C"; + else if (point >= 60) grade = "D"; + else grade = "F"; + return grade; + } +} + +// 이후 PF 강의 평가 클래스 추가가 +``` + +- 결과 출력 클래스 +```java +class GenerateGradeReport { + School school = School.getInstance(); + public static final String TITLE = " 수강생 학점 \t\t\n"; + public static final String HEADER = " 이름 | 학번 |필수과목|점수 \n"; + public static final String LINE = "-------------------------------------\n"; + private StringBuffer buffer = new StringBuffer(); + + public String getReport() { + ArrayList subjectList = school.getSubjectList(); + for (Subject subject : subjectList) { + makeHeader(subject); + makeBody(subject); + makeFooter(); + } + return buffer.toString(); + } + + public void makeHeader(Subject subject) { + buffer.append(GenerateGradeReport.LINE); + buffer.append("\t"+subject.getSubjectName()); + buffer.append(GenerateGradeReport.TITLE); + buffer.append(GenerateGradeReport.HEADER); + buffer.append(GenerateGradeReport.LINE); + } + + public void makeBody(Subject subject) { + ArrayList studentList = subject.getStudentList(); + + for (int i = 0; i < studentList.size(); i++) { + Student student = studentList.get(i); + buffer.append(student.getStudentName()); + buffer.append(" | "); + buffer.append(student.getStudentId()); + buffer.append(" | "); + buffer.append(student.getMajorSubject().getSubjectName() + "\t"); + buffer.append(" | "); + + getScoreGrade(student, subject.getSubjectId()); + + buffer.append("\n"); + buffer.append(LINE); + } + } + + public void getScoreGrade(Student student, int subjectId) { + ArrayList scoreList = student.getScoreList(); + int majorId = student.getMajorSubject().getSubjectId(); + + // 평가 클래스 추가 + GradeEvaluation[] gradeEvaluations = {new BasicEvaluation(), new MajorEvaluation()}; + + for (int i = 0; i < scoreList.size(); i++) { + Score score = scoreList.get(i); + if (score.getSubject().getSubjectId() == subjectId) { + String grade; + if (score.getSubject().getSubjectId() == majorId) + grade = gradeEvaluations[Define.SAB_TYPE].getGrade(score.getPoint()); + else + grade = gradeEvaluations[Define.AB_TYPE].getGrade(score.getPoint()); + + buffer.append(score.getPoint()); + buffer.append(" : "); + buffer.append(grade); + buffer.append(" | "); + } + } + } + + public void makeFooter() { + buffer.append("\n"); + } +} +``` + +- 학교 클래스 +```java +class School { + private static School instance = new School(); + + private static String SCHOOL_NAME = "Good School?"; + private ArrayList studentList = new ArrayList<>(); + private ArrayList subjectList = new ArrayList<>(); + + private School() {} + + public static School getInstance() { + if (instance == null) + instance = new School(); + return instance; + } + + public ArrayList getStudentList() { + return studentList; + } + + public void addStudent(Student student) { + studentList.add(student); + } + + public void addSubject(Subject subject) { + subjectList.add(subject); + } + + public ArrayList getSubjectList() { + return subjectList; + } + + public void setSubjectList(ArrayList subjectList) { + this.subjectList = subjectList; + } +} +``` + +- 테스트 프로그램 작성 +```java + School sh = School.getInstance(); + Subject korean; + Subject math; + GenerateGradeReport gradeReport = new GenerateGradeReport(); + + public static void main(String[] args) { + Test test = new Test(); + + test.createStudent(); + test.createSubject(); + + String report = test.gradeReport.getReport(); + System.out.println(report); + } + + public void createSubject() { + // 전공 객체 생성 + korean = new Subject("국어", Define.KOREAN); + math = new Subject("수학", Define.MATH); + + // PF 평가 방식의 강의의 경우 정책 지정정 + + // 학교 객체에 전공 추가 + sh.addSubject(korean); + sh.addSubject(math); + } + + public void createStudent() { + Student student1 = new Student(111111, "aaa", korean); + Student student2 = new Student(222222, "bbb", math); + Student student3 = new Student(333333, "ccc", korean); + Student student4 = new Student(444444, "ddd", korean); + Student student5 = new Student(555555, "eee", math); + + sh.addStudent(student1); + sh.addStudent(student2); + sh.addStudent(student3); + sh.addStudent(student4); + sh.addStudent(student5); + + korean.register(student1); + korean.register(student2); + korean.register(student3); + korean.register(student4); + korean.register(student5); + + math.register(student1); + math.register(student2); + math.register(student3); + math.register(student4); + math.register(student5); + + addScoreForStudent(student1, korean, 95); + addScoreForStudent(student1, math, 56); + + addScoreForStudent(student2, korean, 95); + addScoreForStudent(student2, math, 95); + + addScoreForStudent(student3, korean, 100); + addScoreForStudent(student3, math, 88); + + addScoreForStudent(student4, korean, 89); + addScoreForStudent(student4, math, 95); + + addScoreForStudent(student5, korean, 85); + addScoreForStudent(student5, math, 56); + } + + public void addScoreForStudent(Student student, Subject subject, int point) { + Score score = new Score(student.getStudentId(), subject, point); + student.addSubjectScore(score); + } +} +``` \ No newline at end of file diff --git "a/\354\244\200\355\230\201/chapter_9.md" "b/\354\244\200\355\230\201/chapter_9.md" new file mode 100644 index 0000000..1ffdb8a --- /dev/null +++ "b/\354\244\200\355\230\201/chapter_9.md" @@ -0,0 +1,51 @@ +## 11. 기본 클래스 +### 11-1 Object 클래스 +> 모든 클래스의 최상위 클래스 + +컴파일 과정에서 모든 클래스는 Object 클래스를 상속한다. + +Object 클래스는 자바에서 사용되는 클래스의 여러 기본적인 메서드를 제공. 그러나 모든 메서드를 재정의 할 수 있지는 않다. + +#### Object 클래스의 기본 메서드 +- toString() : 인스턴스의 정보를 문자열로 반환, 재정의가 가능하다. +- equals() : 인스턴스의 물리적인 주소가 `boolean`으로 반환하는 메서드, 재정의가 가능하다. + 재정의시 매개변수로 받은 obj 클래스를 같은 클래스로 형변환해서 사용한다. +- hashCode() : 인스턴스의 주소값을 반환하는 메서드, 재정의가 가능하다. +- clone() : 인스턴스를 복제하는 메서드. + +## 11-2 String 클래스 + +선언방법 + +```java +String str = new String("문자열"); +``` + +String 클래스의 value 는 불변하다. final을 사용하여 선언되었다. + +변경이 가능한 String 클래스를 선언하기 위해선 `StringBuffer` 클래스나 `StringBuilder` 클래스를 이용하자. + +`StringBuilder` 클래스는 문자열이 안전하게 변경되는 것을 보장하지 않지만 실행 속도가 빠르기 때문에 싱글 스레드 프로그램에서 유용하다. + +## 11-3 Wrapper 클래스 + +기본 자료형을 위한 클래스 + +int, boolean 같은 기본 자료형이 아닌 `Integer`, `Boolean` 같은 클래스형으로 선언한다. + +```java +Integer i = new Integer(100); +``` + +- 언박싱 : Wrapper 클래스를 기본 자료형으로 형변환 +- 오토박싱 : 기본 자료형을 Wrapper 클래스로 형변환 + +## 11-4 Class 클래스 + +클래스나 인터페이스에 대한 변수, 메서드, 생성자 등의 정보를 가짐 + +```java +String str = new String(); +Class cls = s.getClass(); +Class c = String.Class; +``` \ No newline at end of file diff --git "a/\354\244\200\355\230\201/img/chapter_12.png" "b/\354\244\200\355\230\201/img/chapter_12.png" new file mode 100644 index 0000000..bd1f662 Binary files /dev/null and "b/\354\244\200\355\230\201/img/chapter_12.png" differ