<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
    <channel>
        <title>black_snake.log</title>
        <link>https://velog.io/</link>
        <description>"개발 관련 용어 간단 정리"가 이 블로그의 메인 컨텐츠입니다. 목표는 "개발자들의 위키백과"를 만드는 것입니다. 포스트를 읽는데 요구되는 시간이 대부분 1분 내외이므로, 개발 용어를 리마인드하고자 하면 제 포스트들을 여러 개 읽어보는 것을 추천합니다.　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　※ 주의 : 현재 velog 검색엔진의 문제로, 제 블로그에서 검색하면 제 글이 검색이 안됩니다. 해결법은 제 블로그의 소개글을 확인해주세요.</description>
        <lastBuildDate>Tue, 16 Jan 2024 11:31:49 GMT</lastBuildDate>
        <docs>https://validator.w3.org/feed/docs/rss2.html</docs>
        <generator>https://github.com/jpmonette/feed</generator>
        <copyright>Copyright (C) 2019. black_snake.log. All rights reserved.</copyright>
        <atom:link href="https://v2.velog.io/rss/black-snake" rel="self" type="application/rss+xml"/>
        <item>
            <title><![CDATA[Class]]></title>
            <link>https://velog.io/@black-snake/Class</link>
            <guid>https://velog.io/@black-snake/Class</guid>
            <pubDate>Tue, 16 Jan 2024 11:31:49 GMT</pubDate>
            <description><![CDATA[<h3 id="사전적-정의">사전적 정의</h3>
<blockquote>
<p>특정 객체를 생성하기 위해 변수와 메소드를 정의하는 일종의 틀(template)</p>
</blockquote>
<h3 id="용어-설명">용어 설명</h3>
<p>클래스는 <code>추상화</code>로 인해 상태와 행위가 제한된 객체이다. 추상화의 결과물이라고 할 수 있다.</p>
<h4 id="application-class">Application Class</h4>
<p><strong>Java 프로그램을 실행하기 위한 클래스</strong>이다. <code>main</code> 메소드를 갖고 있는 것이 특징이다. OOP와는 무관하다.</p>
<h4 id="bean-class">Bean Class</h4>
<p><strong>Object Modeling에 의해 현실 세계를 표현한 클래스</strong>이다. <code>OOP</code>를 목적으로 파생된 클래스이며, 현업에서 개발자들이 구현할 클래스는 대부분 Bean 클래스이다.</p>
<p>Bean Class는 main 메소드를 갖지 않는다. 그래서 Bean Class 스스로 실행할 수는 없다. 대신 Application Class에서 Bean Class를 참조하여 실행하게 된다. 참조 경로는 <code>classpath</code>에 의해 결정되며, default값은 .(현재 파일 디렉토리)이다. classpath는 OS의 환경변수에서 변경이 가능하다.</p>
<p>다음 글들을 보면 class를 이해하는데 큰 도움이 될 것이다.
oop
<a href="https://velog.io/@black-snake/Constructor%EC%83%9D%EC%84%B1%EC%9E%90">https://velog.io/@black-snake/Constructor%EC%83%9D%EC%84%B1%EC%9E%90</a>
<a href="https://velog.io/@black-snake/Model">https://velog.io/@black-snake/Model</a>
추상화
계층화</p>
]]></description>
        </item>
        <item>
            <title><![CDATA[Constructor(생성자)]]></title>
            <link>https://velog.io/@black-snake/Constructor%EC%83%9D%EC%84%B1%EC%9E%90</link>
            <guid>https://velog.io/@black-snake/Constructor%EC%83%9D%EC%84%B1%EC%9E%90</guid>
            <pubDate>Tue, 16 Jan 2024 11:09:52 GMT</pubDate>
            <description><![CDATA[<h3 id="사전적-정의">사전적 정의</h3>
<blockquote>
<p>인스턴스의 초기화를 담당하는 서브루틴</p>
</blockquote>
<h3 id="용어-설명">용어 설명</h3>
<p><strong>new 연산자로 인해 생성된 인스턴스를 해당 class로 <code>초기화</code>하기 위해 사용되는 특수 메소드</strong>이다. 오직 기본 생성자만 사용해도 문제는 없지만, 일일이 초기값을 set 해줘야 하기 때문에 개발에 큰 불편함을 야기한다. 생성자 메소드는 일반적인 메소드의 syntax를 갖고 있지는 않지만, 메소드의 성질을 모두 갖는 것이 특징이다. 그래서 생성자는 overloading도 가능하고, argument 대입도 가능하다. </p>
<p>생성자 메소드의 syntax는 아래와 같다.</p>
<pre><code class="language-java">Class identifier = new Class();</code></pre>
<p>항상 new 키워드를 앞에 붙이는 것이 특징이다. new 키워드가 없으면 메모리에 인스턴스가 할당되지 않기 때문에, 생성자 메소드가 실행될 수 없다.
<a href="https://velog.io/@black-snake/new">https://velog.io/@black-snake/new</a></p>
<p>아무런 생성자 메소드를 정의하지 않으면, Java에서 기본적으로 기본 생성자를 생성해준다. 하지만 최소 1개 이상의 생성자를 정의했으면 기본 생성자는 생성되지 않는다. 이러한 특징 때문에, 실무에서는 기본 메소드 호출을 보장하기 위해 기본 메소드를 명시하는 conversion이 있다고 한다.</p>
<p>아래의 글들을 보면 더욱 명확히 이해할 수 있을 것이다.
super vs this
getter setter
<a href="https://velog.io/@black-snake/.dot-operator">https://velog.io/@black-snake/.dot-operator</a>
overloading vs overriding</p>
]]></description>
        </item>
        <item>
            <title><![CDATA[Camal case VS Snake case]]></title>
            <link>https://velog.io/@black-snake/Camal-case-VS-Snake-case</link>
            <guid>https://velog.io/@black-snake/Camal-case-VS-Snake-case</guid>
            <pubDate>Tue, 16 Jan 2024 07:13:47 GMT</pubDate>
            <description><![CDATA[<h3 id="사전적-정의">사전적 정의</h3>
<blockquote>
<ul>
<li>Camel case : 파일, 변수, 함수 등 대상의 이름을 띄어쓰기 없이 짓기 위하여 따르는 관례</li>
</ul>
</blockquote>
<ul>
<li>Snake case : 파일, 변수, 함수 등 대상의 이름의 띄어쓰기를 언더바(_)로 표기하는 관례</li>
</ul>
<h3 id="용어-설명">용어 설명</h3>
<ul>
<li><p>Camel case </p>
<ul>
<li>Upper camel case : MyNameIsClass (관례적으로 class 명에 사용)</li>
<li>lower camel case : myNameIsMethod (관례적으로 필드, 메소드 명에 사용)</li>
</ul>
</li>
<li><p>Snake case : my_name_is_field (관례적으로 필드, 메소드 명에 사용)</p>
</li>
</ul>
]]></description>
        </item>
        <item>
            <title><![CDATA[객체 vs 인스턴스]]></title>
            <link>https://velog.io/@black-snake/%EA%B0%9D%EC%B2%B4-vs-%EC%9D%B8%EC%8A%A4%ED%84%B4%EC%8A%A4</link>
            <guid>https://velog.io/@black-snake/%EA%B0%9D%EC%B2%B4-vs-%EC%9D%B8%EC%8A%A4%ED%84%B4%EC%8A%A4</guid>
            <pubDate>Mon, 15 Jan 2024 11:26:17 GMT</pubDate>
            <description><![CDATA[<h3 id="사전적-정의">사전적 정의</h3>
<blockquote>
<ul>
<li>객체 : 특정 사실을 객관화하여 인식하거나 이해하는 대상</li>
</ul>
</blockquote>
<ul>
<li>인스턴스 : 실행 중인 임의의 프로세스, 클래스의 현재 생성된 오브젝트</li>
</ul>
<h3 id="용어-설명">용어 설명</h3>
<h4 id="객체">객체</h4>
<p>객체는 <strong><code>현실 세계(시스템)</code>에서 실제 인식할 수 있는 대상</strong>을 의미한다. OOP의 관점으로 보았을 때, 객체는 현실 세계를 디지털로 표현할 대상이라고 부를 수 있다. 현실 세계에서 객체의 개수는 무한대에 가깝다고 볼 수 있다.</p>
<p>객체는 다음과 같은 모든 대상을 지칭한다.</p>
<ul>
<li>물리적 객체</li>
<li>개념적 객체 (만져지지는 않지만, 그 개념이 없으면 시스템을 설명할 수 없는 것)</li>
<li>SW적 개념을 갖는 객체</li>
</ul>
<p>객체는 아래 3요소로 구성되어 있다.</p>
<ul>
<li>식별성 (identity)</li>
<li>상태 또는 속성 (state, attribute)</li>
<li>행위 (behavior)</li>
</ul>
<p>객체가 갖는 상태나 행위 역시 무한대에 가깝다. 현실 세계에서 객체는 저마다 정말 다양한 상태를 갖고, 다양한 행동을 할 수 있으니까.</p>
<p><em>객체에 대해 더 자세한 내용을 보고 싶다면, 제 블로그에 &#39;OOP&#39; 또는 &#39;객체지향&#39;이라고 검색해서 하나씩 살펴보시기 바랍니다.</em></p>
<h4 id="인스턴스">인스턴스</h4>
<p>인스턴스는 <strong><code>class</code>를 구현하여 메모리에 할당한 것</strong>이다. class는 객체를 추상화한 것으로, domain에 따라 제한된 상태와 행위를 갖는다. 즉, <strong>객체와 달리 인스턴스는 유한한 상태와 행위를 갖는 것이 가장 뚜렷한 차이점</strong>이다. 인스턴스에서 상태는 &#39;필드 또는 멤버 변수&#39;, 행위는 &#39;메소드&#39;라고 부른다.</p>
<h4 id="결론">결론</h4>
<p><strong>객체는 analog, 인스턴스는 digital</strong>라고 생각하면 그 차이를 정말 쉽게 이해할 수 있다.</p>
<h3 id="참고문헌">참고문헌</h3>
<p><a href="https://iosdevlime.tistory.com/entry/CSBasic-%EB%84%88%EC%99%80-%EB%82%98-%EC%9A%B0%EB%A6%AC-%EB%AA%A8%EB%91%90-%EA%B0%9D%EC%B2%B4Object">https://iosdevlime.tistory.com/entry/CSBasic-%EB%84%88%EC%99%80-%EB%82%98-%EC%9A%B0%EB%A6%AC-%EB%AA%A8%EB%91%90-%EA%B0%9D%EC%B2%B4Object</a></p>
]]></description>
        </item>
        <item>
            <title><![CDATA[IDE(통합 개발 환경)]]></title>
            <link>https://velog.io/@black-snake/IDE%ED%86%B5%ED%95%A9-%EA%B0%9C%EB%B0%9C-%ED%99%98%EA%B2%BD</link>
            <guid>https://velog.io/@black-snake/IDE%ED%86%B5%ED%95%A9-%EA%B0%9C%EB%B0%9C-%ED%99%98%EA%B2%BD</guid>
            <pubDate>Sun, 14 Jan 2024 14:54:30 GMT</pubDate>
            <description><![CDATA[<h3 id="사전적-정의">사전적 정의</h3>
<blockquote>
<p>프로그램 개발에 관련된 모든 작업을 하나의 프로그램 안에서 처리하는 환경을 제공하는 소프트웨어</p>
</blockquote>
<h3 id="용어-설명">용어 설명</h3>
<p>코딩, 디버그, 컴파일, 배포 등 모든 것들을 IDE 안에서 처리하기 쉽게 도와준다. 하지만 진정한 개발자라면 IDE를 쓰지않고 개발환경 세팅부터 컴파일, 프로그램 실행까지는 직접 해낼 수 있어야 한다고 생각한다. IDE에 의존적인 개발을 하다보면, 나중에 개발 환경이나 시스템 부분에서 에러가 났을 때 발빠르게 대처하기 어렵기 때문이다.</p>
]]></description>
        </item>
        <item>
            <title><![CDATA[.(dot operator)]]></title>
            <link>https://velog.io/@black-snake/.dot-operator</link>
            <guid>https://velog.io/@black-snake/.dot-operator</guid>
            <pubDate>Sun, 14 Jan 2024 14:50:08 GMT</pubDate>
            <description><![CDATA[<h3 id="사전적-정의">사전적 정의</h3>
<blockquote>
<p>In programming, the dot operator (.) is used to access</p>
</blockquote>
<h3 id="용어-설명">용어 설명</h3>
<p><strong>객체의 필드나 메소드에 접근하기 위해 사용한다.</strong> </p>
<pre><code class="language-java">public class MyClass {
    public int myField = 0;

    public void myMethod() {
        System.out.println(&quot;Hello World&quot;);
    }
}</code></pre>
<p>이렇게 생긴 클래스가 있다고 하자. 그러면 메인 클래스에서 이 클래스를 호출하려면 다음과 같이 <strong>dot operator</strong>를 사용하면 된다.</p>
<pre><code class="language-java">public class Main {
    public static void main() {
        MyClass myInstance = new MyClass();
        System.out.println(myInstance.myField);  // 0
        myInstance.myMethod();  // Hello World
    }
}</code></pre>
<p>이건 이해하기보다는 많이 코딩하면서 익숙해지는 <strong>사용법</strong>이라고 생각한다. </p>
]]></description>
        </item>
        <item>
            <title><![CDATA[prefix, suffix]]></title>
            <link>https://velog.io/@black-snake/prefix-suffix</link>
            <guid>https://velog.io/@black-snake/prefix-suffix</guid>
            <pubDate>Sun, 14 Jan 2024 14:40:02 GMT</pubDate>
            <description><![CDATA[<h3 id="사전적-정의">사전적 정의</h3>
<blockquote>
<ul>
<li>prefix : 접두사</li>
</ul>
</blockquote>
<ul>
<li>suffix : 접미사</li>
</ul>
<h3 id="용어-설명">용어 설명</h3>
<p>개발자들 사이에서는 prefix를 경로 설정, suffix를 확장자 설정에 주로 사용한다.</p>
<pre><code>spring.mvc.view.prefix=/WEB-INF/jsp/
spring.mvc.view.suffix=.jsp</code></pre><p>컴퓨터와 개발자 입장에서 항상 경로를 맨 처음에 고려해야 하고, 항상 확장자가 맨 마지막에 고려해야 하니까 그런 것 같다. </p>
<h3 id="참고문헌">참고문헌</h3>
<p><a href="https://developer-rooney.tistory.com/187">https://developer-rooney.tistory.com/187</a></p>
]]></description>
        </item>
        <item>
            <title><![CDATA[new]]></title>
            <link>https://velog.io/@black-snake/new</link>
            <guid>https://velog.io/@black-snake/new</guid>
            <pubDate>Sun, 14 Jan 2024 14:34:12 GMT</pubDate>
            <description><![CDATA[<h3 id="사전적-정의">사전적 정의</h3>
<blockquote>
<p>사용자 정의 객체 타입 또는 내장 객체 타입의 인스턴스를 생성</p>
</blockquote>
<h3 id="용어-설명">용어 설명</h3>
<p><strong>new 연산자는 인스턴스를 만들고, 그것의 참조값을 반환한다.</strong></p>
<p>다만 인스턴스를 만드는 것과, 인스턴스를 할당하는 것은 다른 개념다.</p>
<pre><code class="language-java">MyClass a;  // declaration
a = new MyClass();  // assignment</code></pre>
<p>new 연산자는 인스턴스를 선언하는 것이 아니다. 인스턴스를 생성하고, 그것의 참조값(주소값)을 리턴할 뿐이다. 이것을 명확히 구분할 수 있어야 new 연산자가 책임을 지는 범위를 명확히 이해할 수 있을 것이다.</p>
<p>아래의 포스트를 참고하면 더 깊은 이해가 가능하다.
<a href="https://velog.io/@black-snake/%EA%B0%9D%EC%B2%B4-vs-%EC%9D%B8%EC%8A%A4%ED%84%B4%EC%8A%A4">https://velog.io/@black-snake/%EA%B0%9D%EC%B2%B4-vs-%EC%9D%B8%EC%8A%A4%ED%84%B4%EC%8A%A4</a></p>
]]></description>
        </item>
        <item>
            <title><![CDATA[Type casting(형변환)]]></title>
            <link>https://velog.io/@black-snake/Type-casting%ED%98%95%EB%B3%80%ED%99%98</link>
            <guid>https://velog.io/@black-snake/Type-casting%ED%98%95%EB%B3%80%ED%99%98</guid>
            <pubDate>Sun, 14 Jan 2024 14:25:41 GMT</pubDate>
            <description><![CDATA[<h3 id="사전적-정의">사전적 정의</h3>
<blockquote>
<p>자료형을 다른 형태로 변경하는 것</p>
</blockquote>
<h3 id="용어-설명">용어 설명</h3>
<p>Java에서 형변환을 하는 방법은 크게 두 가지가 있다.</p>
<ul>
<li>Implicit Casting (묵시적 형변환)</li>
<li>Explicit Casting (명시적 형변환)</li>
</ul>
<h4 id="implicit-casting-묵시적-형변환">Implicit Casting (묵시적 형변환)</h4>
<blockquote>
<p>컴파일러가 자동으로 변환하는 형변환</p>
</blockquote>
<pre><code class="language-java">byte a = 1;</code></pre>
<p>혹시 여기서 숫자 1의 data type을 생각해본 적이 있는가? Java에서는 정수의 기본 타입을 int로 지정하고 있다. 고로 위 코드에서 1의 data type은 <code>int</code> 이다. 즉, 위 코드는 int 타입 값을 byte 타입에 넣으려고 시도하는 것이다. 이 과정에서 프로그램은 int 타입인 1을 byte 타입으로 <code>묵시적 형변환</code>을 하여 값을 집어넣게 되는 것이다. </p>
<p>Casting을 하는 경우 data type의 크기를 고려할 필요가 있는데, 그건 다음 형변환 방식을 설명하면서 함께 정리하겠다.</p>
<h4 id="explicit-casting-명시적-형변환">Explicit Casting (명시적 형변환)</h4>
<blockquote>
<p>프로그래머가 직접 명령하는 형변환</p>
</blockquote>
<pre><code class="language-java">double a = 1.0;
int b = a; </code></pre>
<p>이 코드를 컴파일해보면, 아래와 같은 에러를 반환한다.</p>
<pre><code>error: incompatible types: possible lossy conversion from double to int</code></pre><p>double을 int형으로 변환하는 과정에서 문제가 있다는 내용이다. 앞서 int에서 double은 됐는데 왜 그 역은 안되는 걸까? int는 4bytes이고, double은 8bytes이다. 이는 double이 갖고 있는 정보의 크기가 더 크다는 것이다. 작은 물컵에서 큰 물컵으로 물을 옮기는 데에는 문제가 없지만, <strong>큰 물컵에서 작은 물컵으로 물을 옮길 때에는 물이 흘러 넘칠 경우가 생길 수 있지 않겠는가?</strong> 여기서도 정확히 동일한 원리로 문제가 생기는 것이다. 현재 위 코드에서는 크기가 큰 자료형에서 작은 자료형으로 값을 넘겨주려다보니, 컴파일러가 문제가 있을 수 있다고 경고하는 것이다.</p>
<p>하지만 큰 물컵에 들어있는 물의 양이 충분히 적다면, 작은 물컵으로 물을 옮기는데 문제가 없는 경우도 있을 것이다. 개발자가 확실하게 형변환을 하는데 있어 문제가 없다고 판단되는 경우, 우리는 <code>명시적 형변환</code>을 통해 컴파일러를 무시하고 강제로 형변환을 시킬 수 있다.</p>
<pre><code class="language-java">double a = 1.0;
int b = (int) a;  // b = 1</code></pre>
<p>&#39;1.0&#39;이라는 값은 1이라는 정수로 바꿔도 전혀 문제가 없다. 이런 경우 해당 값을 int 형으로 받아줄 수 있다. 명시적 형변환을 하기 위해서는 대입하려는 변수명 앞에 casting operator인 <code>(data type)</code>을 사용해줘야 한다. </p>
<p>하지만 앞서 말했듯, 데이터 손실이 우려될 가능성이 있는 로직을 다루고 있다면 함부로 명시적 형변환을 진행해서는 안될 것이다. Casting을 할 때는 항상 데이터 크기를 고려하면서 작업하도록 하자.</p>
<h4 id="reference-타입에서의-형변환">reference 타입에서의 형변환</h4>
<p>위에서는 단순히 primitive data type로 예제를 들었다. 하지만 Reference data type에서도 형변환이 가능하다. 근데 이 경우에는 <code>개념적 크기</code>에 따라서 casting의 안전성을 따져야 한다. 개념적으로 더 큰 클래스를 <code>부모 클래스</code>, 내용이 더 구체적인 클래스를 <code>자식 클래스</code>라고 부른다. </p>
<p>&#39;동물&#39;과 &#39;새&#39; 중 동물이 개념적으로 크다는 것은 직관적으로 알 수 있다. 하지만 만약 두 클래스를 모두 구현해야 한다면, 좀 더 구체적인 새 class 쪽이 더 큰 데이터를 보유하고 있을 것이다. </p>
<pre><code class="language-java">class Animal {
    String name;
}

class Bird extends animal{
    String wings;
}

public class Test {
    public static void main(String[] args) {
        Animal a = new Animal();
        Bird b = new Bird();
        Animal c = b;  // Animal로 묵시적 형변환됨
        // Bird d = a;  // error 발생

        Bird d = (Bird) c;  // 되돌리는 형태의 casting의 경우, 다시 자식 클래스로 명시적 형변환 가능
    }
}</code></pre>
<p>위 코드를 보면 bird 클래스는 name 필드까지 포함하고 있기 때문에, 분명히 bird 클래스로 구현된 인스턴스는 animal 클래스로 구현된 것보다 클 것이다. 하지만 primitive data type의 경우 작은 쪽에서 큰 쪽으로 casting하는데 data적인 측면에서 전혀 문제가 발생하지 않지만, reference data type의 경우 작은 쪽에서 큰 쪽으로 casting하면 기존에 전혀 없던 필드랑 메소드를 마주해야 한다. 이렇듯 reference data type은 확장을 해버리면 예측 불가능한 환경을 마주해야 하기 때문에 상식적으로 불가능하다는 것을 느낄 수 있다. </p>
<p>반면 자식에서 부모 클래스로 명시적 casting은 가능하다. 그런데 primitive type과 다르게, 자식에서 부모 자료형으로 변환한다 해도 메모리상에서 실질적으로 데이터가 사라지지는 않는다. 그저 개념적으로 자식 클래스에만 있는 필드나 메소드를 호출할 수 없게될 뿐이다. 그래서, 이 상태에서 <strong>다시 자식 클래스로 명시적 casting을 하게 되면 다시 이전 상태로 되돌릴 수 있게 된다!</strong></p>
<p><em>C언어의 구조체를 떠올리면 충분히 납득할 수 있을 것이다. 만약 직관적으로 이해가 안 간다면, 제 블로그의 OOP 포스트를 쭉 읽어보시면서 데이터 크기를 비교해보기 바란다. 그냥 내용 자체도 매우 좋으니 읽어보는 것을 강추.</em></p>
<h4 id="primitive-type-vs-reference-type">primitive type VS reference type</h4>
<ul>
<li>primitive type은 <code>데이터 크기</code>가 작은 쪽에서 큰 쪽으로 가는 것을 허용.</li>
<li>reference type은 <code>개념적 크기</code>가 작은 쪽에서 큰 쪽으로 가는 것을 허용.</li>
</ul>
<h4 id="casting-연산자의-우선순위">casting 연산자의 우선순위</h4>
<p>casting 연산자는 매우 높은 우선순위를 갖고 있다. 웬만한 것들보다 우선적으로 실행된다.</p>
<pre><code class="language-java">int a = 201/2;  // 100
double b = 201.0/2;  // 100.5
double c = (double) 201/2;  // 100.5
double d = (double) (201/2);  // 100.0</code></pre>
<p>*<em>몫 연산자는 정수 연산에 대해서는 소수점을 버리지만, 실수 연산에서는 정상적인 나머지 연산을 수행한다는 것을 알아두자. 그리고 데이터 크기가 큰 쪽으로 연산 결과가 나온다는 것도 알아두자. *</em>변수 a와 b를 통해 그 특징을 확인해볼 수 있다. </p>
<p>이제 연산의 우선순위도 확인해보자. 변수 c와 d를 비교해보면, d는 연산식이 소괄호로 묶여있는 것을 확인할 수 있다. casting 연산자의 우선순위는 소괄호보다 느리다. 그러므로 casting 연산자를 활용하면 먼저 정수 연산을 한 후에 그 값을 실수값으로 만들던지, 그냥 실수 연산을 먼저 진행할지 개발자가 선택할 수 있다.</p>
]]></description>
        </item>
        <item>
            <title><![CDATA[Call by value, Call by reference]]></title>
            <link>https://velog.io/@black-snake/Call-by-value-Call-by-reference</link>
            <guid>https://velog.io/@black-snake/Call-by-value-Call-by-reference</guid>
            <pubDate>Sun, 14 Jan 2024 09:03:10 GMT</pubDate>
            <description><![CDATA[<h3 id="사전적-정의">사전적 정의</h3>
<blockquote>
<ul>
<li>Call by value : 해당 인자가 갖고 있는 값을 새로운 메모리 공간에 복사하고 호출 = 깊은 복사</li>
</ul>
</blockquote>
<ul>
<li>Call by reference : 해당 인자의 참조값(주소값)을 복사하여 호출 = 얕은 복사</li>
</ul>
<h3 id="용어-설명">용어 설명</h3>
<p>우리가 어떤 변수나 객체를 제어하기 위해 접근하는 방식은 딱 두 가지 방식밖에 없다.</p>
<ol>
<li>해당 변수나 객체가 갖고 있는 값을 복사한 후 독립적으로 제어하기 (= 깊은 복사)</li>
<li>해당 변수나 객체의 참조값을 파악하여 메모리를 직접적으로 제어하기 (= 얕은 복사)</li>
</ol>
<p>두 방식 중 어떤 방식이 좋은가는 개발자의 의도에 따라 달라질 것이다. 어떤 변수가 안전을 보장해야 한다면 깊은 복사로 안정적인 수행이 이뤄지도록 하는 것이 좋을 것이고, 공유 자원을 통해 여러 리소스들을 효율적으로 관리해야 한다면 얕은 복사 방식으로 접근하는 것이 좋을 것이다.</p>
]]></description>
        </item>
        <item>
            <title><![CDATA[Identifier (식별자)]]></title>
            <link>https://velog.io/@black-snake/Identifier-%EC%8B%9D%EB%B3%84%EC%9E%90</link>
            <guid>https://velog.io/@black-snake/Identifier-%EC%8B%9D%EB%B3%84%EC%9E%90</guid>
            <pubDate>Sun, 14 Jan 2024 08:52:35 GMT</pubDate>
            <description><![CDATA[<h3 id="사전적-정의">사전적 정의</h3>
<blockquote>
<p>코드에 존재하는 변수, 자료형, 서브루틴 등을 가리키는 토큰</p>
</blockquote>
<h3 id="용어-설명">용어 설명</h3>
<p>흔히 사용하는 변수명, 메소드명, 클래스명 등을 모두 <code>식별자</code>라고 부를 수 있다. 말 그대로, 무언가를 구분하기 위해 사용하는 이름이니까. 특히 개발자 입장에서는 무언가를 식별하는 목적이 대상을 구분하여 호출하기 위한 목적이 크다.</p>
]]></description>
        </item>
        <item>
            <title><![CDATA[echo]]></title>
            <link>https://velog.io/@black-snake/echo</link>
            <guid>https://velog.io/@black-snake/echo</guid>
            <pubDate>Sun, 14 Jan 2024 08:48:12 GMT</pubDate>
            <description><![CDATA[<h3 id="사전적-정의">사전적 정의</h3>
<blockquote>
<p>(유닉스 계열) 문자열을 컴퓨터 터미널에 출력하는 명령어</p>
</blockquote>
<h3 id="용어-설명">용어 설명</h3>
<h4 id="1-따라하기">1. 따라하기</h4>
<pre><code>$ echo hello world
hello world</code></pre><p>기본적으로는 echo 뒤에 입력한 문자열을 그대로 출력하는 기능을 갖고 있다.</p>
<h4 id="2-환경변수값-출력하기">2. 환경변수값 출력하기</h4>
<pre><code>$ echo $HOME
/root</code></pre><p>어떤 변수가 갖고 있는 값을 출력하도록 명령할 수 있다. 리눅스에서는 echo 뒤 인자를 <code>$변수명</code> 형식으로 입력해줘야 한다. <strong>Windows</strong>에서도 echo 기능을 지원하는데, 이 경우에는 <code>%변수명%</code> 형식으로 인자를 입력해줘야 한다.
&#39;printenv&#39; 라는 키워드로도 동일한 작업을 수행할 수 있다. 이 경우 변수명을 있는 그대로 인자에 입력해주면 된다.</p>
<pre><code>$ printenv HOME
/root</code></pre><h4 id="3-파일-생성">3. 파일 생성</h4>
<pre><code>$ echo &quot;Hello World!&quot; &gt; test.txt
$ cat test.txt
Hello World</code></pre><p>입력한 문자열 내용을 바탕으로 파일에 만들어 저장한다. 여기서 <code>&gt;</code>와 <code>&gt;&gt;</code>에 따라 약간 다른 동작을 수행한다.</p>
<ul>
<li><code>&gt;</code> : 기존 파일이 있다면 덮어쓴다.</li>
<li><code>&gt;&gt;</code> : 기존 파일이 있다면 이어 쓴다.</li>
</ul>
]]></description>
        </item>
        <item>
            <title><![CDATA[Alias]]></title>
            <link>https://velog.io/@black-snake/Alias</link>
            <guid>https://velog.io/@black-snake/Alias</guid>
            <pubDate>Sun, 14 Jan 2024 03:27:31 GMT</pubDate>
            <description><![CDATA[<h3 id="사전적-정의">사전적 정의</h3>
<blockquote>
<ol>
<li>가명, 별명</li>
<li>(리눅스) 시스템 명령어를 단축시키거나, 다른 이름으로 부르기 위해 사용하는 명령어</li>
</ol>
</blockquote>
<h3 id="용어-설명">용어 설명</h3>
<p>Alias는 어떤 무언가를 보다 <code>직관적</code>으로 가리키기 위해 사용하는 <code>식별자</code>라고 보면 된다. </p>
<p>예를 들어, 어떤 배열 객체의 실제 이름은 사실상 해당 객체의 메모리 참조값(주소값)이다. 그 친구의 주소값이 &#39;0x12345678&#39;이라면, 내가 0x12345678을 호출하면 그 친구가 반응을 할 것이다. 하지만 우리는 각각의 배열의 주소값을 일일이 외워서 호출할 수는 없다. 이 문제를 해결하는 방법으로 alias를 적용하는 것이다.</p>
<pre><code class="language-java">int[] arr = new int[5];</code></pre>
<p>이런 식으로 declaration을 한다면, 앞으로 해당 객체를 호출할 때마다 실제 주소값이 아닌, &#39;arr&#39;이라는 가명을 사용해서 직관적으로 호출할 수 있게 되는 것이다.</p>
<hr>
<p>리눅스에서는 &#39;alias&#39;라는 키워드가 존재한다. 이 키워드를 사용하면 마치 매크로를 사용하듯 내맘대로 명령어를 정의할 수 있게 된다. (해당 shell 세션이 생존하는 동안에만 유효)</p>
<pre><code class="language-linux">alias ls = &#39;ls -a&#39;</code></pre>
<p>위 명령어를 입력한다면, 앞으로의 ls 명령어는 전부 &quot;ls -a
로 실행하게 된다. path처럼 굳이 지정하지 않아도 되긴 하지만, 잘 활용한다면 리눅스를 보다 편리하게 사용할 수 있을지도 모른다.</p>
<p>해당 alias를 제거하고 싶으면 unalias 명령어를 사용하면 된다.</p>
<pre><code>unalias ls</code></pre>]]></description>
        </item>
        <item>
            <title><![CDATA[Console (콘솔)]]></title>
            <link>https://velog.io/@black-snake/Console-%EC%BD%98</link>
            <guid>https://velog.io/@black-snake/Console-%EC%BD%98</guid>
            <pubDate>Sun, 14 Jan 2024 03:10:11 GMT</pubDate>
            <description><![CDATA[<h3 id="사전적-정의">사전적 정의</h3>
<blockquote>
<ol>
<li>컴퓨터를 동작시키는 모든 물리 (입력/출력) 장치. 즉 단말기.</li>
<li>터미널</li>
<li>CLI(Command Line Interface, 명령 줄 인터페이스)</li>
</ol>
</blockquote>
<h3 id="용어-설명">용어 설명</h3>
<p>콘솔이라는 용어가 가리키는 것이 정말 다양해서 헷갈릴 수 있다. 개발자들은 콘솔이라는 용어를 주로 CLI를 지칭하는 목적으로 사용할 것이다. 하지만 더 광범위한 개념으로, 모니터, 키보드, 마우스를 전부 콘솔이라고 부를 수 있다. 어떤 형태든 <strong>&quot;컴퓨터와 상호작용할 수 있는 모든 인터페이스&quot;</strong>를 콘솔로 부를 수 있다고 보면 된다. 하지만 개발자들 사이에서는 콘솔이라는 용어가 곧 CLI를 지칭한다고 봐도 무방하긴 하다.</p>
<p>p.s. 본인의 업무 환경에 맞춰 적절히 용어를 사용하고, 또한 잘 알아들을 수 있도록 하자.</p>
]]></description>
        </item>
        <item>
            <title><![CDATA[Assignment (대입)]]></title>
            <link>https://velog.io/@black-snake/Assignment-%EB%8C%80%EC%9E%85</link>
            <guid>https://velog.io/@black-snake/Assignment-%EB%8C%80%EC%9E%85</guid>
            <pubDate>Fri, 12 Jan 2024 12:42:26 GMT</pubDate>
            <description><![CDATA[<h3 id="용어-설명">용어 설명</h3>
<pre><code>int a;  // declaration
a = 10;  // assignment

int b = 20;</code></pre><p>선언되어 있는 변수 따위의 것에 어떤 값을 넣는 것을 <code>대입</code>이라고 한다. 선언 따로 대입 따로 해도 되고, 선언과 대입을 한 번에 해도 된다. 하지만 값이 없는 문제(null 문제)를 피하려면 선언과 대입을 한 번에 하는 방식을 추천한다.</p>
]]></description>
        </item>
        <item>
            <title><![CDATA[Declaration (선언)]]></title>
            <link>https://velog.io/@black-snake/Declaration-%EC%84%A0%EC%96%B8</link>
            <guid>https://velog.io/@black-snake/Declaration-%EC%84%A0%EC%96%B8</guid>
            <pubDate>Fri, 12 Jan 2024 12:39:52 GMT</pubDate>
            <description><![CDATA[<h3 id="용어-설명">용어 설명</h3>
<pre><code>int a;</code></pre><p>단순히 식별자 이름과, 그것의 datatype을 정의하는 것. 이것을 선언이라고 한다.</p>
]]></description>
        </item>
        <item>
            <title><![CDATA[Keyword(예약어)]]></title>
            <link>https://velog.io/@black-snake/Keyword%EC%98%88%EC%95%BD%EC%96%B4</link>
            <guid>https://velog.io/@black-snake/Keyword%EC%98%88%EC%95%BD%EC%96%B4</guid>
            <pubDate>Fri, 12 Jan 2024 12:31:04 GMT</pubDate>
            <description><![CDATA[<h3 id="사전적-정의">사전적 정의</h3>
<blockquote>
<p>컴퓨터 프로그램용으로 고정된 예약어이자 식별자로, 개발할 때 직접 사용할 수 없는 단어.</p>
</blockquote>
<h3 id="용어-설명">용어 설명</h3>
<p>예약어 문제는 최초로 서버와 DB를 연결하여 sql을 사용하는 경우 쉽게 접하게 된다. <del>적어도 나는 그랬다.</del> 백서버 개발 시 user 도메인은 피할 수 없는 설계 대상인데, sql에서는 user가 keyword다. 근데 &quot;user&quot;라는 이름의 필드를 정의한 상태로 SQLMapper나 ORM을 사용하여 빌드하여 DB와 연결하면, 분명 문제가 없는 쿼리문인데 자꾸 에러가 발생하게 될 것이다.</p>
<p>예약어 문제는 어쩔 수 없다. 해당 언어에 친숙해질 때까지는 계속 삽질하게 될 것이다.</p>
]]></description>
        </item>
        <item>
            <title><![CDATA[Path(경로)]]></title>
            <link>https://velog.io/@black-snake/Path</link>
            <guid>https://velog.io/@black-snake/Path</guid>
            <pubDate>Fri, 12 Jan 2024 12:21:13 GMT</pubDate>
            <description><![CDATA[<h3 id="사전적-정의">사전적 정의</h3>
<blockquote>
<ol>
<li>파일이나 디렉터리의 일반적인 형태로써, 파일 시스템에서 고유한 위치를 지정</li>
<li>실행 가능한 프로그램이 있는 디렉터리 집합을 지정</li>
</ol>
</blockquote>
<h3 id="용어-설명">용어 설명</h3>
<p>1번 정의는 &quot;파일 경로&quot;라는 용어로 요약이 가능하다.</p>
<p>이 글의 요점은 2번 정의인 <code>환경 변수</code>에 대한 내용이다. 이 개념은 CLI 환경에서 <code>편리성</code>을 제공하는 역할을 담당한다.</p>
<p>알반적으로 어떤 명령을 입력하게 되면, 현재 디렉토리 위치(current directory)에 존재하는 파일들을 기준으로 동작한다. 하지만 대부분의 경우 bin 폴더에 있을법한 명령 실행 파일을 작업 폴더에 넣는 짓은 하지 않기에, 플랫폼 의존적인 개발을 한다면 이 부분은 상당히 큰 문제다.</p>
<p>다행히(?) 대부분의 CLI 환경에서는 <strong>절대경로</strong>를 활용하여 특정 bin 폴더 내 명령 실행 파일을 가리키면 해당 파일을 이용할 수 있다. 그러나 이 방식은 내가 해당 파일들의 절대 경로를 전부 외워서 입력해야 한다는 것을 전제로 한다. 이 귀찮은 짓을 <code>환경변수</code>를 사용하여 컴퓨터에게 시키는 것이다. Windows 운영체제 기준 환경 변수의 CSV는 <code>;</code>로, 현재 디렉토리 내부에 없는 파일을 입력한 경우 컴퓨터는 path에 등록한 경로들을 순차탐색하여 조회한다. 등록된 경로에 해당 파일이 있으면, 자동으로 그 파일을 실행시켜 입력한 명령을 수행한다.</p>
<p>그러니 개발자라면 이 환경변수라는 것을 잘 알고 있는 것이 정신 건강에 좋다. IDE만 써서 개발했다면 IDE가 이 부분들을 자동으로 처리해서 이 부분은 쉽게 놓칠 수 있는데, 이번에 이 글을 보면서 얻어가는 것이 있으면 좋겠다.</p>
<h3 id="주의사항">주의사항</h3>
<p>기존에 콘솔을 켜둔 상태에서 path를 변경한 후, 다시 해당 콘솔을 이용하여 작업을 진행하면 안된다. 해당 콘솔은 가장 마지막 path만 기억하기 때문이다. 그러므로 path 변경 후에는 항상 새 콘솔로 변경하여 작업을 진행하도록 하자.</p>
]]></description>
        </item>
        <item>
            <title><![CDATA[CLI(command-line interface)]]></title>
            <link>https://velog.io/@black-snake/CLIcommand-line-interface</link>
            <guid>https://velog.io/@black-snake/CLIcommand-line-interface</guid>
            <pubDate>Fri, 12 Jan 2024 12:00:43 GMT</pubDate>
            <description><![CDATA[<h3 id="사전적-정의">사전적 정의</h3>
<blockquote>
<p>가상 터미널 또는 터미널을 통해 사용자와 컴퓨터가 상호 작용하는 방식</p>
</blockquote>
<h3 id="용어-설명">용어 설명</h3>
<p>콘솔에서 검은 화면에 흰 글씨를 타이핑하여 컴퓨터를 조작하는 방식이다. 요즘 떠오르는 클라우드 환경이나 기존 온프레미스 서버 개발 환경은 CLI를 사용하여 운영 환경을 구성하는 것이 일반적이기 때문에, 개발자라면 반드시 CLI에 친숙해져야 한다.</p>
<p>이에 상반되는 개념은 <code>GUI(Grapic User Interface)</code>으로, 알록달록한 화면에 마우스를 드래그 앤 클릭하여 컴퓨터를 조작하는 방식을 말한다. CLI를 GUI와 명확히 구분하기 위해 <code>CUI(Command User Interface)</code>라는 용어를 쓰기도 한다.</p>
]]></description>
        </item>
        <item>
            <title><![CDATA[JAVA Platform]]></title>
            <link>https://velog.io/@black-snake/JAVA-Platform</link>
            <guid>https://velog.io/@black-snake/JAVA-Platform</guid>
            <pubDate>Fri, 12 Jan 2024 11:54:29 GMT</pubDate>
            <description><![CDATA[<h3 id="사전적-정의">사전적 정의</h3>
<blockquote>
<p>Java 어플리케이션의 실행환경(JRE)과 개발환경(JDK)을 제공하는 것들의 모임.</p>
</blockquote>
<h3 id="용어-설명">용어 설명</h3>
<p>Java 프로그래밍 언어로 프로그래밍된 <code>.java</code> 파일을, 컴파일을 끝내면 <code>.class</code> 형식의 <strong>바이트 코드</strong> 형식의 파일로 만들어진다. 이렇게 Java 프로그램을 개발할 수 있는 환경은 <code>JDK(Java Development Kit)</code>에서 제공한다. 참고로 Java에서 컴파일 명령어를 갖고 있는 실행 파일은 <code>javac.exe</code> 이다. Java 명령 실행 파일들은 <code>%JAVA_HOME%\bin</code> 폴더 내에 위치하고 있다.</p>
<p><code>.class</code> 파일은 <code>JRE(Java Runtime Environment)</code>에서 실행할 수 있다. 이 파일은 JRE 내부 라이브러리를 사용해야만 읽을 수 있다. JRE는 운영체제와 프로그램 사이에 껴서 둘 사이를 계층화시키며, 이렇게 계층화된 구조 덕분에 Java 프로그램은 운영체제의 종류에 관계없이 플랫폼 독립적으로 실행할 수 있다. 그러나 이 구조는 Java 프로그램을 실행하기 위해서는 반드시 JRE를 설치해야 하는 문제와, Java 프로그램의 속도를 느리게 만드는 단점을 만든다. 그래서 속도가 덜 중요한 웹 서버에서 운영 서버 컴퓨터의 운영체제를 고려하지 않고 개발해도 되는 Java가 정말 많이 쓰인다. 참고로 Java에서 프로그램 실행 명령어를 갖고 있는 실행 파일은 <code>java.exe</code> 이다.</p>
<h3 id="그-외-용어-정리">그 외 용어 정리</h3>
<ul>
<li>JAVA_HOME - JDK 디렉토리 위치</li>
<li>classpath - JRE 디렉토리 위치</li>
</ul>
]]></description>
        </item>
    </channel>
</rss>