build.gradle 파일은 Gradle 빌드 도구를 사용하는 프로젝트에서 프로젝트의 빌드 구성 및 관리를 위한 스크립트입니다

이 파일은 Grooby 또는 Kotlin DSL(Domain Specific Language)을 사용하여 작성되며, 프로젝트의 의존성 관리, 빌드 구성, 테스트 설정 등을 포함합니다

구조

일반적으로 build.gradle 파일은 다음과 같은 구조를 가집니다

plugins {
    id 'java'
}

repositories {
    jcenter()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

tasks {
    // 빌드 태스크 설정
}

위의 예제에서 `plugins`, `repositories`, `dependencies`, `tasks`는 각각 Gradle 빌드 스크립트에서 사용되는 섹션입니다

주요 섹션들

• plugins
  `plugins` 섹션은 Gradle 플러그인을 설정하는 데 사용됩니다
  예를 들어, Java 플러그인을 추가하려면 `id 'java'`와 같이 선언합니다
• repositories
  `repositories` 섹션은 프로젝트에서 사용할 외부 저장소(예: Maven Central, jCenter 등)를 설정합니다
  의존성을 해결하기 위해 Gradle은 여기에서 저장소를 검색합니다
• dependencies
  `dependencies` 섹션은 프로젝트의 의존성 관리를 설정합니다
  여기에는 프로젝트가 사용하는 외부 라이브러리 및 모듈의 의존성이 포함됩니다
• tasks
  `tasks` 섹션은 빌드 프로세스에서  수행할 작업을 정의합니다
  각 태스크는 특정한 빌드 작업을 수행하거나 다른 태스크에 의존하는 등의 작업을 정의할 수 있습니다

dependencies 설정

• implementation
  `implementation`는 프로덕션 코드에서 사용되는 의존성을 설정하는 데 사용됩니다
  이 의존성은 컴파일 시 클래스 경로에 포함되며, 런타임 시에는 애플리케이션의 클래스 패스에 추가됩니다
  주로 프로젝트의 핵심 기능에 필요한 라이브러리를 추가할 때 사용됩니다
• compileOnly
  `compileOnly`는 컴파일 시에만 사용되는 의존성을 설정하는 데 사용됩니다
  이 의존성은 컴파일 시에만 클래스 경로에 포함되며, 런타임 시에는 제외됩니다
  주로 컴파일 시에만 필요한 라이브러리를 추가할 때 사용됩니다
• testImplementation
  `testImplementation`은 테스트 코드에서 사용되는 의존성을 설정하는 데 사용됩니다
  이 의존성은 테스트 소스 코드의 클래스 경로에 포함되며, 테스트 시에만 사용됩니다
• runtimeOnly
  `runtimeOnly` 키워드는 런타임 시에만 사용되는 의존성을 설정하는 데 사용됩니다
  이 의존성은 컴파일 시에는 클래스 경로에 포함되지 않으며, 런타임 시에만 필요한 경우에 사용됩니다
  주로 애플리케이션의 실행 환경에 따라 필요한 라이브러리를 추가할 때 사용됩니다

JavaScript에서는 `undefined`, `null`, `NaN` 세 가지 요소가 있습니다

이들은 각각 다른 의미를 가지고 있으며, 주로 값이 없거나 잘못된 상태를 나타냅니다

이제 각각의 차이점과 특징에 대해 알아보겠습니다

undefined

`undefined`는 변수가 선언되었지만 값이 할당되지 않은 경우를 나타냅니다

즉, 변수가 존재하지만 어떤 값도 가지고 있지 않습니다

var x;
console.log(x); // undefined

• 변수의 초기값으로 자동 할당됩니다
• 변수가 할당되지 않았거나, 객체 속성이 존재하지 않을 때 반환됩니다
• `typeof undefined`의 결과는 `"undefined"`입니다

null

`null`은 명시적으로 "값이 없음"을 나타냅니다

따라서 `null`은 변수에 의도적으로 값이 없음을 할당하는 데 사용됩니다

var y = null;
console.log(y); // null

null == undefined // true
null === undefined // false

• `null`은 자바스크립트의 객체로 간주되며, `typeof null`의 결과는 `"object"`입니다
• 객체 속성의 초기값으로 사용할 수 있습니다
• `null`은 `undefined`와 다릅니다

NaN

`NaN`은 "Not a Number"의 약어로, 숫자가 아닌 값을 나타냅니다

주로 수학적인 연산이 실패했을 때 반환됩니다

console.log(10 / "hello"); // NaN

NaN == NaN // false

• 숫자와 문자열을 나누는 연산에서 발생할 수 있습니다
• `typeof NaN`의 결과는 `"number"`입니다
• `NaN`은 자신과의 동등 비교가 항상 `flase`입니다

use strict란?

JavaScript는 유연한 언어이지만, 때로는 코드의 실수나 잠재적인 오류를 찾아내기 어렵습니다

이러한 문제를 해결하기 위해 ECMAScript 5에서 "use strict"를 도입했습니다

이는 JavaScript 엔진에게 엄격한 모드로 실행하도록 지시합니다

use strict 사용 예제

"use strict"를 사용하려면 스크립트나 함수의 최상위에 선언해야 합니다

아래는 기본적인 사용법입니다

"use strict";

// 엄격 모드에서 실행될 코드

function myFunction() {
    "use strict";

    // 엄격 모드에서 실행될 코드
}

함수 내부에서 엄격 모드를 적용하려면 위와 같이 함수의 첫 줄에 선언합니다

use strict 사용 시 주요 변경 사항

• 변수 선언 시 var, let, const 키워드를 사용하지 않으면 오류가 발생합니다
• 변수가 선언되지 않은 상태에서 사용하면 오류가 발생합니다
• 객체의 속성을 삭제할 때에도 오류가 발생합니다
• 함수의 매개변수 이름이 중복되면 오류가 발생합니다
• eval() 함수의 사용이 제한됩니다
• 전역 객체의 this 값이 undefined가 됩니다
• "with" 문의 사용이 금지됩니다

결론

use strict는 JavaScript 코드를 더 엄격한 모드로 실행하여 코드 품질을 향상시키고 오류를 방지합니다

이는 개발자가 더욱 안정적이고 효율적인 코드를 작성할 수 있도록 도와줍니다

백틱은 템플릿 리터럴(template literal)이라고도 불리며, 문자열을 표현하는 새로운 방법을 제공합니다

백틱을 사용하면 문자열을 작성하는 동안 보간(interpolation)이나 여러 줄에 걸친 문자열을 쉽게 처리할 수 있습니다

표현식 삽입(Expression Interpolation)

백틱을 사용하여 `${}` 안에 변수나 표현식을 삽입하여 동적인 문자열을 생성할 수 있습니다

var name = 'John';
var greeting = `Hello, ${name}!`;

console.log(greeting); // 출력: Hello, John!

위 예제에서 `${name}`은 변수 `name`의 값을 삽입하여 출력됩니다

여러 줄 문자열(Multi-line Strings)

백틱을 사용하면 여러 줄에 걸친 문자열을 쉽게 작성할 수 있습니다

var multiLineString = `
    This is a
    multi-line
    string.
`;

console.log(multiLineString);

특수문자 처리

백틱을 사용하면 이스케이프 문자(\)를 사용하지 않고도 특수 문자를 삽입할 수 있습니다

var specialChars = `Backtick: \`, Single quote: ', Double quote: "`;

console.log(specialChars);

위 예제에서는 백틱 내에서 특수 문자를 사용하고 있습니다

안녕하세요!

이번 글에서는 Java 프로그래밍에서 중요한 개념 중 하나인 POJO(Plain Old Java Object)에 대해 알아보겠습니다

POJO는 간단하고 가벼운 객체를 의미하며, Java 객체지향 프로그래밍에서 핵심적인 역할을 합니다

이 개념을 이해하고 활용함으로써 더 효율적이고 유지보수가 쉬운 코드를 작성할 수 있습니다

POJO란 무엇인가?

POJO는 "Plain Old Java Object"의 약어로, 간단하게 설명하면 특별한 제약이나 규약이 없는 순수한 자바 클래스를 나타냅니다

이는 특정 프레임워크나 라이브러리에 종속되지 않고, 자바의 기본 기능만으로 정의된 객체입니다

POJO의 특징

1. 기본적인 자바 클래스 구조
   POJO는 일반적인 자바 클래스로, 특정 인터페이스를 구현하거나 특정 클래스를 상속받을 필요가 없습니다
2. 게터(Getter)와 세터(Setter) 메서드
   POJO 클래스는 필드에 접근하기 위한 게터와 세터 메서드를 제공하여 캡슐화를 지향합니다
3. 직렬화(Serialization) 가능
   POJO는 직렬화를 통해 객체를 저장하고 전송할 수 있도록 만들어져 있습니다
4. 테스트 용이성
   POJO는 특정 프레임워크나 환경에 종속되지 않기 때문에 단위 테스트에 용이합니다
   테스트 케이스에서 객체를 쉽게 생성하고 테스트할 수 있습니다
5. 가독성 및 유지보수성 향상
   POJO는 간단한 구조로 코드를 작성하므로 가독성이 좋고, 유지보수가 용이합니다
   특정 기술에 종속되지 않기 때문에 코드 변경이나 업데이트 시에도 유연하게 대처할 수 있습니다

POJO 예제

아래는 간단한 POJO 클래스의 예제입니다

public class Person {
    private String name;
    private int age;

    // 생성자, 게터, 세터 등 필요한 메서드 추가

    // 기본 생성자
    public Person() {}

    // 매개변수를 받는 생성자
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 게터와 세터
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

마무리

POJO는 자바의 객체지향 프로그래밍에서 중요한 개념 중 하나로 간결하면서도 효과적인 코드를 작성하는 데에 필수적입니다

POJO를 적절히 활용하여 코드의 가독성과 유지보수성을 향상시키며 자바 개발에서 더 나은 프로그래밍 경험을 만들어나갈 수 있습니다!

'==' (동등 연산자)

'=='는 동등 연산자로서 두 값이 동등한지 여부를 판단합니다

그러나 이 연산자는 형 변환을 수행하여 비교하므로 데이터 형식이 다를 경우 자동으로 형 변환이 이루어집니다

1 == '1'; // true

위의 예제에서는 '1'이라는 문자열과 1이라는 숫자가 서로 다른 데이터 형식이지만 '==' 연산자는 자동으로 형 변환을 수행하여 true를 반환합니다

'===' (일치 연산자)

'==='는 일치 연산자로서 값과 데이터 형식이 완전히 일치하는지를 판단합니다

이 연산자는 형 변환을 수행하지 않으므로 데이터 형식이 일치해야만 true를 반환합니다

1 === '1'; // false

위의 예제에서는 '===' 연산자는 데이터 형식이 다르기 때문에 false를 반환합니다

언제 어떤 연산자를 사용해야 하는가?

일반적으로 '==='를 사용하는 것이 권장됩니다

왜냐하면 '==='는 형 변환을 수행하지 않기 때문에 예상치 못한 결과를 방지할 수 있습니다

특히 데이터 형식이 중요한 경우에는 '==='를 사용하여 명시적인 일치를 확인하는 것이 좋습니다

그러나 '=='는 특정 상황에서 유용할 수 있습니다

예를 들어, null 또는 undefined 값을 확인할 때 '=='를 사용하면 형 변환이 수행되어 두 값이 동등한지를 판단할 수 있습니다

null == undefined; // true;
null === undefined; // false;

접근 제어자란?

접근 제어자는 클래스 멤버 (변수, 메서드)의 접근 권한을 제어하는 키워드입니다

Java에서는 크게 네 가지의 접근 제어자가 있습니다

• public: 어떤 클래스에서든 접근 가능
• protected: 같은 패키지 내에서 그리고 해당 클래스를 상속받은 외부 패키지의 클래스에서 접근 가능
• default (package-private): 같은 패키지 내에서만 접근 가능 (접근 제어자를 명시하지 않은 경우 기본 값)
• private: 같은 클래스 내에서만 접근 가능

각 접근 제어자의 활용

1. public

public class PublicExample {
    public int publicVariable;
    
    public void publicMethod() {
        // 메서드 내용
    }
}

다른 패키지의 클래스에서도 접근 가능한 공개된 멤버입니다

2. protected

public class ProtectedExample {
    protected int protectedVariable;
    
    protected void protectedMethod() {
        // 메서드 내용
    }
}

상속 관계에 있는 클래스에서도 접근 가능하며, 같은 패키지에서도 접근 가능합니다

3. dafault (package-private)

class DefaultExample {
    int defaultVariable;
    
    void defaultMethod() {
        // 메서드 내용
    }
}

접근 제어자를 명시하지 않으면 기본적으로 같은 패키지에서만 접근 가능한 멤버가 됩니다

4. private

public class PrivateExample {
    private int privateVariable;
    
    private void privateMethod() {
        // 메서드 내용
    }
}

같은 클래스 내에서만 접근 가능한 멤버로, 외부 클래스에서 직접 접근할 수 없습니다

접근 제어자의 선택 기준

적절한 접근 제어자를 선택하는 것은 클래스의 캡슐화를 지원하고 유지보수성을 높이는 데 중요합니다

항상 가장 낮은 접근 권한을 사용하는 것이 좋으며, 필요한 경우에만 더 높은 접근 권한을 허용하는 것이 좋습니다

접근 제어자는 프로그램의 보안성과 모듈성을 강화하는 데 중요한 역할을 합니다

올바르게 사용하면 코드의 유지보수성을 향상시킬 수 있습니다

Java Doc 주석이란?

Java Doc 주석은 자바 소스 코드에 추가되는 주석의 한 종류로, 코드에 대한 문서를 생성하는 데 사용됩니다

이 주석은 특별한 형식으로 작성되며, 주로 클래스, 메서드, 필드 등의 선언 부분에 위치합니다

Java Doc 주석을 이용하면 코드의 의도와 사용 방법, 관련된 주의사항 등을 명확하게 기술할 수 있습니다

Java Doc 주석 작성 방법

Java Doc 주석은 다음과 같은 형식을 따릅니다

/**
 * 여기에 주석 내용을 작성합니다.
 * 여러 줄로 작성 가능합니다.
 *
 * @author 작성자
 * @version 버전 정보
 * @param 매개변수명 매개변수 설명
 * @return 반환값 설명
 * @throws 예외타입 예외 설명
 */

여기서 `@author`, `@version`, `@param`, `@return`, `@throws` 등은 Java Doc  도구가 이 주석을 분석하여 문서를 생성할 때 사용되는 태그입니다

효과적인 Java Doc 주석의 예

/**
 * 계산기 클래스는 기본적인 사칙 연산을 수행합니다.
 * 이 클래스는 두 수를 입력으로 받아 덧셈, 뺄셈, 곱셈, 나눗셈을 수행할 수 있습니다.
 *
 * @author John Doe
 * @version 1.0
 */
public class Calculator {

    /**
     * 주어진 두 수를 더합니다.
     *
     * @param num1 첫 번째 숫자
     * @param num2 두 번째 숫자
     * @return 덧셈 결과
     */
    public int add(int num1, int num2) {
        return num1 + num2;
    }

    /**
     * 주어진 두 수를 뺍니다.
     *
     * @param num1 첫 번째 숫자
     * @param num2 두 번째 숫자
     * @return 뺄셈 결과
     */
    public int subtract(int num1, int num2) {
        return num1 - num2;
    }

    // 곱셈, 나눗셈 메서드에 대한 주석도 추가 가능
}

Java Doc 주석은 코드의 가독성을 향상시키고, 문서를 자동으로 생성하여 개발자들이 더 효율적으로 협업할 수 있도록 도와줍니다

주석을 작성할 때는 명확하고 간결하게 정보를 전달하도록 노력하며, 코드를 이해하기 쉽게 만드는 데에 주석이 큰 도움이 됩니다

Java Doc 주석을 적극적으로 활용하여 프로젝트의 유지보수성과 품질을 향상시킬 수 있습니다

어제 추상 클래스와 추상 메서드를 정리하면서 인터페이스와 추상 클래스의 차이점이 궁금해졌습니다

Java에서 인터페이스와 추상 클래스는 둘 다 추상화를 통한 객체 지향 프로그래밍의 핵심 개념입니다

그러나 이 둘은 목적과 특징에서 차이가 있습니다

이 글에서는 Java에서 인터페이스와 추상 클래스의 주요 차이점에 대해 알아보겠습니다

1. 인터페이스 (Interface)

인터페이스는 Java에서 다중 상속을 지원하고, 클래스 간의 계약(Contract)을 정의하는데 주로 사용됩니다

다음은 인터페이스의 주요 특징입니다

• 추상 메서드(Abstract Method): 모든 메서드가 추상 메서드로 선언되어 있습니다. 구현은 하위 클래스에서 이루어집니다
• 다중 상속: 여러 인터페이스를 구현할 수 있습니다
• 상수(Constant): 인터페이스에서는 상수를 정의할 수 있습니다. 이는 자동으로 `public static final`로 설정됩니다.
• 인터페이스 간 상속: 인터페이스는 다른 인터페이스를 확장할 수 있습니다

2. 추상 클래스 (Abstrct Class)

추상 클래스는 클래스이면서 일부 메서드가 구현되지 않고 추상 메서드로 남겨진 클래스입니다

다음은 추상 클래스의 주요 특징입니다

• 일반 메서드와 추상 메서드 혼합: 추상 클래스는 일반 메서드와 추상 메서드를 함께 포함할 수 있습니다
• 단일 상속: Java에서는 단일 상속만을 지원하므로, 추상 클래스도 이 조건을 따릅니다
• 인터페이스 구현 가능: 추상 클래스는 인터페이스를 구현할 수 있습니다

3. 사용 상황

인터페이스

다중 상속이 필요하건, 계약을 명확하게 정의해야 할 때 사용합니다

예를 들어 여러 클래스에서 공통적으로 구현해야 하는 메서드가 있을 때 유용합니다

추상 클래스

공통된 메서드 구현이 필요하며, 또한 상속을 통해 확장하고자 할 때 사용합니다

추상 클래스는 하위 클래스에게 일부 구현을 강제하고 나머지는 선택적으로 제공할 수 있습니다

안녕하세요!

이번 글에서는 Java의 추상 메서드에 대해 알아보겠습니다

추상 메서드는 객체지향 프로그래밍의 중요한 개념 중 하나로, 클래스를 설계하고 확장하는 데에 있어서 유용하게 활용됩니다

그럼 알아보도록 하겠습니다

추상 메서드란?

추상 메서드는 선언만 있고 본문이 없는 메서드입니다

이 메서드를 가진 클래스를 추상 클래스라고 부르며, 추상 클래스는 직접 객체를 생성할 수 없습니다

대신, 이 추상 클래스를 상속받은 하위 클래스에서 추상 메서드를 반드시 구현해야 객체를 생성할 수 있습니다

이를 통해 메서드의 일관성을 유지하고, 다형성을 구현할 수 있습니다

abstract class Shape {
    abstract void draw();
}

class Circle extends Shape {
    void draw() {
        System.out.println("원을 그립니다.");
    }
}

class Square extends Shape {
    void draw() {
        System.out.println("사각형을 그립니다.");
    }
}

위의 예제에서 Shape 클래스는 추상 메서드 draw를 가지고 있습니다

이 클래스를 상속받은 Circle과 Square 클래스에서는 반드시 draw 메서드를 구현해야 합니다

추상 클래스의 활용

1. 일관성 있는 디자인 구현: 여러 하위 클래스에서 동일한 메서드 시그니처를 유지하면서 각 클래스마다 다르게 구현할 수 있습니다
2. 다형성 구현: 추상 클래스를 상속받아 각자 다르게 구현된 메서드를 통해 다형성을 구현할 수 있습니다
3. 강제성 부여: 하위 클래스에서 반드시 구현해야 하는 메서드를 정의함으로써, 해당 메서드의 누락을 방지하고 안정성을 확보할 수 있습니다

추상 클래스와 인터페이스의 차이

Java에서는 인터페이스 역시 추상 메서드를 가질 수 있습니다

그러나 추상 클래스와 인터페이스의 큰 차이점 중 하나는 다중 상속을 지원하는지 여부입니다

추상 클래스는 단일 상속만을 허용하지만, 인터페이스는 다중 상속을 허용합니다

다중 상속이란, 자식 클래스가 둘 이상의 부모를 가지는 것을 의미합니다

interface Drawable {
    void draw();
}

class Circle implements Drawable {
    void draw() {
        System.out.println("원을 그립니다.");
    }
}

class Square implements Drawable {
    void draw() {
        System.out.println("사각형을 그립니다.");
    }
}

마무리

추상 메서드는 객체 지향 프로그래밍에서 클래스의 일관성을 유지하고, 다형성을 활용하기 위한 강력한 도구입니다

추상 클래스와 인터페이스를 통해 프로그램의 설계를 유연하게 할 수 있으며, 코드의 채사용성과 유지보수성을 향상시킬 수 있습니다

Java에서는 이러한 추상 메서드를 통해 높은 수준의 객체 지향 프로그래밍을 구현할 수 있습니다

for each 문을 사용하여 배열을 순회해 보자

public class Test02 {

	public static void main(String[] args) {

		int[] arr = new int[4];
		
		arr[0] = 7;
		arr[1] = 3;
		arr[2] = 9;
		arr[3] = 6;

		for (int num: arr) {
			System.out.println(num);
		}	
	}
}

배열에서 값을 num이란 변수로 하나씩 가져와서 루프를 돌고 있다

for문 대신에 for each 문을 쓰려면 값만 활용하는 상황이어야 한다

해당 값이 저장된 index나 특정 index의 값을 조회하는 건 어렵다

그리고 for문보다 for each 문이 성능이 좋기 때문에 간단한 코드인 경우에 더 선호될 거 같다

for each 문을 사용할 수 있는 자료구조는 iterable 인터페이스를 불러올 수 있어야 한다

iterable과 iterator에 대해서는 아래 블로그를 확인해 보자

https://coder-in-war.tistory.com/entry/Java-27-Iterable%EA%B3%BC-Iterator-%EC%9D%B8%ED%84%B0%ED%8E%98%EC%9D%B4%EC%8A%A4

new는 자바의 예약어이자 연산자이다
객체를 생성할 때 사용한다

간단하게 new를 활용해서 int형 배열을 선언해 보자

int[] arr = new int[3];

int형 변수를 선언하고 초기화하는 코드와 비교해 보자

int num = 4;

위에 두 라인이 유사함을 알 수 있다

(자료형) (변수명) = (초기화 값);

다만 배열의 경우 객체이기 때문에 초기화를 위해 new 키워드를 사용해 주었다

이번에는 컴퓨터 내부에서 데이터를 메모리에 어떻게 저장하는지 살펴보자

우선 스택 메모리와 힙 메모리가 있다

(메모리에 대한 자세한 내용은 나중에 따로 포스팅해보자)

아래 코드의 경우 메모리에 다음과 같이 저장된다

int num = 4;

스택 메모리에 num이란 이름의 공간을 배정하고 값을 저장했다

new 연산자를 활용한 아래 코드는 어떻게 동작하는지 나눠서 살펴보자

int[] arr = new int[3];

위 코드는 우선 `new int[3]` 부분이 동작한다

힙 메모리에 공간을 배정한다

그 이후에 힙 메모리의 주소값을 스택 메모리 공간에 저장한다

그래서 arr을 그대로 출력하면 사람이 알아볼 수 없는 복잡한 주소값을 보게 된다