자바 API 활용 및 API 만들기

실제로 유틸성 API를 제작하는 것은 유지보수성과 가독성에 큰 영향을 줍니다. 언제 API를 만들어 사용할지 고민해보시면 좋겠습니다.

 

Course 2

Part 1. 자바 API 활용 및 API 만들기

CH1. 우리가 사용하게 될 클래스들(API)

• 직접 만들어서 사용하는 class들
  개념:
  직접 만들어서 사용하는 클래스는 개발자가 특정 기능을 수행하기 위해 정의하는 클래스입니다. 이러한 클래스는 애플리케이션의 특정 요구사항을 충족시키기 위해 설계됩니다. 사용자 정의 클래스는 고유의 필드와 메소드를 포함하며, 객체 지향 프로그래밍의 원칙에 따라 재사용 가능하고 확장 가능합니다.
  예시:
  // Person 클래스를 정의합니다.
• class Person {
•     // 클래스의 필드
•     private String name;
•     private int age;
•     // 생성자
•     public Person(String name, int age) {
•         this.name = name;
•         this.age = age;
•     }
•     // 이름을 반환하는 메소드
•     public String getName() {
•         return name;
•     }
•     // 나이를 반환하는 메소드
•     public int getAge() {
•         return age;
•     }
•     // 이름과 나이를 출력하는 메소드
•     public void introduce() {
•         System.out.println("Hello, my name is " + name + " and I am " + age + " years old.");
•     }
• }
• public class Main {
•     public static void main(String[] args) {
•         // Person 객체를 생성하고 메소드를 호출합니다.
•         Person person = new Person("John", 30);
•         person.introduce();
•     }
• }
• /*
• Person이라는 클래스를 직접 정의했습니다. 이 클래스는 이름과 나이를 필드로 가지며, 생성자와 메소드를 통해 객체를 생성하고 데이터를 처리합니다.
• */
• Java에서 제공해 주는 class들
  개념:
  Java에서 제공하는 클래스들은 표준 라이브러리(java.lang, java.util 등)에서 제공하는 클래스들로, 자바 프로그래밍을 쉽게 하기 위해 미리 구현된 클래스들입니다. 이러한 클래스들은 다양한 데이터 구조, 입출력, 네트워킹 등 여러 가지 기능을 제공합니다.
  예시:
  import java.util.ArrayList;
• import java.util.HashMap;
• public class JavaProvidedClassesExample {
•     public static void main(String[] args) {
•         // ArrayList 예시
•         ArrayList<String> list = new ArrayList<>();
•         list.add("Apple");
•         list.add("Banana");
•         list.add("Orange");
•         for (String fruit : list) {
•             System.out.println(fruit);
•         }
•         // HashMap 예시
•         HashMap<String, Integer> map = new HashMap<>();
•         map.put("Apple", 1);
•         map.put("Banana", 2);
•         map.put("Orange", 3);
•         for (String key : map.keySet()) {
•             System.out.println("Key: " + key + ", Value: " + map.get(key));
•         }
•     }
• }
• /*
• ArrayList와 HashMap이라는 자바 표준 라이브러리 클래스를 사용했습니다. ArrayList는 동적 배열을 제공하고, HashMap은 키-값 쌍을 저장하는 자료 구조입니다.
• */
• 다운 받아서 사용하는 class들
  개념:
  다운 받아서 사용하는 클래스들은 외부 라이브러리 또는 프레임워크에 포함된 클래스들입니다. 이러한 라이브러리는 특정 기능을 구현하기 위해 재사용 가능한 코드를 제공합니다. Maven, Gradle과 같은 빌드 도구를 사용하여 프로젝트에 쉽게 추가할 수 있습니다.
  예시:
  // Maven을 사용하여 Gson 라이브러리를 추가한다고 가정합니다.
• // pom.xml 파일에 다음 의존성을 추가합니다.
• /*
• <dependency>
•     <groupId>com.google.code.gson</groupId>
•     <artifactId>gson</artifactId>
•     <version>2.8.6</version>
• </dependency>
• */
• import com.google.gson.Gson;
• class User {
•     private String name;
•     private int age;
•     public User(String name, int age) {
•         this.name = name;
•         this.age = age;
•     }
•     public String getName() {
•         return name;
•     }
•     public int getAge() {
•         return age;
•     }
• }
• public class GsonExample {
•     public static void main(String[] args) {
•         // Gson 객체를 생성합니다.
•         Gson gson = new Gson();
•         // User 객체를 JSON 문자열로 변환합니다.
•         User user = new User("Alice", 25);
•         String json = gson.toJson(user);
•         System.out.println("JSON: " + json);
•         // JSON 문자열을 User 객체로 변환합니다.
•         String userJson = "{\\"name\\":\\"Bob\\",\\"age\\":30}";
•         User newUser = gson.fromJson(userJson, User.class);
•         System.out.println("Name: " + newUser.getName() + ", Age: " + newUser.getAge());
•     }
• }
• /*
• 외부 라이브러리인 Gson을 사용하여 Java 객체를 JSON으로 변환하고 JSON을 Java 객체로 변환하는 예를 보여줍니다. 
• Maven을 통해 Gson 라이브러리를 프로젝트에 추가한 후 사용할 수 있습니다.
• */

CH2.내가 만들어본 최초의 API

• 배열처럼 동작하는 API 만들어 보기
  개념:
  배열처럼 동작하는 API를 만드는 것은 데이터 구조를 직접 설계하여 관리하는 방법을 배우는 좋은 연습입니다. 이는 배열의 기본 기능을 이해하고, 크기 조정, 요소 추가 및 제거, 요소 접근 등의 기능을 직접 구현해 보는 것을 의미합니다.
  예시:
  class MyArray {
•     private int[] array;
•     private int size;
•     public MyArray(int capacity) {
•         array = new int[capacity];
•         size = 0;
•     }
•     public void add(int value) {
•         if (size == array.length) {
•             resize();
•         }
•         array[size++] = value;
•     }
•     public int get(int index) {
•         if (index < 0 || index >= size) {
•             throw new IndexOutOfBoundsException("Index out of bounds");
•         }
•         return array[index];
•     }
•     public int size() {
•         return size;
•     }
•     private void resize() {
•         int[] newArray = new int[array.length * 2];
•         System.arraycopy(array, 0, newArray, 0, array.length);
•         array = newArray;
•     }
• }
• public class MyArrayExample {
•     public static void main(String[] args) {
•         MyArray myArray = new MyArray(2);
•         myArray.add(1);
•         myArray.add(2);
•         myArray.add(3);
•        
•         for (int i = 0; i < myArray.size(); i++) {
•             System.out.println(myArray.get(i));
•         }
•     }
• }
• /*
• MyArray 클래스는 기본적인 배열 동작을 구현합니다. add 메소드는 요소를 추가하고, 배열의 크기를 자동으로 조정하며, get 메소드는 인덱스로 요소를 가져옵니다.
• */
• IntArray 클래스를 만들어 사용하기
  개념:
  IntArray 클래스는 정수를 저장하는 배열을 다루기 위한 클래스입니다. 배열의 크기 조정, 요소 추가 및 삭제, 요소 접근 등의 기능을 포함합니다. 이는 배열처럼 동작하는 API의 구체적인 예입니다.
  예시:
  class IntArray {
•     private int[] array;
•     private int size;
•     public IntArray(int capacity) {
•         array = new int[capacity];
•         size = 0;
•     }
•     public void add(int value) {
•         if (size == array.length) {
•             resize();
•         }
•         array[size++] = value;
•     }
•     public int get(int index) {
•         if (index < 0 || index >= size) {
•             throw new IndexOutOfBoundsException("Index out of bounds");
•         }
•         return array[index];
•     }
•     public void remove(int index) {
•         if (index < 0 || index >= size) {
•             throw new IndexOutOfBoundsException("Index out of bounds");
•         }
•         for (int i = index; i < size - 1; i++) {
•             array[i] = array[i + 1];
•         }
•         size--;
•     }
•     public int size() {
•         return size;
•     }
•     private void resize() {
•         int[] newArray = new int[array.length * 2];
•         System.arraycopy(array, 0, newArray, 0, array.length);
•         array = newArray;
•     }
• }
• public class IntArrayExample {
•     public static void main(String[] args) {
•         IntArray intArray = new IntArray(2);
•         intArray.add(10);
•         intArray.add(20);
•         intArray.add(30);
•         for (int i = 0; i < intArray.size(); i++) {
•             System.out.println(intArray.get(i));
•         }
•         intArray.remove(1);
•         for (int i = 0; i < intArray.size(); i++) {
•             System.out.println(intArray.get(i));
•         }
•     }
• }
• /*
• IntArray 클래스는 add, get, remove 메소드를 포함하여 배열을 다루는 기본 기능을 구현합니다. resize 메소드는 내부 배열의 크기를 동적으로 조정합니다.
• */
• BookArray 클래스를 만들어 사용하기
  개념:
  BookArray 클래스는 Book 객체를 저장하고 관리하는 배열을 다루기 위한 클래스입니다. 이 클래스는 Book 객체를 추가, 제거, 검색하는 기능을 포함합니다.
  예시:
  class Book {
•     private String title;
•     private String author;
•     public Book(String title, String author) {
•         this.title = title;
•         this.author = author;
•     }
•     public String getTitle() {
•         return title;
•     }
•     public String getAuthor() {
•         return author;
•     }
• }
• class BookArray {
•     private Book[] books;
•     private int size;
•     public BookArray(int capacity) {
•         books = new Book[capacity];
•         size = 0;
•     }
•     public void add(Book book) {
•         if (size == books.length) {
•             resize();
•         }
•         books[size++] = book;
•     }
•     public Book get(int index) {
•         if (index < 0 || index >= size) {
•             throw new IndexOutOfBoundsException("Index out of bounds");
•         }
•         return books[index];
•     }
•     public void remove(int index) {
•         if (index < 0 || index >= size) {
•             throw new IndexOutOfBoundsException("Index out of bounds");
•         }
•         for (int i = index; i < size - 1; i++) {
•             books[i] = books[i + 1];
•         }
•         size--;
•     }
•     public int size() {
•         return size;
•     }
•     private void resize() {
•         Book[] newBooks = new Book[books.length * 2];
•         System.arraycopy(books, 0, newBooks, 0, books.length);
•         books = newBooks;
•     }
• }
• public class BookArrayExample {
•     public static void main(String[] args) {
•         BookArray bookArray = new BookArray(2);
•         bookArray.add(new Book("1984", "George Orwell"));
•         bookArray.add(new Book("Brave New World", "Aldous Huxley"));
•         bookArray.add(new Book("Fahrenheit 451", "Ray Bradbury"));
•         for (int i = 0; i < bookArray.size(); i++) {
•             Book book = bookArray.get(i);
•             System.out.println("Title: " + book.getTitle() + ", Author: " + book.getAuthor());
•         }
•         bookArray.remove(1);
•         for (int i = 0; i < bookArray.size(); i++) {
•             Book book = bookArray.get(i);
•             System.out.println("Title: " + book.getTitle() + ", Author: " + book.getAuthor());
•         }
•     }
• }
• /*
• BookArray 클래스는 Book 객체를 저장, 추가, 제거, 검색하는 기능을 제공합니다. resize 메소드는 내부 배열의 크기를 동적으로 조정합니다.
• */
• ObjectArray 클래스를 만들어 사용하기
  개념:
  ObjectArray 클래스는 다양한 타입의 객체를 저장하고 관리할 수 있는 배열을 다루기 위한 클래스입니다. 이 클래스는 제네릭을 사용하여 타입에 구애받지 않고 객체를 저장할 수 있습니다.
  예시:
  class ObjectArray<T> {
•     private Object[] array;
•     private int size;
•     public ObjectArray(int capacity) {
•         array = new Object[capacity];
•         size = 0;
•     }
•     public void add(T value) {
•         if (size == array.length) {
•             resize();
•         }
•         array[size++] = value;
•     }
•     @SuppressWarnings("unchecked")
•     public T get(int index) {
•         if (index < 0 || index >= size) {
•             throw new IndexOutOfBoundsException("Index out of bounds");
•         }
•         return (T) array[index];
•     }
•     public void remove(int index) {
•         if (index < 0 || index >= size) {
•             throw new IndexOutOfBoundsException("Index out of bounds");
•         }
•         for (int i = index; i < size - 1; i++) {
•             array[i] = array[i + 1];
•         }
•         size--;
•     }
•     public int size() {
•         return size;
•     }
•     private void resize() {
•         Object[] newArray = new Object[array.length * 2];
•         System.arraycopy(array, 0, newArray, 0, array.length);
•         array = newArray;
•     }
• }
• public class ObjectArrayExample {
•     public static void main(String[] args) {
•         ObjectArray<String> stringArray = new ObjectArray<>(2);
•         stringArray.add("Hello");
•         stringArray.add("World");
•         stringArray.add("!");
•         for (int i = 0; i < stringArray.size(); i++) {
•             System.out.println(stringArray.get(i));
•         }
•         ObjectArray<Integer> intArray = new ObjectArray<>(2);
•         intArray.add(1);
•         intArray.add(2);
•         intArray.add(3);
•         for (int i = 0; i < intArray.size(); i++) {
•             System.out.println(intArray.get(i));
•         }
•     }
• }
• /*
• ObjectArray 클래스는 제네릭을 사용하여 다양한 타입의 객체를 저장, 추가, 제거, 검색하는 기능을 제공합니다. resize 메소드는 내부 배열의 크기를 동적으로 조정합니다.
• */
• ArrayList 클래스 사용하기
  개념:
  ArrayList 클래스는 Java의 표준 라이브러리에서 제공하는 동적 배열을 다루기 위한 클래스입니다. 이 클래스는 자동으로 크기를 조정하며, 요소 추가, 제거, 검색 등의 기능을 제공합니다.
  예시:
  import java.util.ArrayList;
• public class ArrayListExample {
•     public static void main(String[] args) {
•         ArrayList<String> stringList = new ArrayList<>();
•         stringList.add("Apple");
•         stringList.add("Banana");
•         stringList.add("Cherry");
•         for (String fruit : stringList) {
•             System.out.println(fruit);
•         }
•         stringList.remove("Banana");
•         for (String fruit : stringList) {
•             System.out.println(fruit);
•         }
•         System.out.println("Size of the list: " + stringList.size());
•     }
• }
• /*
• ArrayList 클래스는 요소 추가, 제거, 검색, 크기 조정 등의 기능을 자동으로 처리합니다. 이를 통해 개발자는 배열을 쉽게 관리할 수 있습니다. ArrayList는 내부적으로 배열을 사용하지만, 크기가 자동으로 조정되므로 더 편리하게 사용할 수 있습니다.
• */

CH3.자바 String 클래스 사용하기

• 문자열 생성방법 2가지
  개념:
  자바에서 문자열을 생성하는 방법은 주로 두 가지가 있습니다. 첫 번째는 문자열 리터럴을 사용하는 방법이고, 두 번째는 new 키워드를 사용하여 String 객체를 생성하는 방법입니다.
  예시:
  /*1. 문자열 리터럴 사용하기*/
• public class StringLiteralExample {
•     public static void main(String[] args) {
•         // 문자열 리터럴로 문자열 생성
•         String str1 = "Hello, World!";
•         System.out.println(str1);
•     }
• }
• /*2. new 키워드를 사용하여 문자열 객체 생성하기*/
• public class StringObjectExample {
•     public static void main(String[] args) {
•         // new 키워드로 문자열 생성
•         String str2 = new String("Hello, World!");
•         System.out.println(str2);
•     }
• }
• /*str2는 new 키워드를 사용하여 새로운 String 객체를 생성합니다. 이 방법은 항상 새로운 객체를 생성합니다.*/
• String 클래스에서 제공하는 Method 활용하기
  개념:
  자바 String 클래스는 문자열을 조작할 수 있는 다양한 메소드를 제공합니다. 이러한 메소드는 문자열의 길이를 반환하거나, 특정 문자나 문자열을 찾거나, 문자열을 분리하거나 합치는 등의 기능을 합니다.
  예시:
  public class StringMethodsExample {
•     public static void main(String[] args) {
•         String str = "Hello, World!";
•         // 문자열의 길이를 반환
•         int length = str.length();
•         System.out.println("Length: " + length);
•         // 특정 문자 또는 문자열의 위치를 반환
•         int index = str.indexOf('o');
•         System.out.println("Index of 'o': " + index);
•         // 대소문자 변환
•         String upperStr = str.toUpperCase();
•         System.out.println("Uppercase: " + upperStr);
•         String lowerStr = str.toLowerCase();
•         System.out.println("Lowercase: " + lowerStr);
•         // 부분 문자열 추출
•         String substring = str.substring(7, 12);
•         System.out.println("Substring: " + substring);
•         // 문자열 치환
•         String replacedStr = str.replace("World", "Java");
•         System.out.println("Replaced: " + replacedStr);
•     }
• }
• /*
• length(), indexOf(), toUpperCase(), toLowerCase(), substring(), replace() 메소드를 사용하여 문자열을 조작했습니다.
• */
• 자바에서 문자열을 비교하는 방법
  개념:
  자바에서 문자열을 비교하는 방법에는 두 가지가 있습니다. 하나는 == 연산자를 사용하는 것이고, 다른 하나는 equals() 메소드를 사용하는 것입니다. == 연산자는 두 문자열 참조가 동일한 객체를 가리키는지를 확인하고, equals() 메소드는 두 문자열의 내용을 비교합니다.
  예시:
  public class StringComparisonExample {
•     public static void main(String[] args) {
•         String str1 = "Hello";
•         String str2 = "Hello";
•         String str3 = new String("Hello");
•         // == 연산자로 비교
•         System.out.println("str1 == str2: " + (str1 == str2)); // true
•         System.out.println("str1 == str3: " + (str1 == str3)); // false
•         // equals() 메소드로 비교
•         System.out.println("str1.equals(str2): " + str1.equals(str2)); // true
•         System.out.println("str1.equals(str3): " + str1.equals(str3)); // true
•     }
• }
• /*
• == 연산자는 두 문자열이 같은 객체인지 비교하고, equals() 메소드는 두 문자열의 내용이 같은지를 비교합니다.
• */
• 자바에서 문자열을 분리하는 방법
  개념:
  자바에서 문자열을 분리하는 방법은 split() 메소드를 사용하는 것입니다. split() 메소드는 지정한 구분자를 기준으로 문자열을 분리하여 배열로 반환합니다.
  예시:
  public class StringSplitExample {
•     public static void main(String[] args) {
•         String str = "apple,banana,cherry";
•         // 문자열을 콤마(,)로 분리
•         String[] fruits = str.split(",");
•         // 분리된 문자열 출력
•         for (String fruit : fruits) {
•             System.out.println(fruit);
•         }
•     }
• }
• /*
• split() 메소드를 사용하여 문자열을 콤마(,)로 분리하여 배열로 반환하고, for-each 문을 사용하여 배열의 각 요소를 출력합니다.
• */