Java/문법

[Java] 핵심 기본편 - 추상클래스와 인터페이스, 제네릭스(제네릭스, 제네릭 클래스, Wrapper 클래스, ArrayList, LinkedList, HashSet, HashMap, Iterator)

Se On 2024. 7. 2. 22:27

1. 추상클래스와 인터페이스

추상클래스

  • 추상클래스: 아직 완성되지 않은 클래스
  • abstract class 클래스명 {}
  • 아래 Shape 클래스는 완성되지 않은 추상 클래스지만, 상속하는 자식 클래스에서 메소드를 완성시켜 추상 클래스를 활용할 수 있음 
// 추상 클래스
abstract class Shape{ // Shape: 클래스
	abstract double calculateArea(); // calculateArea: 도형 크기를 재는 메소드
}

// 정사각형 클래스
class Square extends Shape { // Square: Shape 클래스 상속
    private double s; // 한 면의 길이
    public Square(double s) {
        this.s = s;
    }
    double calculateArea() {
        return s * s; // 면적 계산 메소드 완성
    }
}

// 원 클래스
class Circle extends Shape { // Circle: Shape 클래스 상속
    private double r; // 반지름
    public Circle(double r) {
        this.r = r;
    }
    double calculateArea() {
        return Math.PI * r * r; // 면적 계산 메소드 완성
    }
}

 

인터페이스

  • 인터페이스: 클래스를 작성할 때 기본이 되는 뼈대
  • interface 인터페이스명{}
    • implements를 통해서 구현할 수 있음
    • interface에 선언되어 있는 메소드를 구현하려는 클래스에서 모두 적용할 수 있음
// 위 추상 클래스 Shape을 인터페이스로 변경하기
interface Shape{
    double calculateArea();
}

// Shape 인터페이스를 구현하여 Square 클래스 만들기
class Square implements Shape {
    private double s;
    public Square(double s) {
        this.s = s;
    }
    double calculateArea() {
        return s * s;
    }
}

// Circle 클래스
class Circle implements Shape {
    private double r;
    public Circle(double r) {
        this.r = r;
    }
    double calculateArea() {
        return Math.PI * r * r;
    }
}

 

2. 제네릭스

제네릭스

  • 제네릭스: 다양한 형태의 데이터를 일반화하여 다룰 수 있게 해 주는 것
    • 장점: 코드의 재사용성을 높이고 타입 안정성을 확보할 수 있음
  • T 변수명
// 메인 메소드 - 세 개의 서로 형이 다른 변수
public static void main(String[] args) {
    int intValue = 3;
    double doubleValue = 3.14;
    String stringValue = "안녕";
    
    printValue(intValue);
    printValue(doubleValue);
    printValue(stringValue);
}

// 각 메소드의 형태는 int, double, String
public static void printValue(int value) { // int
	System.out.println(value);
}

public static void printValue(double value) { // double
	System.out.println(value);
}

public static void printValue(String value) { // String
	System.out.println(value);
}

// 위 상황에서 제네릭스 활용 가능!
public static <T> void pirntValue (T value) {
	System.out.println(value);
}

 

 

제네릭 클래스

  • 제네릭 클래스: 제네릭 기반 클래스(다양한 데이터 유형을 처리할 수 있도록 설계된 클래스)
  • class 클래스명 <T> {}
    • 제네릭 클래스를 사용하기 위해서는 클래스 뒤에 어떤 데이터를 담을지를 먼저 정의해 주어야 함
// BoxInteger 클래스: 정수를 담을 수 있음
class BoxInteger {
    int data;
    public void setData(int data) {
        this.data = data;
    }
}

// BoxString 클래스: 문자열을 담을 수 있음
class BoxString {
    String data;
    public void setData(String data) {
        this.data = data;
    }
}

// 메인 메소드 - 위 두 개의 클래스 사용하기
public static void main(String[] args) {
    BoxInteger iBox = new BoxInteger();
    iBox.setData(3); // 정수 담기
    
    BoxString sBox = new BoxString();
    sBox.setData("안녕"); // 문자열 담기
}

// 제네릭 클래스
class Box<T> { // 정수와 문자열 모두 담을 수 있는 Box 클래스
    T data;
    public void setData(T data) {
        this.data = data;
    }
}

public static void main(String[] args) {
    Box<Integer> iBox = new Box<>(); // <Integer> 정수 담기
    iBox.setData(3);
    
    Box<String> sBox = new Box<>(); // <String> 문자열 담기
    sBox.setData("안녕");
}

 

Wrapper 클래스

  • Wrapper 클래스: 기본 자료형을 객체로 Wrapping + 추가 기능을 제공하는 클래스
대표적인 Wrapper 클래스 감싸지는 자료형
Integer int
Double double
Character char 
// 메인 메소드
public static void main(String[] args) {
    int i = 1;
    double d = 1.0;
    char c = 'a';
}

// Wrapper 클래스로 변환하기
public static void main(String[] args) {
    Integer i = 1;
    Double d = 1.0;
    Character c = 'a';
    
    // 추가 기능
    System.out.println(i.intValue());
    System.out.println(d.intValue()); // double을 int로 변환하여 출력하기
    System.out.println(c.charValue());
}

 

ArrayList

  • ArrayList: 배열 기반 리스트, 빠른 접근 + 순차 저장
  • ArrayList<T>
    • Arraylist<String> list = new ArrayList<>();
// ArrayList<String>: 문자열을 담기 위한 ArrayList
public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<>();
    list.add("철수"); // list.add: list에 값을 추가
    list.add("영희");
    
    // 리스트 내 데이터 순회
    for (String s: list) {
        System.out.println(s);
    }
}
기능 설명 예시 결과
add 추가 list.add("철수"); {"철수"}
get 가져오기 list.get(0); "철수"
size 크기 list.size(); 1
set 수정 list.set(0, "영희"); {"영희"}
contains 포함 여부 list.contains("영희"); true
(미포함: false)
remove 삭제 list.remove("영희"); { }
clear 전체 삭제 list.clear(); { }

 

LinkedList

  • LinkedList: 연결 리스트, 데이터의 빠른 삽입 + 삭제
  • LinkedList<T>
    • LinkedList<String> list = new LinkedList<>();
// LinkedList
public static void main(String[] args) {
    LinkedList<String> list = new LinkedList<>();
    list.add("철수");
    list.add("영희");
    
    // 리스트 내 데이터 확인을 위한 for문
    for (String s: list) {
        System.out.println(s);
    }
}
기능 설명 예시 결과
add 추가 list.add("철수"); {"철수"}
get 가져오기 list.get(0); "철수"
getFirst 처음 요소 가져오기 list.getFirst(); "철수"
getLast 마지막 요소 가져오기 list.getLast(); "철수"
addFist 맨 앞에 추가하기 list.addFirst("영희"); {"영희", "철수"}
addLast 맨 뒤에 추가하기 list.addLast("영철"); {"영희", "철수", "영철"}
clear 전체 삭제 list.clear(); { }

 

HashSet

  • HashSet: 순서, 중복을 허용하지 않는 데이터의 집합
  • HashSet<T>
    • HashSet<String> set = new HashSet<>();
// HashSet
public static void main(String[] args) {
    HashSet<String> set = new HashSet<>();
    set.add("철수");
    set.add("영희");
    set.add("철수");
    // {"철수", "영희"} 중복 허용X
}
기능 설명 예시 결과
add 추가 set.add("철수"); {"철수"}
contains 포함 여부 set.contains("영희"); false
size 크기 set.size(); 1
remove 삭제 set.remove("철수"); { }
clear 전체 삭제 set.clear(); { }

 

HashMap

  • HashMap: (Key, Value)를 쌍으로 저장하는 자료구조, 중복X 순서X
  • HashMap<K, V>
    • HashMap<String, Integer> map = new HashMap<>();
// HashMap
public static void main(String[] args) {
    HashMap<String, Integer> map = new HashMap<>(); // <이름, 점수>
    map.put("철수", 100);
    map.put("영희", 90);
}

HashMap 결과

기능 설명 예시 결과
put 추가 map.put("철수", 100); {"철수":100}
size 크기 map.size(); 1
get 가져오기 map.get("철수"); 100
containsKey Key 포함 여부 map.containsKey("영희"); false
remove 삭제 map.remove("철수"); { }
clear 전체 삭제 map.clear(); { }

 

Iterator

  • Iterator: 컬렉션의 모든 데이터 순회
  • Iterator<T>
    • Iterator<String> it = list.iterator();
// ArrayList<String>: 문자열을 담기 위한 ArrayList
public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<>();
    list.add("철수"); // list.add: list에 값을 추가
    list.add("영희");
    
    // Iterator를 사용하여 리스트 내 데이터 순회
    Iterator<String> it = list.iterator();
    while (it.hasNext()) {
        System.out.println(it.next());
    }
}
기능 설명 예시 결과
hasNext 다음 요소 확인 it.hasNext() true
next 다음 요소 가져오기 it.next() "철수"
remove 삭제 it.remove() { }

 

참고 영상: 나도코딩 - 자바 무료 강의 2시간 완성(1분 자바)

https://youtu.be/DNCBaeCoMug?si=VM02QD9igeT561pp

 

 

반응형