728x90
반응형

이전 포스팅에서 GraphQL API 구축을 하였다

 

그 코드를 다시 리팩토링 하여 axios 밑 비동기 방식으로 변경하였다

 

그리고 두개의 쿼리를 작동시켜 데이터를 가져오는 방법을 확인 해보자

 

 


db.js

import axios from "axios";
const BASE_URL = "https://yts.am/api/v2/";        // 기본적인 api url을 지정하고 
const LIST_MOVIES_URL = `${BASE_URL}list_movies.json`;  
				// 그 다음은 기능적으로 필요한 url을 개별적으로 관리한다
const MOVIE_DETAILS_URL = `${BASE_URL}movie_details.json`;
const MOVIE_SUGGESTIONS_URL = `${BASE_URL}movie_suggestions.json`;

export const getMovies = async (limit, rating) => { 
			// async await는 자바스크립트의 비동기 처리 패턴중 가장 최근에 나온 문법으로
    const {          // 비동기처리 방식인 콜백함수와 프로미스의 단점을 보완하는 방법이다
        data: {
            data: { movies }
        }
    } = await axios(LIST_MOVIES_URL, {  // 기존  node-fetch를 axios로 변경하여 사용하였다
        params: {
            limit,
            minimum_rating: rating
        }
    });
    return movies;
};

export const getMovie = async id => {	// 영화한개의 정보를 가져오는 함수
    const {
        data: {
            data: { movie } 
        }
    } = await axios(MOVIE_DETAILS_URL, {
        params: {
            movie_id: id
        }
    });
    return movie;
};

export const getSuggestions = async id => { // 추천 영화 검색해서 가져온다
    const {
        data: {
            data: { movies }
        }
    } = await axios(MOVIE_SUGGESTIONS_URL, {
        params: {
            movie_id: id
        }
    });
    return movies;
};

 

위와 같이 변경하였다

 

이제 그에 맞게 스키마를 재정의 하자

 

 


schema.graphql

type Movie {
    id: Int!
    title: String!
    rating: Float
    description_intro: String
    language: String
    medium_cover_image: String
    genres: [String]
}

type Query {
    movies(limit: Int, rating: Float): [Movie]!
    movie(id: Int!): Movie
    suggestions(id: Int!): [Movie]!
}

 

 

스키마에 suggestions를 추가하여 쿼리를 호출할 수 있게 한다

 


resolvers.js

import { getMovies, getMovie, getSuggestions } from "./db";

const resolvers ={
    Query: {
        movies: (_, { rating, limit }) => getMovies(limit, rating), 
        			// resolvers 함수는 스키마에 정의되어있는 쿼리의 함수들을 참조한다
        movie: (_, { id }) => getMovie(id),                     
        			// resolvers 함수에 db의 함수를 참조하여 추출 데이터를 가지고 오게된다
        suggestions: (_, { id }) => getSuggestions(id)      
        			// Query의 키들은 직접적인 쿼리문을 호출할때 사용한다
    }
};

export default resolvers;

 

나머지 파일들은 기존 셋팅과 동일하며

 

변경된 코드들을 실행을 하게 된다면 밑에와 같이 출력이 된다

 

 

 

 

 

이렇게 변경한 코드로 React를 적용하여 만들어보자!

 

 

 

 

 

2020/06/26 - [GraphQL/GraphQL 활용 서버구축 실습] - GraphQL API로 데이터 정보 가져오기

 

GraphQL API로 데이터 정보 가져오기

이전 포스팅에서 GraphQL로 간단한 정보를 가져왔다 이제는 영화 오픈 API를 통해 정보를 가져와보자 우선 index.js에 GraphQL를 활용해서 서버를 구축하고 맵핑을 시작하자 이것은 이전포스팅과 동일�

tantangerine.tistory.com

 

728x90
반응형
728x90
반응형

이전 포스팅에서  GraphQL로 간단한 정보를 가져왔다

 

이제는 영화 오픈 API를 통해 정보를 가져와보자

 

우선 index.js에 GraphQL를 활용해서 서버를 구축하고 맵핑을 시작하자

 

이것은 이전포스팅과 동일하지만 다시한번 작성해보자

 


index.js

import { GraphQLServer } from "graphql-yoga";
import resolvers from "./graphql/resolvers"

const server = new GraphQLServer({
    typeDefs: "graphql/schema.graphql", // 스키마정의가 되어있는 곳을 Defs로 둔다
    resolvers   // 결과 값을 실행할곳을 성정한다 단지 이 4줄로 끝이다
});

server.start(() => console.log("Graphql server Running"));

 

그리고 가져올 영화 정보가 어떤 타입인지 지정해주어야한다

 

영화정보를 가져올때 어떠한 형식인지 지정해주어야 하는것이다

 


schema.graphql

type Movie {
    id: Int!
    title: String!
    rating: Float!
    summary: String!
    language: String!
    medium_cover_image: String!
}                   

type Query {       
    movies(limit: Int, rating: Float): [Movie]!      
}

 

그리고 db.js를 만드는데 여기서는 오픈 API를 연결한다

 

db.js에는 url주소가 필요하며 그리고 url에 쿼리스트링이 있다면 그 쿼리스트링을 동적으로 변수처리해서 

 

조건을 변경할 수 있다

 


db.js

import fetch from "node-fetch";
const API_URL = "https://yts.am/api/v2/list_movies.json?";

// Node.js에서 fetch를 할때 필요하다 node-fetch를 설치하자

export const getMovies = (limit, rating) => {
    let REQUEST_URL = API_URL;
    if (limit > 0) {
        REQUEST_URL += `limit=${limit}`;
    }
    if (rating > 0) {
        REQUEST_URL += `&minimum_rating=${rating}`;
    }
    return fetch(REQUEST_URL)
      .then(res => res.json())
      .then(json => json.data.movies);
}

 

그리고 resolvers.js를 만들어서 Query문을 작성해서 오픈API에서 가져올 정보를 핸들링할 수 있다

 


 resolvers.js

import { getMovies } from "./db";

const resolvers ={
    Query: {
        movies: (_, { rating, limit }) => getMovies(limit, rating)
    }
};

export default resolvers;

 

이러한 결과는 아래와 같이 나오게된다

 

영화 API 

 

다음 포스팅은 더 많은 데이터 조작을 하고 여러가지 함수활용을 해보겠습니다!

 

 

728x90
반응형
728x90
반응형

Clipboard Events

이벤트 이름 :onCopy , onCut, onPaste

속성 : DOMDataTransfer clipboardData

 

Composition Events

이벤트 이름 : onCompositionEnd ,onCompositionStart, onCompositionUpdate

속성 : string data

 

Keyboard Events

이벤트 이름 :onKeyDown, onKeyPress, onKeyUp

속성 :

boolean altKey

number charCode

boolean ctrlKey

boolean getModifierState(key)

string key

number keyCode

string locale

number location

boolean metaKey

boolean repeat

boolean shiftKey

number which

이 key속성은 DOM Level 3 Events spec에 설명 된 값 중 하나를 사용할 수 있습니다 .

 

Focus Events

이벤트 이름 :onFocus , onBlur

이러한 포커스 이벤트는 폼 요소뿐만 아니라 React DOM의 모든 요소에서 작동합니다.

속성 : DOMEventTarget relatedTarget

 

Form Events

이벤트 이름 : onChange, onInput, onInvalid, onSubmit

onChange 이벤트에 대한 자세한 정보는 양식을 참조하십시오 .

 

Mouse Events

이벤트 이름 :

onClick, onContextMenu, onDoubleClick, onDrag, onDragEnd, onDragEnter, onDragExit,

onDragLeave, onDragOver, onDragStart, onDrop, onMouseDown, onMouseEnter, onMouseLeave,

onMouseMove, onMouseOut, onMouseOver, onMouseUp

 

onMouseEnteronMouseLeave이벤트는

하나가 아닌 일반 버블의 입력되는 왼쪽이 되는 요소로부터 전파하고 캡처 단계가 없습니다.

 

속성 :

boolean altKey

number button

number buttons

number clientX

number clientY

boolean ctrlKey

boolean getModifierState(key)

boolean metaKey

number pageX

number pageY

DOMEventTarget relatedTarget

number screenX

number screenY

boolean shiftKey

 

Pointer Events

이벤트 이름 :

onPointerDown, onPointerMove, onPointerUp, onPointerCancel, onGotPointerCapture,

onLostPointerCapture, onPointerEnter, onPointerLeave, onPointerOver, onPointerOut

onPointerEnteronPointerLeave이벤트는 하나가 아닌 일반 버블의 입력되는 왼쪽되는 요소로부터 전파하고 캡처 단계가 없습니다.

 

속성 :

W3 spec에 정의 된대로 포인터 이벤트 는 다음 속성을 사용하여 마우스 이벤트 를 확장 합니다.

number pointerId

number width

number height

number pressure

number tangentialPressure

number tiltX

number tiltY

number twist

string pointerType

boolean isPrimary

브라우저 간 지원에 대한 참고 사항 :

포인터 이벤트는 모든 브라우저에서 아직 지원되지는 않습니다

(이 기사를 작성할 당시 지원되는 브라우저에는 Chrome, Firefox, Edge 및 Internet Explorer가 포함됨).

표준 준수 폴리 필이의 번들 크기를 크게 늘리기 때문에

React는 의도적으로 다른 브라우저에 대한 지원을 폴리 필하지 않습니다 react-dom.

응용 프로그램에 포인터 이벤트가 필요한 경우 타사 포인터 이벤트 폴리 필을 추가하는 것이 좋습니다.

 

Selection Events

이벤트 이름 : onSelect

 

Touch Events

이벤트 이름 : onTouchCancel onTouchEnd onTouchMove onTouchStart

속성 :

boolean altKey

DOMTouchList changedTouches

boolean ctrlKey

boolean getModifierState(key)

boolean metaKey

boolean shiftKey

DOMTouchList targetTouches

DOMTouchList touches

 

UI Events

이벤트 이름 : onScroll

속성 :

number detail

DOMAbstractView view

 

 

onScroll

이벤트 이름 : onWheel

속성 :

number deltaMode

number deltaX

number deltaY

number deltaZ

 

Media Events

이벤트 이름 :

onAbort, onCanPlay, onCanPlayThrough, onDurationChange, onEmptied, onEncrypted,

onEnded, onError, onLoadedData, onLoadedMetadata, onLoadStart, onPause, onPlay,

onPlaying , onProgress, onRateChange, onSeeked, onSeeking, onStalled, onSuspend,

onTimeUpdate, onVolumeChange, onWaiting

 

 

Image Events

이벤트 이름 :onLoad, onError

 

 

Animation Events

이벤트 이름 : onAnimationStart, onAnimationEnd, onAnimationIteration

속성 :

string animationName

string pseudoElement

float elapsedTime

 

 

Transition Events

이벤트 이름 : onTransitionEnd

속성 :

string propertyName

string pseudoElement

float elapsedTime

 

 

Other Events

이벤트 이름 :onToggle

 

 

728x90
반응형
728x90
반응형

# final

위치 : 마지막이라는 의미

의미 : 클래스 앞(상속금지), 메서드 앞(overriding 금지), 변수 앞(재할당 금지)

 

 

 

final 클래스 앞에 선언될 때 예문


final class A{ //final은 class에서 상속할 것이 없을 때 확장(상속) 금지를 선언할 때 사용한다

  static int a=100; //옆에 예문처럼 static만 선언되어있다면 상속할 필요가 없으므로

  static int b(){ return 200; }// final을 선언해서 상속하는 것을 막아야 한다

  } //static은 공용처럼 사용할 수 있으며 어떤 변수가 초기화하거나 재할당하게 되면
	//그 값은 독자적인 값으로 여러 객체생성을 하면 그 값은 한 개의 값으로 선언된다

class B extends A{ 

  void c(){

  System.out.println(a);

  }

}

class C{

  public static void main(String args[]){

    B o1=new B(); o1.a=300; = A.a=300; //가독성을 위해 변경해야한다

    B o2=new B(); o2.c();

  }

}


 

 

final 변수 앞에 선언될 때 예문


class A{

  final int num;



  A(int n){

    num=n; // 생성자에서 로컬변수의 최초 재할당은 가능하다.

    num=300; // 컴파일에러

  }

  void a(){

  num=400; // 컴파일에러

  }

}

interface A{ //자동으로 접근제어자 선언됨

  void abc(); 
  
} //interface를 선언하게되면 그 클래스 해당하는 메서드는 static final void abc();라는 형식이

숨겨져 있다 그래서 범위가 정해지고 public > protected > default > private

class B implements A{

  public void abc(){ //앞에는 public을 꼭 선언해야 오버라이딩을 할 수 있다

  } //그리고 interface를 선언하게되면 개체생성을 하지 못하고 구현개체를 개별로 선언해주고

} //부모상족자로 interface 클래스를 선언하여 interface가 가지고있는 메서드를 구현 개체에

//오버라이딩을 해서 구현하게된다

 

 

 

# 다형적변수

다형적 변수는 상속(확장) 관계에서만 허용되며, 자식 클래스의 오버라이딩된 메서드만 접근할 수 있다

 

 

추상클래스에서 추상메서드는 실행 바디를 생성할 수 없다 아래의 문장을 확인하자

 


abstract class Animal{ 

  abstract void sound(); //실행문인 {}가 제외되었다는것을 알 수 있다

  abstract void sound(); //이때 추상 클래스 추상 메서드를 선언하여 강제로 오버라이딩을 하게 한다

} //그 이유는 추상 클래스의 추상 메서드가 선언되면 상속자의 시그니쳐와 같은 형태의


class Dog extends Animal{ //오버라이딩을 해야 컴파일에러가 발생하지 않기 때문이다

  void sound(){ System.out.println("멍멍"); } //그래서 자식 상속자 클래스를 
  								// 작업하는 사람의 실수를 미연에 방지할 수 있다
}


class Duck extends Animal{// 다형적변수와 추상 클래스의 추상메서드는 반드시 함께 생각해야만 한다

  void sound(){ System.out.println("꽥꽥"); }

}


class Cat extends Animal{

  void sound(){ System.out.println("야옹"); }

}


class Sound{

  static void test(Animal s){

  s.sound();

  }
}


class A{

  public static void main(String[] args){

    Dog dog=new Dog();

    Duck duck=new Duck();

    Cat cat=new Cat();

    Sound.test(dog);

    Sound.test(duck);

    Sound.test(cat);

  }
}


 

# abstract

 

의미 : 추상적이라는 의미

위치 : 클래스 앞, 메서드 앞

 

추상 클래스는 객체를 생성할 수 없다

 


abstract class A{ 

  //클래스 간 확장(상속) 관계일 때 클래스 B도 추상 클래스를 선언해야

  int a=100; 		// 컴파일에러가 발생하지 않는다

} 			//또 한 추상 클래스가 선언된 클래스는 상속(확장) 관계인 클래스는

class B{			// 메서드 오버라이딩을 해야 컴파일 오류를 막을 수 있다

  public static void main(String[] args){

    A o=new A();

    System.out.println(o.a);

  }
}

--------------------------------------------------------

abstract class A{

  abstract void abc();

  void def(){ System.out.println(200); 
  
  }
}

abstract class B extends A{

  void def(){System.out.println(100); 
    
}




반응형

# 참조형간의 형변환

 

다형적 변수로 자식의 오버라이딩 되지 않은 메서드를 호출할 때 형변환을 사용한다. (상속 관계에서만 적용) 예문 확인

 


class A{

}

class B extends A{

  void abc(){ 
  
  	System.out.println(1); 

}


class C{

  public static void main(String[] args){

    B o1=new B();

    o1.abc(); // 1

    A o2=o1;

    o2.abc(); // 컴파일에러

    B o3=(B)o2;

    o3.abc(); // 1

  }
}

 


 

#수치형간의 형변환(정수, 실수, 문자)

 

 

byte(1) < short, char(2)< int(4)< long(8) < float(4) < double(8)

 

 


 

int a=10;

byte b=a; // 컴파일에러



byte a=10;

int b=a; // 자동형변환



double a=3.5;

int b=a; // 컴파일에러



double a=3.5;

int b=(int)a; // 강제형변환



int a=10; // 0이28개1010

byte b=10; // 00001010



char a='A';

char b=65;

char c='\u0041';

System.out.println(a);

System.out.println(b);

System.out.println(c);



System.out.println('A'+1); // 66

System.out.println("A"+1); // A1



float a=3.5; // 컴파일에러

float b=3.5F;

int c=5L; // 컴파일에러

int d=3D; // 컴파일에러




 

값자체를 의미할때 컴퓨터언어에서는 리터럴(literal) ==>

숫자D --> double형

숫자F --> float형

숫자L --> long형

 

0b숫자 --> 2진수표현

0숫자 --> 8진수표현

0x숫자 --> 16진수표현

 

 

[ex] 10진수65를 2진수로 표현하면?

단, java.lang.Integer클래스의 toBinaryString메서드를 이용한다.

 


[an]

class A{

  public static void main(String... args){

    String s=Integer.toBinaryString(65);

    System.out.println(s); // 01000001

  }

}





[ex] 10진수65를 16진수로 표현하면?

단, java.lang.Integer클래스의 toHexString메서드를 이용한다.



[an]

class A{

  public static void main(String... args){

    String s=Integer.toHexString(65);

    System.out.println(s); // 41

  }
}
728x90
반응형
728x90
반응형

접근제어자

private

- 접근금지 ( method는 상속 안 되며 method overriding 금지 ) 자기 자신 접근 가능

 

public

- 접근허용 ( 다른 폴더에 있는 클래스는 접근하기 위해서는 public 선언이 필요하다 )

 

default

- 같은 패키지일 때 접근허용, 다른 패키지일 때 접근금지 상속관계인 경우라도 접근금지

 

protected

- 같은 패키지일 때 접근허용, 다른 패키지일 때 접근금지 상속관계인 경우 허용

 


 

기타제어자

final

- 위치 : 클래스 앞(상속금지), 메서드 앞(overriding 금지), 변수 앞(재할당 금지)

 

abstract

- 위치 : 클래스 앞, 메서드 앞 의미 : 추상적이라는 의미

 

static

- 위치 : 멤버변수 적용가능 static 변수; 의미 : 클래스에 속한 것이란 의미

- 위치 : method 적용가능 static 메서드(); 의미 : 메서드는 static 선언된 것만 호출가능 하다

- 상속관계가 성립되더라도 static은 그 값은 변화가 없다

 

클래스 앞에 선언이 되는 접근제어자 : public, default 그 외의 접근제어자는 변수에 사용

public > protected > default > private

 

#static static은 객체생성 전에 메모리에 할당된다

위치 : 멤버변수, method 적용가능 의미 : 클래스에 속한 것이란 의미

 


class A{

  public static void main(String[] args){

    System.out.println(Math.PI);

  }
}

클래스 변수(static이 선언된 멤버변수) : 모든 객체가 공유하는 변수

객체변수(static이 선언되지 않은 멤버변수) : 객체에 속한 변수

 


class A{

  static int a=100; // 클래스변수

  int b=200; // 객체변수

  A(){ a++; b++; }

}

class B{

  public static void main(String[] args){

  A o1=new A();

  System.out.println(A.a); // 101 클래스 변수의 형태를 보더라도 객체 생성한 변수는 통합적으로 적용된다

  System.out.println(o1.b); // 201

  A o2=new A();

  System.out.println(A.a); // 102

  System.out.println(o2.b); // 201

  A o3=new A();

  System.out.println(A.a); // 103

  System.out.println(o3.b); // 201

  }
}

 

 

#static 블록 : 클래스가 로드될 때 자동으로 호출되는 메서드


class A{ 		

  static{ System.out.println(1);} // static이 선언되어 있으면 자동으로 호출이 된다 그래서
  
}					// 변수나 메서드 앞에 선언되어있다면 그 변수와 메서드가 자동 호출된다

//static{ 실행문 }  // 그래서 static 블록안에 선언문과 호출문은 자동으로 호출된다


class B{			// static{실행문}은 실행문 안에 static선언 했던 것들만 사용 할 수 있다

  static{ System.out.println(2); }	
  
  public static void main(String... args){
  
  System.out.println(3);
}

 


 

instance 블록 – 시그니쳐는 {}만으로 실행가능하다 {}안에 실행문이 자동으로 실행한다


class A{

{ //<-- instance 블록 - 원하지 않아도 자동으로 실행되기때문에

  System.out.print("객체생성되기전에반드시"); //작업의 유연성이 떨어지므로 비추천

  System.out.println("실행해야하는소스코드");

  for(int a=1; a<=10; a++)

  System.out.print(a+" ");

} //<-- instance 블록

  A(){

  System.out.println("AAA");

  }

  A(int n){

  System.out.println("BBB");

  }

  A(String s){

  System.out.println("CCC");

  }

}



class B{

  public static void main(String... args){

    A o1=new A();

    A o2=new A(100);

    A o3=new A("abc");
  }
}

 

private 선언된 생성자를 객체생성 하기


class A{ 

  private A(){}

  static A abc(){ return new A(); } // method def를 호출하기 위해서 클래스 A의 객체생성이 필요하다 하지만

  void def(){ System.out.println(1); } // 생성자 A가 private 선언되어 있어 객체생성 접근이 불가능하다. 하지만

} // method abc() 실행문에 return new A()를 활용한다면 객체생성을 할 수 있다


class B{ 
		 
  public static void main(String[] args){ 
  		// 반환형인 abc()는 static이 선언되어있어 객체생성 없이 클래스 이름으로 호출이
		// 가능하다는 이점을 활용하자 abc() 참조형 A이므로 호출문 작성하면
        //이 된다. 이때 A.abc()=new A() return 값이 저장되기에
  A o=A.abc(); A o=A.abc(); 	// 식을 풀이하면 객체생성 때와 같은 식이 성립된다

  o.def(); A o=new A() 
}

 

( 객체 생성할 수 없는 클래스 객체생성 활용 예문 )

java.util.Calendar클래스의 getInstance method 호출하는 소스코드 ( 객체 생성할 수 없는 클래스 객체생성 하기 )

Calendar클래스는 어떠한 이유로 객체생성이 되지 않는다


 

import java.util.Calendar;
class A{
 public static void main(String[] args){
 
 Calendar o=Calendar.getInstance();		//getInstance()는 반환형으로 return 값이 Calendar이다

  }					//그래서 달력정보를 호출하려면 getInstance()를 꼭 사용하여야 한다
}
					// java.util.Calendar클래스의 클래스변수 
					// YEAR, MONTH, DATE의 값을 출력하는 소스코드


import java.util.Calendar;

class A{
 
 public static void main(String[] args){
 
 System.out.println(Calendar.YEAR);		// 1	YEAR, MONTH, DATE static이 선언된 클래스 변수이다

 System.out.println(Calendar.MONTH);	// 2

 System.out.println(Calendar.DATE);		// 5
 }
}

 

 

java.util.Calendar클래스의 get메서드 호출하는 소스코드

 


import java.util.Calendar;
class A{

 public static void main(String[] args){
 
 Calendar o=Calendar.getInstance();	//옆 예문에서 private 선언된 생성자를 객체 생성하는 방법과
 
 	int y=o.get(Calendar.YEAR);		//유사한 방법으로 활용할 수 있다
    
 	int m=o.get(Calendar.MONTH)+1;
    
 	int d=o.get(Calendar.DATE);
    
	System.out.println(y);
    
	System.out.println(m);
    
	System.out.println(d);
 }
}

 

 

static 활용 예문이다 


class Child{
  String name;
  
  static int candyNum;
  
  Child(String n){	name=n; candyNum=10;}

  void eatCandy(){ candyNum--;
}


class A{
   public static void main(String[] args){
   
     Child c1=new Child("진우");
     
     Child c2=new Child("서진");
     
     System.out.println(c1.name);
     
     System.out.println(c2.name);
     
     System.out.println(c1.candyNum); // 10
     
     System.out.println(c2.candyNum); // 10
     
     c1.eatCandy(); // 진우(이)가 사탕을 먹는다 사탕수:9
     
     c1.eatCandy(); // 진우(이)가 사탕을 먹는다 사탕수:8
     
     c2.eatCandy(); // 서진(이)가 사탕을 먹는다 사탕수:9
     
     System.out.println(c1.candyNum); // 7	
     		//가독성을 위해서 Child.candyNum로 고쳐주는 것이 좋다.
     
     System.out.println(c2.candyNum); // 7	
     		//그 이유는 static을 선언하여 공용으로 사용하는 의미를 내포하고 있다.
  }
}

 

class A{
    static int a=100;
    
    int b=200;
    
    void c(){
    
        System.out.println(a);
        
        System.out.println(b);
    }
    
    static void d(){
    
        System.out.println(a);		//static 간에 호출 가능
        
        System.out.println(b);		//컴파일에러
    }
}


class B{
	public static void main(String[] args){
    
		A.d();
        
		A o=new A();
  }
}

 


 

# final

위치 : 마지막이라는 의미

의미 : 클래스 앞(상속금지), 메서드 앞(overriding 금지), 변수 앞(재할당 금지)

 

 

final 클래스 앞에 선언될 때 예문


final class A{ //final은 class에서 상속할 것이 없을 때 확장(상속) 금지를 선언할 때 사용한다

  static int a=100; //옆에 예문처럼 static만 선언되어있다면 상속할 필요가 없으므로

  static int b(){ return 200; } //final을 선언해서 상속하는 것을 막아야 한다

} //static은 공용처럼 사용할 수 있으며 어떤 변수가 초기화하거나 재할당하게 되면


class B extends A{ 그 값은 독자적인 값으로 여러 객체생성을 하면 그 값은 한 개의 값으로 선언된다

  void c(){

  System.out.println(a);

  }

}


class C{

  public static void main(String args[]){

  B o1=new B(); o1.a=300; = A.a=300; //가독성을 위해 변경해야한다

  B o2=new B(); o2.c();

  }

}


//final 변수 앞에 선언될 때 예문

class A{

  final int num;

  A(int n){

    num=n; //생성자에서 로컬변수의 최초 재할당은 가능하다.

    num=300; // 컴파일에러

  }

  void a(){

  num=400; // 컴파일에러

  }

}



interface A{ //자동으로 접근제어자 선언됨

  void abc(); 
  
} //interface를 선언하게되면 그 클래스 해당하는 메서드는 static final void abc();라는 형식이

  //숨겨져 있다 그래서 범위가 정해지고 public > protected > default > private


class B implements A{

  public void abc(){ //앞에는 public을 꼭 선언해야 오버라이딩을 할 수 있다

  } //그리고 interface를 선언하게되면 개체생성을 하지 못하고 구현개체를 개별로 선언해주고

} //부모상족자로 interface 클래스를 선언하여 interface가 가지고있는 메서드를 구현 개체에

//오버라이딩을 해서 그 구현하게된다




 

다음은 다항적 변수와 abstract을 활용하는 방법을 알아보자

 

 

 

2020/06/14 - [Java/Java 입문] - [Java] 상속자, 은닉변수, super(), this의 활용

 

[Java] 상속자, 은닉변수, super(), this의 활용

-상속자- 모든 생성자의 첫 번째 줄에는 super() 소스코드가 생략되어 있다. 단, 생성자의 첫 번째 줄에 super() 또는 this()가 선언된 경우 super() 소스코드는 추가되지 않는다. 객체간의 관계 is a관계 :

tantangerine.tistory.com

 

 

 

 

728x90
반응형
728x90
반응형

-상속자-

모든 생성자의 첫 번째 줄에는 super() 소스코드가 생략되어 있다.

단, 생성자의 첫 번째 줄에 super() 또는 this()가 선언된 경우 super() 소스코드는 추가되지 않는다.

 

객체간의 관계

is a관계 : 상속관계

has a관계 : 어떤 클래스에서 다른 클래스의 주소를 멤버변수로 가진것

 


class A{

  A(){ 
    
    System.out.println(1); 
  
  } // B 클래스 객체 생성해서 생성자 method B를 실행하면

} // 부모 클래스 A의 생성자를 불러와 같이 실행하게 된다 하지만 이때



class B extends A{ // 생성자의 첫 번째 줄에는 super() 소스코드가 생략되어있으며

  B(){ 
    
    super() 
    
    System.out.println(2); 
  
  } // super()의 매개변수 타입과 부모 클래스의 생성자의 매개변수 타입이

} // 일치해야 부모 클래스의 생성자를 불러올 수 있다



class C { // 결과는 1, 2가 출력된다

  public static void main(String[] args){

    B o=new B();

  } 

}


 

 

-super()-

super()는 일반 생성자에 생략이 되어있다

평소에는 어떠한 작동을 하지않고 상속관계가 되었을때에만 작동이된다

 

상속관계에서 super()로 인해 부모 클래스에 해당하는 생서자를 불러오게된다

 


class A{

  A(String s){

    System.out.println(1);

  }
}



class B extends A{

  B(){ 
  
    this(100); 
  
  } // this()는 자기 자신의 생성자를 불러오는 코드로써 this()의 매개변수 타입과

  B(int a){ 
  
  	super("aaa"); 
    
  } // 불러올 생성자의 매개변수 타입을 일치시킨다. 이때 동일시 된 생성자가

} // 실행되고 실행문에 supe()에 의해 부모 클래스에 해당하는 생성자를





class C{ // 불러오게 되는데 이때도 매개변수의 타입이 일치해야지만 부모 클래스의 생성자를 불러올 수 있다

  public static void main(String[] args){

    B o=new B();

  }
}

=========================================================================================


class Animal{

  String type;
  
  Animal(String t){ 
  
  type=t; 
  
  }
}


class Dog extends Animal{

  Dog(){
  
    super("개");		
      // 상속자 관계에서 부모 클래스에서 생성자 method가 선언되어있고 매개변수도 선언되어있다면 
  }	  // 부모 클래스의 생성자 매개변수와 자식 클래스의 생성자 super의 기본타입이 같지 않다면
}	  // 컴파일에러가 일어나기 때문에 부모의 생성자 method 매개변수 타입이 같은지 확인하고 
	  // super()을 꼭 이용하여야만 에러를 방지하고 사용할 수 있다

class Cat extends Animal{	
  Cat(){
    super("고양이");
  }
}


class A{
  public static void main(String[] args){
    Dog dog=new Dog();
    Cat cat=new Cat();
    System.out.println(dog.type);	// 개
    System.out.println(cat.type);	// 고양이
  }
}
 

 

여기서  this란

아래의 예문으로 확인하여 익히자

 

-this, this()-


class Car{
  String color="red";
    void print(){ 
        				// this 자체가 멤버변수를 의미한다. 즉, this. 멤버변수를 실행하면
      System.out.println(this.color); 	// 멤버변수의 값을 얻을 수 있다
 	}			
}


class A{
	public static void main(String[] args){
		Car car1=new Car();  
		Car car2=new Car();
		Car car3=new Car();
		car1.print();
		car2.print();
		car3.print();
	}
}

--------------------------------------------------------------------------------------------

class A{						    // 생성자의 method에서 this()를 이용하면 
	A(){ System.out.println(1); }	// 매개변수 타입이 서로 다른 자료형 타입이더라도 
    								// 출력할 수 있다
	A(String s){ 
      this(); 
      System.out.println(2); } 	
    
	A(int i){ 
      this("aa");  // 첫 로컬변수에 this(“aa“)로 매개변수 동일타입에 해당하는   
      System.out.println(3);  // 위치 이동하며 더 이상 동일한 타입이 없다면 실행 순서는 역순으로 진행
    }	
    
}		


class B{						
	public static void main(String[] args){		
		A o=new A(100);	// 처음 호출문에 생성자 객체생성으로 매개변수 정수 100으로 호출한다
	}
}



-------------------------------------------------------------------------------------------

class A{
	int n;
	A(int n){ this.n=n; }
	A getA(){ return this; }		
}


class B{
	public static void main(String args[]){
		A o1=new A(100);
        
		A o2=o1.getA();	    
        	// method getA()에서 return this를 불러와서 멤버변수의 값을 객체 생성한 o2에 저장하게 된다
		
        System.out.println(o1.n); // 100 
        
		System.out.println(o2.n); // 100
        	 // 객체생성 변수에 멤버변수 값 100 저장했기 때문에 o2.n을 불러들이면  100이 출력된다
	}						
}
  

 

 

 

-super, 은닉변수-

은닉변수를 설정하여 super을 이용해서 부모의 멤버변수를 불러올 수 있다


class Animal{

  int num=100; // 은닉변수(shadow variable) 사용하고 싶지 않다는 뜻

    void sound(){

      System.out.println("소리결정되지 않음");

    } 
}



class Dog extends Animal{

  int num=200; // 부모 클래스의 멤버변수와 이름이 같을 때 자식 멤버변수가 재할당된다

  void sound(){ // 그래서 부모 클래스의 멤버변수를 불러올 수 없다 하지만 super을 이용하여

    super.sound(); // 부모 멤버변수를 불러올 수 있다

    System.out.println(super.num);

    System.out.println(this.num);

    System.out.println(num);

    System.out.println("멍멍");

  } 
}



class A{

  public static void main(String[] args){

    Dog dog=new Dog();

    dog.sound();

  } 
}

// -결과-
// 소리 결정되지 않음
// 멍멍

 

 

이제 종합 예제 문제로 활용법을 알아보자


class Video{

  String title;
  
  Video(String t){ 
  
  title=t; 
  
  }
}


class GeneralMember{

  String name; 
  
  Video rentalVideo;
  
  GeneralMember(String n, Video v){
  
  name=n; 
  
  rentalVideo=v;
  
  }
}



class SpecialMember extends GeneralMember{

  int bonus;
  
  SpecialMember(String n, Video v, int b){
  
  super(n,v);
  
  bonus=b;
  
  }
}



class VideoShop{
 public static void main(String[] args){
	Video v1=new Video("슈렉");
	Video v2=new Video("겨울왕국");
	GeneralMember m1=new GeneralMember("홍길동",v1);
	SpecialMember m2=new SpecialMember("김길동",v2,100);
	System.out.println(m1.name); // 홍길동
	System.out.println(m1.rentalVideo.title); // 슈렉
	System.out.println(m2.name); // 김길동
	System.out.println(m2.rentalVideo.title); // 겨울왕국
	System.out.println(m2.bonus); // 100
 }
}

 

 


2020/06/02 - [Java/Java 입문] - Java - 생성자 호출과 선언, 개념

 

Java - 생성자 호출과 선언, 개념

생성자 기본 method 형식에서 클래스 변수로 method를 생성한 선언문이다 객체 생성할 때 매개변수 값을 동시에 선언하는 방식으로 식은 다음과 같다. ( 클래스 변수 식별자변수=new 클래스 변수(매��

tantangerine.tistory.com

 

728x90
반응형
728x90
반응형

자동차객체 학사시스템객체

- 속성(특성) : 브랜드, 소유주, 색상, 속도

- 속성(특성) : 교수, 학생

- 기능(행위) : 달린다, 멈춘다, 기름을 더 넣는다

- 기능(행위) : 학점을 조회하다, 강좌를 개설하다, 학생을 조회하다

 

위와 같이 저러한 객체들은 어떠한 행동, 행위들을 한다

그런것들을 코드를 객체모델링 화 할려면 아래와 같은 단계를 거쳐야한다

 

 

객체모델링 3단계

1 객체의 속성과 기능 얻기

2 객체를 클래스 선언하기

3 객체 생성하기

 

-변수의 종류(위치에 따른 구분)-

-멤버변수 : method의 중괄호 (즉, 블록) 바깥쪽에 선언된 변수

-매개변수 : method의 소괄호에 선언된 변수

-로컬변수 : method의 중괄호 (즉, 블록) 안쪽에 선언된 변수

 


class A{

int a=100; // 멤버변수

void method(int b){ // 매개변수

int c=300; // 로컬변수

} }

 

-멤버변수, 로컬변수, 매개변수 활용법- ( 같은 클래스 내에서 멤버변수 및 로컬변수 선언 활용 )

 

이름 : 김상진, 지역 : 부산, 학교 : 내성초등학교, 학년 : 5

 

위의 정보로 코드를 작성하는데 객체모델링을 실시하자

 


class Location{ // method는 처음 객체 설정이 매우 중요

  String name; // 객체를 파악해서 클래스를 설정하고 추후 호출문에서 객체 생성할 때를 생각해야 한다

  } // 객체는 지역, 학교, 어린이 3가지로 나눌 수 있으며 이것을 클래스 명으로 설정하자



class School{ // 어린이에 대한 정보는 멤버변수로 지정한다. 이때 학교 이름, 지역 이름도 해당된다.

  String name; // 이러한 클래스 분류 과정은 객체 지향적 언어로써 누구든 알기 쉽게 하는 것에 있다.

}



class Child{ // 이처럼 멤버변수에 지역, 학교, 학년, 이름이 선언되어있는 것을 알 수 있으며

  Location location; // 멤버변수에 값을 선언하지 않는 이유는 한번 값을 지정하면 호출문에서 값을 전달할 때
					 // 기존의 값이 무의미하기 때문이다
  String name;  // 클래스 내에서 멤버변수는 “어디서든” 사용할 수 있으며, “어디서든” 재할당할 수 있다
  
  int grade; // 또 한 호출 되지 않는 상황에 여러 정보가 할당되어있는 것은 좋은 코드가 될 수 없다

  School school; 

  void setValue(String n, int g, School s, Location l){

  name=n; // 매개변수 중 클래스 변수는 클래스 주소만 저장할 수 있다
  
  grade=g;

  school=s;  // School s = v3 이 되고 즉, School s=new School(); 되므로
  
  location=l; // s는 객체 생성한 변수가 되고 다시 school에 저장되어
			  // method printlnfo school.name을 호출 할 수 있다
  } 


void printInfo(){

  System.out.println("이름 : "+name); // 호출문에서 할당한 멤버변수를 출력한다

  System.out.println("지역 : "+location.name); // 이때 school은 School의 객체 생성된 변수이므로

  System.out.println("학교 : "+school.name); // school.name 멤버변수를 호출할 수 있다

  System.out.println("학년 : "+grade); // 멤버변수 호출문 = 객체생성변수. 멤버변수

}



class O{

  public static void main(String[] args){

    Location v2=new Location(); v2.name="부산"; // 객체 생성된 변수를 이용하여

    School v3=new School(); v3.name="내성초등학교"; // 클래스 멤버변수의 값을 할당한다

    Child v1=new Child(); v1.name=“김상진”;

    v1.setValue( “김상진”, 6, v3, v2 );

    v1.printInfo();

  }
}

 

- 멤버변수의 활용예문 ( 로컬변수에서 다른 클래스 멤버변수 선언 활용 ) -


class Car{

  String color="red";

}

class Factory{

  void changeColor(Car o, String color){

  o.color=color; // method 호출문으로 매개변수 car1, pink가 저장된다

  // o.color (car1.color) 멤버변수에 pink가 저장한다는 의미있는데
  } 
}



class O{

  public static void main(String[] args){

    Car car1=new Car(); // 같은 클래스의 객체생성을 여러 번 할 경우

    Car car3=new Car(); // 서로 다른 객체의 주소(변수)가 갖게 되고

    Factory factory=new Factory(); // 멤버변수의 값 또 한 서로 다른 값을 선언할 수 있다

    factory.changeColor(car1,"pink");

    factory.changeColor(car3,"green");

    System.out.println(car1.color);

    System.out.println(car3.color);

  }

}

 

 

멤버변수의 활용예문 ( 배열 객체생성 & 배열 길이, for문 활용법 ) - 주소 전달 방식


class Car{

  String color="red";

}



class Factory{

  void changeColor(ACar[] array, String[] cArray){

    int len=array.length; // 객체(자동차)가 추가로 생산이 된다고 한다면

    for(int a=0; a<len; a++) // 객체 생성된 변수를 배열로 묶은 배열의 변수를 활용하여

    array[a].color=cArray[a]; // 멤버변수의 값을 할당하는 차이가 있다.
  
  } 
}



class P{

  public static void main(String[] args){ // 위의 방식과 다르게 주소 전달하는 방식으로

    Car car1=new Car(); // 객체 생성된 car1과 car2를 배열로 묶은 변수(array) 와

    Car car3=new Car(); // color 정보를 배열로 묶은 변수( cArray )로

    Factory factory=new Factory(); // method changeColor 매개변수 값을 선언하고

    Car[] array={car1,car3}; // 매개변수로 재활당 된 변수는 배열의 길이를 구하고

    String[] cArray={"pink","green"}; // for 문 실행으로 array[a].color=cArray[a]; 값을 할당한다

    factory.changeColor(array,cArray);

    System.out.println(car1.color); // pink

    System.out.println(car3.color); // green

  }
}

class N{ int a=100; }

class Q{ String a="aaa"; }



class R{

  void test(N v1, Q v2){ // 위와 같이 주소 전달 방식으로 클래스 주소를 전달한다.

    System.out.println(v1.a); // 100 // 호출문에 객체생성 된 변수 o1, o2를 활용하여

    System.out.println(v2.a); // aaa // test method 매개변수에 재할당하여 다른 클래스 멤버변수를 호출

  }
}



class S{

  public static void main(String[] args){

    N o1=new N();

    Q o2=new Q();

    R o3=new R();

    o3.test(o1,o2);

  }
}

 

 

멤버변수의 활용예문 ( return, 배열, 명령행 매개변수, 연산자 ) - 값 전달 방식


class Calculator{

  int[] operate(int a, int b){

    return new int[]{

    a+b, a-b, a*b, a/b // 연산자를 return하여 v3를 호출하고 for문 활용으로 출력

    };
  }
}



class A{

  public static void main(String[] args){

    Calculator o=new Calculator();

    Calculator o1=new Calculator();

    int v1=Integer.parseInt(args[0]);

    int v2=Integer.parseInt(args[1]);

    int[] v3=o.operate(v1,v2); // 명령행 매개변수의 지정 값이

    // method 매개변수 값으로 지정되어 출력문에 영향을 준다

    String[] s1={"합","차","곱","몫"};

    String[] s2={"+","-","*","/"};

    for(int i=0; i<4; i++){

      System.out.println(s1[i]+":"+v1+s2[i]+v2+"="+v3[i]);

      }

  }

}

객체모델링은 메서드 선언과 호출 그리고 변수들을 잘 활용하여야 한다

처음은 익숙하지않아 어떻게 선언해야할지도 모르지만 호출문을 보고 선언문을 작성해보고

선언문을 보고 호출문을 작성하는 연습을 한다면 반환형 메서드, 무반환형 매서드등 여러가지로

익숙해질 수 있을것이다

 

2020/06/11 - [Java/Java 입문] - [Java] 메서드 선언과 호출, 반환형과 무반환형 method 활용

 

[Java] 메서드 선언과 호출, 반환형과 무반환형 method 활용

-method method 선언과 호출- 1. 반환형이 있는 method 자료형 method 변수(){ return 값; } 호출문 ( 자료형 변수=method변수.(); ) 호출하려는 method와 관련이 있는 클래스에 대한 객체생성이 필요 2. 반환형이..

tantangerine.tistory.com

 

 

728x90
반응형
728x90
반응형

-method method 선언과 호출-

 

1. 반환형이 있는 method

자료형 method 변수(){ return 값; }

호출문 ( 자료형 변수=method변수.(); )

호출하려는 method와 관련이 있는 클래스에 대한 객체생성이 필요

 

2. 반환형이 없는 method

void method 변수 (){}

호출문 ( method변수.(); )

호출하려는 method와 관련이 있는 클래스에 대한 객체생성이 필요하다.

 


class B{

void a(){ System.out.println(1); }

void b(){ System.out.println(2); }

void c(){ System.out.println(3); }

}



class C{

  public static void main(String args[]){

    B o=new B(); //배열 2번 구조 자료형[] 배열형=new 자료형[방 개수] 활용이랑 비슷하다고 생각을 하자

                //클래스 "B" 객체생성이 가능하다. 객체 생성된 주소가 변수 o에 저장된다

                //이때 자료형의 자리에는 클래스 "이름" 이 오는 것이 특징

                //또 한 클래스는 참조형으로 자료형이 될 수 있음을 기억하자

    o.a(); 		//o에 저장된 클래스 B의 객체 주소가 a()를 불러온다

                //즉, 객체생성으로 인한 주소가 o에 저장이 되고 a() method가 실행된다

                //o. a()에 대해 (.) 콤마 앞에는 클래스 주소(변수)만 사용할 수 있다

    System.out.println(4);

  }

}

// 결과는 1 2 3 4가 출력 될것이다 띄워쓰기는 생략한다

위와 같이 클래스를 객체를 생성하여 클래스 내부의 매서드를 실행시키기 아주 좋은 방법이다

이 방법은 앞으로 프로그래머로써 아주 기본이되는 것이므로 필히 기억하고 선언과 호출을 기억해야한다

 

이때 o.a();가 호출문이고 void a(){} 가 선언문이 된다

 

 

-method 활용법-

이제 기본기를 익혔으니 간단하게  다른 예문을 보도록하자


class Dog{

  void sound(){System.out.println("멍멍");}

}

class Cat{

  void sound(){System.out.println("옹야");}

}

class D{

  public static void main(String[] args){

    Dog o=new Dog();

    o.sound();

    Cat p=new Cat();

    p.sound();

  }

}

 


엔트리 포인트에서 여러 클래스를 객체생성하여 사용이 가능하다

 

 

 

 

-method 호출과 매개변수-

 

method 명은 숫자로 시작하면 안 되며, 소문자로 작성하고, 혼합은 뒤 단어의 첫머리글자를 대문자로 한다


class E{

  void a(int v1){System.out.println(1);}

    // method의 선언(헤드) 부 시그니쳐 라고 한다

    // method a에 대한 매개변수 v1은 method b의 매개변수 v1은 서로 적용받지 않는다

    // 매개변수는 v1은 호출문에 “o.a(100);“ 100 값이 v1에 저장된다

    // 자동으로 “int v1=100”이 라는 식이 성립된다

    // 또 한 v1은 실행문에서 활용이 가능하다.

  void b(char v1, int v2){System.out.println(2);}

    // method 매개변수 간에 자료형의 타입은 서로 관계가 없다.

  void c(){System.out.println(3);

}

class F{

  public static void main(String[] args){

    System.out.println(4);

    E o=new E();

    o.a(100);

    o.b('B',200); //호출할 때에는 타입의 개 수와 순서를 맞추어야 한다

    o.c();

  }

}

// 결과는 1 2 3 4 즉, method 호출문에 작성된 매개변수의 값은 호출에 필요한 조건들이며 출력이 되는 값은 아니다.



// 만약 결과 값을 매개변수 값과 같게 하려면 매개변수를 출력 값에 지정하면 된다. 
// 아래와 같이 작성해보자

void a(int v1){System.out.println(v1);} // 100

void b(char v1, int v2){System.out.println(v1); // B

System.out.println(v2) // 200

}

위의 방법은 메서드에 매겨변수로 받은 변수들의 활용이다 그 매개변수들은 실행문 즉 블럭에서 사용이가능하다

이렇게 다른 클래스에서 어떠한 값을 가지고 있는 변수를 호출시 매개변수로 지정을하게되면 클래스 내부의 값을 다른 클래스로 전달하는 효과를 가질 수 있다

 

이러한 활용을 잘 익혀두자

 

-명령행 개수 과 method 활용 예문-

명령행 개수를 활용하여 cmd창에서 값을 바꿔어 가면서 연습할 수 있다

 

2020/06/11 - [Java/Java 입문] - [Java] 명령행 매개변수 cmd창에 직접 값넣기

 

[Java] 명령행 매개변수 cmd창에 직접 값넣기

오늘은 명령행 매개변수를 알아보자 cmd창에서 입문자들이 연습을 할 때 사용하면 엔트리 포인트에 args[0]를 어떻게 활용하는지 알 수 있다 -명령행 매개변수- class AB{ public static void main(String[] args

tantangerine.tistory.com


class Gugudan{

  void print(int dan){

    System.out.println(dan+"단");

    for(int num=1; num<10; num++){ // dan 명령행 매개변수가 실행되면 지정한 숫자만큼 for문으로 실행

      System.out.print(dan); // 결과 값을 출력한다

      System.out.print("*");

      System.out.print(num);

      System.out.print("=");

      System.out.println(dan*num);

    } // 클래스 Gugudan 에서

  } // method 변수 print 매개변수 이름은

} // method 선언문의 매개변수와 같아도 무관하다

class H{

  public static void main(String args[]){

    Gugudan a=new Gugudan();

    int dan=Integer.parseInt(args[0]); // 명령행 매개변수가 지정되어 실행될 때 dan에 정수 값이 저장되고

    a.print(dan); // a.print(dan); dan이 args[0] 실행되어 method를 호출한다

  }
}

위에서 보듯이 arg[0]을 호출문에 작성하고 cmd창에서 값을 입력하여 실행할 수 있다

자세한 사항은 다음 포스팅에 설명할 수 있는 기회를 삼아 보겠다

 

 

 

-반환형이 있는 method 선언-

[선언하기]

자료형 method명(){

  명령문;

  ....

  return 값;

}

 

class H{

  int a(){System.out.println(1); return 100;}

  String b(){System.out.println(2);return "aa";}

  boolean c(){System.out.println(3);return true;}

  // 반환형 method는 return 값을 지정한다 이 때 그 값은 method 타입과 일치시킨다

}

class I{

  public static void main(String[] args){

    System.out.println(4);

    H o = new H();

    int v1=o.a(); // method a를 불러들이고 싶을 때 무 반환형과는 달리 method 타입을 같게 한다

      // 그 이유는 method a의 return 값이 100이며 그 100의 값이 호출문으로 돌아와 v1에 저장된다

      // 저장될 때 정수의 값 100이 저장되므로 자료형의 타입 int를 맞춰주어야 한다

      // 계속해서 int v1=o.a(); 에서 단독의 o.a(); 호출문에 의해

      // out.println가 발생하고 그 값은 1이 출력된다

      // v1의 값이 출력하고 싶다면 아래와 같이 System.out.println(v1); 작성하여 변수설정을 한다

      // 그 출력 값은 100이 된다

    String v2=o.b();

    boolean v3=o.c();

    System.out.println(v1);

    System.out.println(v2);

    System.out.println(v3); //결과 1 2 3 100 “aa” true

  }

}

 


반환형있는 메서드는 메서드를 실행하고 어떠한 결과 값을 메서드 호출한 곳으로 리턴시켜준다

이 반환형있는 메서드는 자바에서 아주 중요하다고 할 수 있다 

실제로 어느 프로젝트에서도 가장 기본이되는 자바 중에서도 이 메서드 활용이 제일 큰 비중을 차지할 것이다

그러니 메서드의 활용과 개념은 꼭 확인 해두자! 

 

 

-method 배열선언 return 배열 활용문 -

 

반환형있는 메서드의 리턴값을 배열로 선언하고 그에 따른 활용법을 알아보자


class M{

  int m1(){ return 1;}

  String m2(){ return "aa";}

    int[] m3(){

      int[] array={2,3,4}; // method 실행문에서 배열을 선언해서 그 배열의 변수를 return 하여

      return array; // 호출문에서 활용이 가능하다.

  }

}


class N{

  public static void main(String[] args){

    M o=new M();

    int v1=o.m1();

    String v2=o.m2();

    int[] v3=o.m3(); // return array 값은 배열이기 때문에 자료형도 1차원 배열로 만듬

    System.out.println(v1);

    System.out.println(v2);

      for(int b=0; b<3; b++){ // for 문으로 한번에 출력

        System.out.println(v3[b]);
      }
  }
}

이렇게 리턴값에 배열로 선언하여 호출문에서 그 배열을 활용할 수 있다

어떻게 보면 자바스크립트에서 함수와 모듈의 느낌이 비슷할 수 있다

그 느낌을 살려 활용법과 개념을 필히 익히도록하자

 

 

아래에 문제를 한개를 준비 했다 

밑에 호출문을 보고 여러 클래스를 만들어서 선언문을 작성 하면 된다 

 

 결과적으로 v1.printInfo() 라는 메서드를 실행하면

 

이름 : 박혁민, 지역 : 서울, 학교 : 서울초등학교, 학년 : 5

 

위의 문자열이 출력되게 코드를 작성하면 된다


class O{
	public static void main(String[] args){
    
		Location v2=new Location();	v2.name="서울";		// 객체 생성된 변수를 이용하여
        
		School v3=new School();		v3.name="서울초등학교";	// 클래스 멤버변수의 값을 할당한다
        
		Child v1=new Child();		v1.name=“박혁민”;		
        
		v1.setValue( “박혁민”, 6, v3, v2 );
        
		v1.printInfo();
	}

여기서는 멤버, 로컬, 매개 변수를 활용하여야 하고 객체모델링을 정확히 이해하고 해야만 가능할것같다

그럼 다음 포스팅인 객체모델링 멤버, 로컬, 매개 변수에 따른 메서드의 활용에서 이 문제를 같이 해결해보자

 

 

 

 

728x90
반응형
728x90
반응형

오늘은 명령행 매개변수를 알아보자 cmd창에서 입문자들이 연습을 할 때

사용하면 엔트리 포인트에 args[0]를 어떻게 활용하는지 알 수 있다

 

 

-명령행 매개변수-


class AB{

  public static void main(String[] args){

    System.out.println(args[0]);

    System.out.println(args[1]);

    System.out.println(args[2]);

  }

}

위와 같이 명령행 매개변수는 args[0]을 우리가 지정할 수 있다는 것이다

그것도 cmd 창에서 말이다

위 코드를 작성하고 자바를 컴파일한 후 클래스를 실행 시킬때 숫자를 작성 하면 그 값이 cmd 창에서 확인이 가능하다

  상세한 설명은 아래에서 하겠다

 

 

 


class U{

  public static void main(String[] args){

    int a=args.length;

    System.out.println("배열의 길이 :" + a);

  }

}

java U 100

cmd창에서 위처럼 입력하게 된다면 

 

100이라는 숫자는 문자의 타입을 갖는 배열의 길이 변수 a에 저장된다

그 출력 값은 “배열의 길이  :+ 100”이 된다

 

이때 문자 값을 가지는 명령행 매개변수는 연산을 수행하기 어려워서 문자열을 정수로 변경하여 수행한다

 

 

이때 잠시 문자열을 정수로 변경하는 법을 알아보자

 

-문자열을 정수로 변경- ( parse - 문자열을 구문 해석하다 )

 


int 변수=Integer.parselnt(배열의 길이 변수 or 문자 타입의 변수)-

int a=Integer.parseInt(100);오류

int a=Integer.parseInt("100");정상

int a=Integer.parseInt("백");오류



class V{

  public static void main(String[] args){

    String a="100";

    int b=Integer.parseInt(a);

    System.out.println(a+200); // 100200

    System.out.println(b+200); // 300

  }
}


//java V 100 200 실행 시 위와 같이 값이 다름을 알 수 있다

 


-명령행 매개변수, 문자열 정부 변환 동시 활용법-


class W{

  public static void main(String[] args){

    int a=Integer.parseInt(args[0]);

    int b=Integer.parseInt(args[1]);

    System.out.println(args[0]+args[1]); 

    System.out.println(a+b); // 300

  }

}

//java V 100 200 실행 시 연산자를 통한 명령행의 합산 값을 출력할 수 있다



 


-명령행 매개변수, if 문 동시 활용 법-


class Y{

  public static void main(String[] args){

  Int a=Integer.parseInt(args[0]); // 문자열인 명령행 매개변수를 정수로 바꿔준다

    if(a>0){ // 출력되는 명령행 매개변수의 값이 0보다 크면

      System.out.print("양수"); // 양수 실행이 되며 아닐 시 음수가 된다

    }else{

      System.out.print("음수");

    }
  }
}





-명령행 매개변수, for문, 배열 길이 구하기 동시 활용법-


class A{
	public static void main(String[] args){
	int len=args.length;		
	for(int a=0; a<len; a++)		
	System.out.println(args[a]);		
	}
}
 // 명령형 매개변수의 배열의 길이를 구하여 java A 100 200 300 지정순간
 // 배열의 길이를 구한다 len=3이 된다 그 값으로 for문에 활용하여
 // 출력값에 args[a] for문 변수 a를 인덱스 넘버에 지정하면 값이 출력된다

솔직히 명령행 매개변수가 그렇게 실무에서도 많이 쓰는지 나도 모른다 내경험에서는 거의 없다고 볼수 있다

하지만 어느 개념이든 어떠한 기능이든 배움에는 다른 것들과 함축되어 더 이로움을 주는 것은 확실하다고 생각한다

그러니 이것저것 많이 알아보자

728x90
반응형
728x90
반응형

REST API가 아닌 다른방식으로 데이터를 가져올 수 있다

그것은 페이스북에서 개발하고 사용하는 GraphQL이다 

 

이 방법은 URL이 필요없으며, 당연히 Parameter도 필요없다

그말 즉슨, form-data와 body-parse하는 모든 과정들이 필요가 없어진다 

 

이 하나만으로도 엄청난 장점일 수밖에 없다

 

이전 페이지에서 셋팅법을 소개 하였고 그 것을 조금 따라해본다면 쉽게 결과물을 가져올 준비가 되었을 것이다

 

 

스키마 정의 즉 데이터 가져올 타입과 데이터의 일부분만 가져올 수 있게 형식도 지정하게된다


// File:schema.graphql
type Person {
    id: Int!
    name: String!
    age: Int!
    gender: String!	// ! 느낌표의 의미는 필수항목의 의미이다
}                   

type Query {       
    people: [Person]!          // people은 많은 Person을 포함하고있다라는 뜻으로 배열로 묶어준다
    person(id: Int!): Person!  // person의 누구를 찾을것인지 함수와 비슷한 형식을 지정해준다
    						   // 그리고 ':' 뒤에는 리턴되는 형식이 Person이라고 지정한다
}

즉, type을 지정하여 그 객체인 Person을 불러올 때 
person(id: 1){
  name
} // 라고만 하면 id 1에 해당하는 person에 이름을 가지고 오게된다

/*
또한, 간단한 정의는 Query(질문을)를 resolve(해결하는) 함수를 만드는거라고 생각하면된다
그것은 Query라는 타입으로 질문의 타입을 정의하고 그 데이터 형식(타입)을 지정한다
지금은 type Query, type Person이라는 것이다

그리고 이 모듈은 index.js를 생성하면서 GraphQL을 생성할때 Query와 resolvers를 같이 맵핑하여
서버를 구축하게된다
*/

 

이렇게 스키마 정의를 하고 데이터를 어떻게 받을지 어떻게 가공할지에 대한 형식을 정해

우리는 데이터 받을때 형식과 폼을 맞추지 않아도 된다는 것이다

 

그럼 두 번째로는 이 형식에 맞게 데이터를 조작할 함수를 생성한다

 


// File: resolvers.js
import { people, getById } from './db';
const resolvers = {
    Query: {
        people: () => people, 
        person: (_, { id }) => getById(id) 
    }                           
}

export default resolvers;

// 이 resolvers 파일은 schem에 정의되어있는 형식과 타입에 맞춰 우리는 쿼리를 사용할 수 있다

 

이렇게 만들어진 두개의 파일은 API서버를 생성할때

아래와 같이 정의하여 생성하게된다

 


// File: index.js

import { GraphQLServer } from "graphql-yoga";
import resolvers from "./graphql/resolvers"

const server = new GraphQLServer({
    typeDefs: "graphql/schema.graphql", // 스키마정의가 되어있는 곳을 Defs로 둔다
    resolvers   		// 결과 값을 실행할곳을 성정한다 단지 이 4줄로 끝이다
});

server.start(() => console.log("Graphql server Running"));

// API서버를 만들기 위해서는 위와같이 두가지사항을 정의한다
// 정의되는 사항은 파일경로 import 해온 정보들을 저장한다

 

그리고 데이터를 정의하여 연습을 진행하자

 


// File: db.js
export const people = [
    {   
        id: 0,
        name: "Jisu",
        age: 18,
        gender: "female"
    },
    {
        id: 1,
        name: "Deal",
        age: 18,
        gender: "female"
    },
    {
        id: 2,
        name: "JD",
        age: 18,
        gender: "male"
    },
    {
        id: 3,
        name: "Japan Guy",
        age: 18,
        gender: "male"
    },
    {
        id: 4,
        name: "Nicolas",
        age: 18,
        gender: "female"
    },
];

export const getById = id => {
    const filteredPeople = people.filter(person => person.id === id);
    return filteredPeople[0]
}

// db에 우선에서 getById를 함수를 만들어서 데이터를 가공을 한다
// 그 결과를 리턴값으로 돌려준다
// 그 값을 받는 곳은 getById()를 사용하는 곳이다

 


 

db에 간단한 getById 함수를 선언하여 해당하는 id를 사용하는 사용자정보를 구해올 수 있게 한다

 

아래의 사진은 http://localhost:4000/으로 어떻게 데이터가 오는지 확인할 수 있다

 

 

Graph API 활용

 

 

이렇게 기본기를 만들어 보았다

앞으로 무비앱을 만들기위한 기본 토대가 될것이다

 

 

 

 

 

 

 

728x90
반응형
728x90
반응형

삼항연산자 (항이 3개인 연산자)

 

자료형 변수 = 조건 ? 값 1 : 값2;  <--코드식

자료형 변수 = 조건 ? 값 1 : ( 조건 ? 값 2 : 값3 );

 

조건이 true이면 값1이 변수에 할당된다

조건이 false이면 값2가 변수에 할당된다

 

예제를 한번보고 넘어가도록 하자


class C{

  public static void main(String[] args){

    int num=-9; //예제에서 num은 –9가 되므로 0보다 크지 않기 때문에

    String a=num>0 ? "양수" : "음수"; //조건식에 false가 선언되어 우측변수에 할당된다 

    System.out.println(a); //결과는 음수이다.
  }

}

위와 같이 num이 0보다 크다면 첫번째 섹터에 있는 "양수"를 String a 저장하고

크지 않다면 "음수"를 String a에 저장하게 된다 

 

다른 예제를 살펴 보도록 하자

 


class E{

  public static void main(String[] args){

    int num=0;

    String a= num==0 ? "영" : ( num<0 ? "음수" : "양수") ;

    System.out.println(a); 
  }
}

class E{

  public static void main(String[] args){

    int num=0;

    String a= num!=0 ? ( num<0 ? "음수" : "양수") ; "영"

    System.out.println(a); 
  }
}

위와 같이 중복으로 사용할 수 있다.

조건식에 num의 값이 0으로 true일 경우 “영” 이 호출되지만

만약 false 경우 오른쪽 중괄호 조건식을 향한다. 이때 중괄호 안에 조건식을 선언해서

구체적인 값을 다시 물어볼 수 있다

 

 

 

return 삼항연산자, method 동시 활용법


class Mymath{

  int max(int a, int b){

  return a>b ? a:b; // 명령행 매개변수의 값이 지정하면 method 선언으로

  } // return 값을 호출문에 돌아간다

} // v3에 그 값은 저장이 되고 출력문을 통해 v3가 출력된다


class Z{

  public static void main(String[] args){

    Mymath o=new Mymath();

    int v1=Integer.parseInt(args[0]);

    int v2=Integer.parseInt(args[1]);

    int v3=o.max(v1,v2); // 명령행 매개변수를 정수로 변환하여

    System.out.println(v3); // 그 변수를 method 매개변수에 재할당된 값으로

  } // 삼항연산을 한 값을 return을 하여 호출문에서 출력한다

}

class I{

  public static void main(String[] args){

    int num=Integer.parseInt(args[0]);

    String a= num>0 ? "양수" : "음수"; // num이 0보다 작을 때 a에 음수가 저장되고

    String a1= num==0 ? "영" : a; //num이 0과 같지 않을 때 a가 a1에 저장된다

    //이때 a는 음수라는 문자열 값을 가진다

    System.out.println(a1);
  }
}


위의 메서드를 활용해서 삼항연산자를 사용하면 일정 값을 대치하여 간편하게 이용할 수 있다

 

 

 

-삼항연산자, 논리연산자 활용예문-


class A{

  public static void main(String args[]){

    int age=35;

    String a= (20<=age && age<30) ? "20대" : "20대아님";

    System.out.println(a);

  }
}

 


마지막으로 삼항연산자를 이용하여 짝, 홀수 판별해보자

 

public class EvenOddTriCondition {

  public static void main (String[] args) {
  
    int temp = 99;
    
    temp = (temp%2==1) ? temp*3+1 : temp/2;
    
    System.out.printf("계산 후=%d\n", temp);
    
  }
  
}

 

temp가 6일 때 (temp%2)는 0으로 짝수이다. 홀수가 아니므로 temp/2인 3을 temp에 대입한다.

temp가 5일 때 (temp%2)는 1로 홀수이다. 홀수이므로 tempX3+1인 16을 temp에 대입한다.


 

논리 연산자와 삼항연산자를 동시에 사용할 수 있다

이러한 예제를 많이 보는것이 어떻게보면 코드를 잘할 수 있을거라고 생각한다

보지도 않고 창의적으로 생각해서 코드짤수 있다면 얼마나 좋을까

그렇지 못한 필자는 여러가지 쿡북용 책도 많이 보는 편이다

 

 

 

2020/06/02 - [Java/생성자] - Java - 생성자 호출과 선언, 개념

 

Java - 생성자 호출과 선언, 개념

생성자 기본 method 형식에서 클래스 변수로 method를 생성한 선언문이다 객체 생성할 때 매개변수 값을 동시에 선언하는 방식으로 식은 다음과 같다. ( 클래스 변수 식별자변수=new 클래스 변수(매��

tantangerine.tistory.com

 

728x90
반응형
728x90
반응형

프로젝트 만들 폴더를 만들고 그 안에서 yarn init 레퍼지토리 등등 설정을 하고

code . ---> vscode를 열수 있음

지금 현재 폴더에서 vscode 들어가서

git init .

git remote add origin https://github.com/nomadcoders/movieql

git pull origin master

 

yarn add graphql-yoga

yarn global add nodemon

 

.babelrc 파일을 만들어서 바벨을 설치 한다


//File: .babelrc

{

"presets": ["env", "stage-3"]

}

yarn add babel-cli babel-preset-env babel-preset-stage-3 --dev

추가적으로 바벨의 설치한다


//File: package.json

{
  "name": "movieql",
  "version": "1.0.0",
  "description": "Movie API with Graphql",
  "main": "index.js",
  "repository": "https://github.com/paradox1107/movieql",
  "author": "Nicloas Serrano Arevalo<nico@nomadcoders.co>",
  "license": "MIT",
  "dependencies": {
    "graphql-yoga": "^1.18.3"
  },
  "scripts":{
    "start": "nodemon" // index.js 파일을 주시하게된다. yarn start 할때마다 nodemon이 활성화된다
       // nodemon은 파일을 수정할때마다 서버를 재시작해줄것이다
  },
  "devDependencies": {		// 바벨을 설치하고 나면 아래의 4줄이 생성될것이다
    "babel-cli": "^6.26.0",
    "babel-node": "^0.0.1-security",
    "babel-preset-env": "^1.7.0",
    "babel-preset-stage-3": "^6.24.1"
  }
}

 

이제 준비 작업은 끝이 났다 

 

GraphQL로 해결할 수 있는 두가지 문제를 알아보자

1. Over-fetching

2. Under-fetching

 

 

/user/1/GET

 

* 예로 user의 이름을 웹에보여주고 싶다고 가정을 하자

* 하지만 일반적으로 지금까지 사용한 서버는 이름만 가져오는 것이 아니라

* 성이나 프로필사진같은 모든 유저들의 정보를 받게된다

* 이것을 Over-fetching라고 한다

* , 내가 요청한 영역의 정보보다, 많은정보를 서버에서 받게되는 것을 말한다

 

* Under-fetching은 어떤 하나를 완성하기위해 내가 다른 요청들을 해야할 때 발생한다.

* 예를 들어 우리가 인스타그램의 앱을 시작하려면 많은 정보를 받게된다

* , 아래의 코드처럼 3가지 요청이 3번 오고가야 앱이 시작된다

* 이것이 Under-fetching이다

* 이 문제를 해결하기 위해 GraphQL은 URL 체계가 존재하지 않는다

 

/feed/

/notifications/

/user/1/

 

/graphql // 위의 코드가 아닌 하나의 종점만 있을 뿐이다 이걸로 모든것이 가능해진다

 

// 아래의 GraphQL 언어를 만들어서 하나에 모든것을 담아서 보내고 받을 수 있다


{
  feed {
    comments
    likeNumber
  }
  Notifications {
    isRead
  }
  user {
    username
    profilepic
  }
}

// 위의 코드GraphQL에 보내고 밑의 코드GraphQL에서 보낸 java script Object이다

// 내가 요청한 것만 정확하게 보내주는 것을 알 수 있다


 

{
  feed: [
    {
      comments: 1,
      likeNumber: 20
    }
  ],
  notifications: [
    {
      isRead: true
    },
    {
      isRead: false
    }
  ],
  user: [
    {
      username: "kim",
      profilepic: "http"
    }
  ]
}

 

 

728x90
반응형
728x90
반응형

ES6 모듈 시스템에서는 default 키워드를 사용하여 모듈에서 기본으로 내보내는 값을 정의할 수 있다.

숫자, 문자, 불리언과 같은 기본형 값과 객체, 함수, 클래스와 같은 참조형 값 모두올 수 있다.

 


export default 'hello';
export default function hello(name) {
  console.log('hello' + name);
};

export default class Hello {
  constructor(greeting) {
    this.greeting = greeting;
  }
  hi(name) {
    console.log(`${this.greeting} ${name}`);
  }
}

default 키워드 사용에 있어 중요한 점이 있는데, default 키워드는 하나의 모듈에서 한 번만 사용할 수 있다.

즉, 한 파일에서하나의 값만 default로 정의할 수 있다.

 

default 키워드 다음에는 var, let, const와 같은 변수 선언 키워드가 올 수 없다.

default는 사실 해당 모듈의 기본값을 선언하는 것이기 때문에 변수 선언 키워드가 오면 문법적 오류를 발생한다

예를 들어, A라는 모듈이 있으면 A.default = 'hello'와 같이 A모듈의 기본값을 할당한다고 볼 수 있다

 

 


//File: app.js
import Hello from './hello,js';

const koreanHi = new Hello('안녕하세요.');
koreanHi.hi('하린');

 


hello.js에서 default로 내보낸 값을 가져오고 import하는 모듈에서(현재 파일) 이름을 부여한다.

여기에는 Hello라는 이름으로 부여하였다

 

hello.js에서는 클래스를 기본값으로 내보냈기 때문에 new 키워드를 사용하여 객체를 생성한다.

 

Hello 클래스의 인스턴스인 koreanHi의 hi메소드를 호출한다.

 

위 코드를 크롬 콘솔에서 확인하면 다음과 같다

 

결과 : 안녕하세요. 하린


 

이렇게 모듈의 default 값을 가져오는 활용방법을 알아보았다

어느 한 파일에서 export default가 되어있는 부분을 다른 파일에서 불러오는것이 가능하다

그것은 import로 가져오게 되는데 이때 가져올때 이름은 꼭 export default에 맞춰서 import 할 필요가 없다

즉, import하는 파일에서 이름을 지정하여 사용하면된다.

그렇게 사용하면 모듈화된 파일안에 정의된 함수, 변수를 사용할 수 있다

 

다음은 모듈을 여러 이름으로 내보내고 가져오는 방법을 알아보자

 

 

2020/06/08 - [JavaScript/모듈 이해하기] - 자바스크립트 모듈 시스템 이해하기 - 번들링(Bumdling) 웹팩(Webpack)

 

자바스크립트 모듈 시스템 이해하기 - 번들링(Bumdling) 웹팩(Webpack)

ES6의 모듈 자바스크립트 코드를 담고 있는 하나의 파일이다. 즉 하나의 파일이 하나의 모듈이라고 볼 수 있다. ES6의 모듈은 엄격한 모드의 코드이고 import와 export 키워드를 사용한다. export 키워��

tantangerine.tistory.com

 

728x90
반응형
728x90
반응형

ES6의 모듈 자바스크립트 코드를 담고 있는 하나의 파일이다. 즉 하나의 파일이 하나의 모듈이라고 볼 수 있다.

ES6의 모듈은 엄격한 모드의 코드이고 importexport 키워드를 사용한다.

export 키워드르르 이용하여 모듈내의 특정 코드를 외부에서 사용할 수 있다. 그리고 import 키워드를 이용해서 export 한 코드를 가지고 올 수 있다.

간단히 모듈을 정의하고 코드를 외부로 내보내고 가지고 오는 예제를 살펴보자.


//File: hello.js
export function hello(name){
 console.log(`hello ${name}`);
}


//File: app.js
import {hello} from './hello.js';

hello('es6 module'); // hello es6 module 출력된다.

두 모듈은 단순한 자바스크립트 파일이다.

hello.js에서는 hello 함수를 정의하고 이함수를 export 키워드를 이용하여 외부에서 가져올 수 있게 내보냈다.

app.js에서는 hello.js의 hello함수를 import키워드를 이용하여 가지고 온다.

이렇게 가져온 함수는 app.js 모듈내에서 자유롭게 사용할 수 있다

 

이렇게 하나의 모듈이 다른 모듈에서 내보낸(Export) 코드를 가져오면(Import) 두 모듈은 서로 의존하게 되어 의존관계가 형성되고 여러 모듈들은 의존관계를 맺어 의존관계 그래프가 형성되게 된다. 그리고 의존 관계 그래프에서는 최상의 루트가 필요한데 이루트 모듈이 애플리케이션의 시작 지점이 된다.

자바나 C언어에서의 메인 메소드와 같다고 생각하면 된다.

위 예제 코드에서는 app.js가 루트 모듈이라고 볼 수 있다.

 


ES6의 모듈로 정의된 파일들은 실행하는 방법에 따라 두 가지로 분류할 수 있다

 

* 런타임 로딩(Runtime Loading)

런타임 로딩은 의존 관계가 형성된 모듈들을 애플리케이션이 구동 시점에 비동기 HTTP 요청으로 불러오고 실행된다. 이때 모듈 로더가 필요한데 system.js 나 require.js를 이용할 수 있다

 

 

 

 

 

 


* 번들링(Bumdling)

번들링은 의존 관계가 형성된 모듈들을 하나의 파일로 묶어 준다.

그리고 애플리케이션이 구동할 때 묶여진 이 파일을 로드한다.

번들링은 개발 시점에 이루어지게 되고 브라우저에서 이루어지지 않고 대체로 node.js 환경에서 이루어지게 된다.

대표적인 모듈 번들로는 웹팩(Webpack)이 있다

 


* 웹팩(Webpack)

웹팩은 모듈 번들러로 자바스크립트 코드 외에 CSS, 이미지, 폰트 등 다양한 자원들을 모듈화시켜 의존 관계 그래프를 형성하여 병합된 파일들을 만들 수 있다.

node.js 플랫폼에서 동작하는 애플리케이션이고 다양한 플러그인들을 제공하고 있다

 

Bundler 여러 개의 파일을 묶어주는 파일로 여러 가지가 있다 그중 Webpack을 공부하자

웹에서도 모듈을 사용하고 여러개의 파일을 묶어서 제공하고자 사용한다

그 이유는 프로젝트가 많은 양의 js, css파일등이 필요하기 때문에 많은 작업들을 수행해야 하기 때문

최신 브라우저에 사용할 수 있으며 bundle.js로 오래된 브라우저도 지원이 가능하게된다

 

//File: hello.js
var word = 'hello';

export default word;

//File: word.js
var word = 'World';

export default word;



//webpack – module

//File: index.html

<div id="root"></div>

<script type="module">

import hello_word from "./source/hello.js";

import world_word from "./source/world.js";

document.querySelector('#root').innerHTML = hello_word + ' ' + world_word;

</script>

 

Webpacknpm install D webpack-cli을 하여 webpack을 설치한다

webpack 적용을 하기위해 모듈화하여 .js파일을 추가하고 index.html파일을 수정한다

 

// File: index.html -- (entry 파일 추가 & 수정)
<div id="root"></div>

<script src="./public/index_bundle.js">

import hello_word from "./hello.js";

import world_word from "./world.js";

document.querySelector('#root').innerHTML = hello_word + ' ' + world_word;

</script>

 

npx weppack entry

./source/index.js output

./public/index_bundle.js

 

위의 명령어를 실행하면 entry 파일인 index.js 에서 사용하고 있는 모든 파일을 index_bundle.js에 출력하라는 의미

 

웹을 실행하면 출력은 전과 같게 동일하지만 js파일은 한 개만 로드한다


<!DOCTYPE HTML>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Module Sample</title>
  <script type="module" src="app.js"></script>
</head>
<body>
</body>
</html>

위 코드를 크롬 콘솔에서 확인 하면 다음과 같다

결과 : hello es6 module


 

2020/06/08 - [JavaScript/모듈 이해하기] - 자바스크립트 모듈 시스템 이해하기 - 번들링(Bumdling) 웹팩(Webpack)

 

 

자바스크립트 모듈 시스템 이해하기 - 번들링(Bumdling) 웹팩(Webpack)

ES6의 모듈 자바스크립트 코드를 담고 있는 하나의 파일이다. 즉 하나의 파일이 하나의 모듈이라고 볼 수 있다. ES6의 모듈은 엄격한 모드의 코드이고 import와 export 키워드를 사용한다. export 키워��

tantangerine.tistory.com

 

728x90
반응형
728x90
반응형

오늘은 자바스크립트의 모듈에 대해서 이야기 해보자


모듈은 파일이나 코드의 묶음 단위로 애플리케이션 하나의 구성요소로 볼 수 있다. 이렇게 모듈로 정의 하면 모듈단위로 코드를 재사용 할 수 있고, 하나의 애플리케이션이라는 큰 기능을 작은 기능단위로 잘게 분리하여 관리할 수 있다.

예를 들어, 베이스볼 게임이라는 애플리케이션을 문제 생성 모듈, 플레이어 관리 모듈, 등과 같이 여러 모듈로 구성할 수 있다

 

* 위와 같이 여러 장점들이 있지만 너무 많이 모듈화를 한다면 유지 보수나 다른 개발자들이 수정작업을 할때 불필요한 작업들이 발생한다 관리모듈이든, 문제 생성 모듈이든, 그 모듈은 분명한 작업들을 관리하는 작업이야 한다

단순히 어떠한 기본값들을 모듈화해서 관리할 필요는 없을 것이다

 

ECMAScript 5.x 버전까지는 모듈에 대한 정의를 자바스크립트 표준으로 제공하지 않았다  그래서 네임스페이스 패턴을 통해 모듈을 정의 했다. 다음의 예제를 통하여 네임스페이스 패턴을 알아보자.

 

var namespaceA = (function(){
	var privateVariable = '비공개 변수';
    return {
    	publicApi: function(){
        	console.log(privateVariable + '를 접근할 수 있습니다.');
        }
    }
})();

namespaceA.publicApi();

 

네임스페이스란 C# 언어에서 제공하는 기능으로 코드를 그롭화하고 이름 충돌을 방지하게 도와준다

하지만 자바스크립트에서는 네임스페이스를 직접적으로 지원하지 않는다. 그래서 함수를 정의함과 동시에 실행하는 즉각 호출 패천을 통하여 네임스페이스를 유사하게 구현할 수 있다. 이렇게 하는 이유는 기본적으로 변수와 함수를 기본적으로 선언하게 되면 전역으로 정의되어 다른 라이브러리나 타인의 코드에서 정의된 이름들과 충돌이 날수 있기 때문이다.

 

 

위 예제는 즉각 호출 패턴을 통해 함수를 정의함과 동시에 실행하여 util이라는 네임스페이스를 생성하고 있다.

var 키워드로 생성된 변수의 스코프는 함수이기 때문네임스페이스안에 정의 된 변수들을 그 외부에서 접근을 못한다

 

즉시 호출 패턴인 (function(){//코드})();를 통하여 namespaceA의 변수에 함수에서 반환된 객체를 할당 한다.

 

함수 안에 선언된 변수는 함수 내부에서만 접근이 가능하기 때문에 비공개 영역이 된다.

 

반환되는 객체는 namespaceA에 할당되고,

외부에서 접근이 가능하기 때문에 해당 객체의 속성과 메소드들은 공개 API가된다.

 

namespaceA의 publicApi 메소드를 호출한다

 

 

위 코드를 크롬 콘솔에서 확인하면 다음과 같다

 

 

결과


비공개 변수를 접근할 수 있습니다


namespaceA 자체는 전역으로 등록되기 때문에 여전히 이름 충돌이 발생할 수 있다. 그리고 즉시 호출패턴을 통해 정의된 다른 모듈을 사용하는 것 또한 전역을 통해 가져오게된다 이러한 문제점을 햄결하기 위해 ES6 이전에는 RequireJS를 통하여 모듈을 정의 하였다.

 

ES6에서 모듈시스템에 대한 표준이 정의 되었기 때문에 RequireJS과 같은 별도의 라이브러리 필요없이 이러한 문제점을 해결할 수 있다 

 

 


 

 아직 es6를 사용하지 않는 프로젝트들이 많이 있다 이러한 방식으로 사용하여 모듈화를 하는 일이 많이는 없지만 일단 이러한 것도 있구나 하며 이번 페이지는 넘어가도록 하자

728x90
반응형
728x90
반응형

배열 뒤에 요소를 추가하는 방법으로 push를 알아보도록하자

 

자바스크립트 배열 자료형은 Linked List 자료구조 형태를 갖고 있다.

 

따라서 배열 앞과 뒤에서 요소를 추가하는 것이 가능하다

 

Array 내장객체 메소드 push배열 뒤에서 요소를 추가한다

 

const festa = ['mang'];

festa.push('chimmy');

festa.push('tata')

festa.push('cooky');

festa.push('shooky');

festa.push('koya');

festa.push('rj');

festa.forEach(name => {

  console.log(name);

});

//결과

mang

chimmy

tata

cooky

shooky

koya

rj

문장 순서대로 festa 배열 뒤에 요소를 추가한다

 

반복문을 이용하여 festa 배열의 요소들을 콘솔로 출력한다.

 

위 코드를 크롬 콘솔에서 확인하면 결과가 위와 같이 나온다

 

아래와 같은 코드를 다시 보며 잘 생각 해보자

 

배열의 처음이나 끝에서 요소 하나를 추가하거나 제거하고 나머지를 변수에 저장한다

 

const array2 = ["b", "c", "d"];

const a9 = array2.push("e"); 

//배열의 요소 "e"가 마지막 배열 인덱스에 추가되고 배열길이 값을 a9에 저장된다

배열의 요소 "e"가 마지막 배열 인덱스에 추가되고 배열길이 값을 a9에 저장된다

 

 

2020/06/02 - [JavaScript/splice 배열 인덱스로 특정요소 수정하기] - splice - 배열 인덱스로 특정 요소 수정하기

 

splice - 배열 인덱스로 특정 요소 수정하기

Array 객체의 메소드 splice는 특정 위치의 요소를 샂게하거나 수정할 수 있다. 배열.splice(시작 인덱스, 삭제할 요소의 개수, 추가될 요소들 ...) 첫 번째 인자인 시작 인덱스는 배열 요소가 변경될 ��

tantangerine.tistory.com

 

728x90
반응형
728x90
반응형

Array 객체의 메소드 splice는 특정 위치의 요소를 샂게하거나 수정할 수 있다.

 

배열.splice(시작 인덱스, 삭제할 요소의 개수, 추가될 요소들 ...)

 

첫 번째 인자인 시작 인덱스는 배열 요소가 변경될 시작 지점입니다. 

splice는 측정 위치의 요소를 지정하는 것이 필수이므로 반드시 첫 번째 인자값은 배열 길이보다 작아야 유효한다

 

두 번째 인자인 삭제할 요소의 개수는 시작인덱스의 위치부터 삭제하고자 하는 개수만큼 요소를 제거한다.

이때 해당 요소가 제거됨과 동시에 메소드 호출 결과로 값을 반환한다.

 

세 번째 인자에 추가될 요소들을 지정하면, 시작 인덱스부터 해당 요소들이 추가된다.

 

const fruits const fruits = ['melon', 'lemon', 'source', 'apple', 'juice'];

fruits.splice(4, 1);

fruits.splice(4, 0, 'grape');

fruits.splice(2, 1, 'mandarin', 'strawberry', 'watermelon');

console.log(fruits);

 

변수 fruits에 배열 리터럴을 할당하여 선언한다.

이 배열의 내부 요소에는 문자열들이 있는데, 과일과 과일이 아닌 종류들이 섞여있다

 

splice(4, 1)를 실행하면 과일이 아닌 juice 문자열이 추출된다

 

splice(4, 0, 'grape')는 삭제할 개수를 지정하지 않아 추출되는 요소가 없다

그러나 세 번째 인자로 인해 시작 인덱스에 'grape' 문자열이 추가된다

 

결과

[ 'melon', 'lemon',  'mandarin', 'strawberry', 'watermelon', 'apple', 'juice']

728x90
반응형
728x90
반응형

생성자

기본 method 형식에서 클래스 변수로 method를 생성한 선언문이다

객체 생성할 때 매개변수 값을 동시에 선언하는 방식으로 식은 다음과 같다.

( 클래스 변수 식별자변수=new 클래스 변수(매서드 변수); )

 

class School{

String name;

School(String n){ name=n; } // 클래스 method 매개변수의 자료형과 타입을 같은 조건일 때 관계가 성립된다

}

 

class Student{

  School school;

  String name;

  Student(String n, School s){ name=n; school=s;

}                                    // 기존 method와는 클래스 이름으로 선언된 것 이외에

                                     // 호출방식과 선언방식이 동일하다

void gotoSchool(){                                             

  System.out.print(name+"이");

  System.out.println(school.name+"학교에간다");

  }

}

 

class T{

  public static void main(String[] args){

  School school1=new School("서울대");             

  School school2=new School("하버드");          

  Student s1=new Student("김상진",school1);       

  Student s2=new Student("김상훈",school2);         

  s1.gotoSchool();

  s2.gotoSchool(); 

  }

}

예로 class A{} 만들었다면 자동으로 A(){} 생성자가 클래스안에 생성되어진다

그래서 기존 A o=new A(); 만으로 객체생성을 할 수 있다 

그 이유는 자동으로 생성된 생성자매개변수에 어떠한 타입도 가지고 있지 않기 때문이다

하지만 생성자에 개발자가 매개변수의 값을 선언하게되면 객체생성 때 그 값의 타입을 선언해야지만 객체생성이 가능하다

 

 

 

 

 

 

 

728x90
반응형
728x90
반응형

카티시안(Cartesian) 곱을 이용한 조인

어떤 제품의 월별로 매출집계를 보고자 한다면 매출이 발생하지 않은 달에도 매출이 없다는 다는 것을 알기 위해 0값을 가진 로우를 출력하는 것이 좋을 것이다 이와 같이 발생한 값의 유무에 관계 없이 고정된 양식에 로우를 출력하고자 한다면 생각보다 쉽지는 않다

 

SELECT y.계정명,

  sum(decode(x.공정, ‘원사’, 금액)) 원사,

  sum(decode(x.공정, ‘제작’, 금액)) 재직,

  sum(decode(x.공정, ‘기모’, 금액)) 기모,

  sum(decode(x.공정, ‘염색’, 금액)) 염색,

  sum(decode(x.공정, ‘가공’, 금액)) 가공

FROM

  (SELECT substr(계정과목, 1, 2) 항목, 공정, sum(금액) 금액

    FROM 전표테이블

    WHERE 사업장 = ‘울산공장’

   and 전표일자 like :작업월||‘%’

   and 계정과목 between ‘1234’ and ‘6543’

   GROUP BY substr(계정과목, 1, 2), 공정) x

   , 계정테이블 y

WHERE y.계정과목 between ‘1200’ and ‘6500’

and y.항목분류 = ‘1’

and x.항목(+) = substr(y.계정과목, 1, 2)

GROUP BY y.계정명;

 

 

테이블에 항목을 나타낼수 있는 계정과목 같은 테이블이 개별적으로 존재한다면 그 테이블을 이용하여 카티시안 조인과 outer 조인을 활용하여 정보가공은 전표테이블로 가공을 하고 계정명은 과목만 나타나있는 계정테이블을 활용하여 select를 한다

항목 분류가 중요한 이유는 집합은 테이터 발생 상황에 따라 값이 존재하지 않는 계정과목이 생길 수가 있다 그래서 계정테이블이 출력한 로우 단위인 계정들만 추출하여 GROUP BY한 집합을 OUTER 조인을 하기 위함이다

하지만 항목분류번호는 없을 수 있다 그 경우는 임시테이블을 만들어서 항목별로 분류코드를 부여하여 활용하면 된다

 

728x90
반응형
728x90
반응형

카테시안(Cartesian) 곱을 이용한 조인 – 관계가 없는 테이블간의 조인

커서를 선언하여 오픈한 후 루프 내에서 반복하여 패치를 하면서 복잡한 처리를 할 때 여러개의 상위테이블 정보를 참조해야 원하는 가공을 처리할 수 있는 경우가 있다고 하자 그렇게 처리되고 가공을 하고 상수값을 결합하여 실행 한 수 그 결과를 애플리케이션에 보내주는 작업들을 진행한다 이러한 데이터 베이스 호출(DBMS CALL)은 시스템 오버헤드의 주범이라고 할 수 있다

반복 수행되는 구문 내에 여러개의 SQL이 나열되어 있는 것은 가능한 피하는 것이 좋다

 

SELECT ename, job, sal, y.loc

FROM EMP x, DEPT y

WHERE x.empno=:emp_no

AND x.sal=:sal_no

AND y.dname(+) = :dname_no||substr(x.empno,0,0)

 

조인할 때 어느 한 집합만 공집합이 되더라도 전체가 공집합이 되어버리므로 다른 성공한 집합까지 실패하게 된다

그래서 y.dame(+) = :dname_no만 작성하게되면 해당하는 dame가 null이거나 만족하는 값이 없으면 오류가 난다

위와 같은 방법으로 조인하면 DEPTNO에 해당하는 dame가 null이거나 만족하는 값이 없더라도 SUBSTR의 연산값으로 NULL이 출력된다

OUTER-JOIN은 반드시 어떤 집합과 연결을 할 때만 의미가 있다

728x90
반응형

+ Recent posts

Powered by Tistory, Designed by wallel