728x90
반응형

 

자바 개발자라면 API 호출은 일상 다반사입니다. 프론트엔드에서 주로 사용되는 API 호출 방식과 달리, 백엔드에서는 Java를 이용한 호출이 많이 이루어집니다. 특히 Apache HttpClient와 HttpURLConnection을 비교해볼 때, 각각의 장단점과 사용법을 알아보는 것이 중요합니다. 이 글에서는 두 라이브러리를 활용한 API 호출 방법을 자세히 설명하며, 왜 Apache HttpClient가 더 간결하고 효율적인지에 대해 탐구해보겠습니다.

 


 

HttpURLConnection
HttpURLConnection

 

HttpURLConnection을 이용한 API 호출

Java의 기본 라이브러리인 HttpURLConnection을 사용하면, 다음과 같은 방식으로 GET 요청을 보낼 수 있습니다.

 

HttpURLConnection을 이용한 기본 GET 요청 예제 코드

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class HttpGetRequestExample {
    public static void main(String[] args) {
        try {
            // 기본 URL
            String baseUrl = "http://example.com/api";
            
            // 파라미터 추가
            String params = "?param1=value1&param2=value2";
            String urlString = baseUrl + params;
            
            // URL 객체 생성
            URL url = new URL(urlString);
            
            // HttpURLConnection 객체 생성
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            
            // 요청 방식 선택 (GET)
            connection.setRequestMethod("GET");
            
            // 요청 헤더 추가 (옵션)
            connection.setRequestProperty("User-Agent", "Mozilla/5.0");
            
            // 응답 코드 가져오기
            int responseCode = connection.getResponseCode();
            System.out.println("GET Response Code :: " + responseCode);
            
            // 응답 코드가 200 OK인 경우, 응답 내용 읽기
            if (responseCode == HttpURLConnection.HTTP_OK) {
                BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
                String inputLine;
                StringBuffer response = new StringBuffer();
                
                while ((inputLine = in.readLine()) != null) {
                    response.append(inputLine);
                }
                in.close();
                
                // 응답 내용 출력
                System.out.println(response.toString());
            } else {
                System.out.println("GET request not worked");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 

Apache HttpClient의 등장

 

반면, Apache HttpClient 라이브러리를 사용하면, 코드가 훨씬 간결해집니다. Maven을 사용하는 프로젝트의 경우, 다음과 같이 의존성을 추가해야 합니다.

 

Apache HttpClient를 이용한 GET 방식은 다음과 같습니다.

 

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.13</version>
</dependency>

 

import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

public class HttpClientGetExample {
    public static void main(String[] args) {
        // HttpClient 객체 생성
        try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
            
            // URIBuilder를 사용하여 URL 및 파라미터 구성
            URIBuilder uriBuilder = new URIBuilder("http://example.com/api");
            uriBuilder.addParameter("param1", "value1");
            uriBuilder.addParameter("param2", "value2");
            
            // HttpGet 객체 생성
            HttpGet httpGet = new HttpGet(uriBuilder.build());
            
            // 요청 헤더 추가 (옵션)
            httpGet.addHeader("User-Agent", "Mozilla/5.0");
            
            // 요청 실행 및 응답 받기
            try (CloseableHttpResponse response = httpClient.execute(httpGet)) {
                // 응답 본문을 String으로 변환
                String result = EntityUtils.toString(response.getEntity());
                
                // 결과 출력
                System.out.println(result);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 

 

 

Apache HttpClient를 사용하면 URIBuilder를 통해 URL과 파라미터를 쉽게 구성할 수 있고, HttpGet 객체를 생성하여 요청을 보낼 수 있습니다. 이는 코드를 간결하게 만들 뿐만 아니라, 개발자가 HTTP 통신의 세부사항에 덜 집중할 수 있게 해줍니다.

 


반응형

POST 요청 방식 비교

 

POST 요청에 대해서도 비교해봅시다. HttpURLConnection을 사용할 경우, OutputStream을 통해 직접 데이터를 전송해야 합니다.

 

HttpURLConnection을 이용한 POST 요청 예제 코드

 

import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Scanner;

public class PostExample {
    public static void main(String[] args) {
        String targetURL = "http://example.com/api/resource";
        HttpURLConnection connection = null;

        try {
            // URL 객체 생성 및 연결 설정
            URL url = new URL(targetURL);
            connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Content-Type", "application/json; charset=UTF-8");
            connection.setDoOutput(true); // OutputStream을 사용하여 요청 본문에 데이터를 쓸 것임을 지정

            // 요청 본문에 JSON 데이터 작성
            String jsonInputString = "{\"name\": \"John\", \"age\": 30}";
            try (OutputStream os = connection.getOutputStream()) {
                byte[] input = jsonInputString.getBytes("utf-8");
                os.write(input, 0, input.length);
            }

            // 응답 받기 및 출력
            try (Scanner scanner = new Scanner(connection.getInputStream())) {
                while (scanner.hasNextLine()) {
                    System.out.println(scanner.nextLine());
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.disconnect();
            }
        }
    }
}

 

 

반면, Apache HttpClient를 사용하면, 객체를 JSON으로 변환하여 HttpPost 객체에 전달하는 방식으로 간결하게 처리할 수 있습니다.

 

Apache HttpClient를 이용한 POST 요청 예제 코드

 

import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;

public class JsonExample {
    public static void main(String[] args) throws Exception {
        // 객체 생성
        MyObject myObject = new MyObject();
        myObject.setName("John Doe");
        myObject.setAge(30);

        // 객체를 JSON으로 변환
        ObjectMapper objectMapper = new ObjectMapper();
        String json = objectMapper.writeValueAsString(myObject);

        // HTTP POST 요청 설정
        HttpPost post = new HttpPost("http://example.com/api");
        StringEntity entity = new StringEntity(json);
        post.setEntity(entity);
        post.setHeader("Accept", "application/json");
        post.setHeader("Content-type", "application/json");

        // 요청 실행
        try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
            httpClient.execute(post);
        }
    }

    // 자바 객체 정의
    public static class MyObject {
        private String name;
        private int age;

        // getters and setters
        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; }
    }
}

 


 

 

Apache_HttpClient
Apache_HttpClient

마무리

이 글에서는 Java에서 API 호출을 위한 두 가지 방법, 즉 HttpURLConnection과 Apache HttpClient의 사용법을 비교해보았습니다. Apache HttpClient의 사용이 더 간결하고 유연하다는 것을 확인할 수 있었습니다.

Java 개발에 있어서 이러한 라이브러리의 선택과 활용은 프로젝트의 효율성을 크게 향상시킬 수 있습니다.

 

더 궁금한 점이 있으시다면 댓글로 질문해주세요. 감사합니다.

728x90
반응형
728x90
반응형

이전 글에서 엑셀 데이터를 읽어와 DB에 저장하기

 

때로는 현업과 아님 타 부서에서 엑셀 데이터를 어드민 페이지에서 볼 수 있게 해달라고 한다면,

그리고 엑셀 파일에 수백 가지의 데이터가 있다면,

어떻게 하겠습니까? 

수 작업으로 데이터에 저장하기는 어려운 일입니다

 

그래서 엑셀을 업로드해서 자바에서 읽을 수 있는 방법을 모색해보았습니다

 

자세한 사항이 알고 싶으시면 아래의 링크를 클릭하시면 됩니다

 

 

2022.08.05 - [IT_Web/Java] - Java 엑셀 데이터 읽어오기 및 다중 insert 한방에 하기

 

Java 엑셀 데이터 읽어오기 및 다중 insert 한방에 하기

오늘은 엑셀 데이터를 업로드해서 자바에서 데이터를 받아서 insert를 하든 아니면 다시 그 데이터를 다시 조합해서 웹에 다시 전달하는 등 핸들링하는 방법을 알아보겠습니다 그리고 클래스명

tantangerine.tistory.com

 

메일 보내기 앞서 Velocity란? 무엇인가?

메일을 보내기 위해서는 HTML 태그가 필요하며

head태그와 body에 각종 태그를 삽입하여 템플릿을 만들어서 

일정한 코드를 삽입해서 로고나 이미지를 보여줄 수 있습니다

하지만 태그만 필요한 것이 아닌 DB에서 관리하는 데이터들도

같이 범용성 있게 노출시켜야 합니다

그러기 위해서 vm파일에 데이터를 같이 합성하여 사용하기 위해

velocity를 사용합니다

 

 

velocity 설정 및 추가하기

Velocity를 활용하기 위해 pom.xml에 추가합니다

 

<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity</artifactId>
    <version>1.7</version>
    <scope>system</scope>
    <systemPath>${webapp.lib}/velocity-1.7.jar</systemPath>
</dependency>

 

 

bean과 필요한 값을 설정합니다

로그인 및 비밀번호와 패스워드를 설정합니다

그리고 메일을 보낼 서비스단도 추가합니다

 

 

<!-- smtp 메일전송 -->
<bean id="mailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl"> 
    <property name="host" value="mail.######.net"/> 
    <property name="port" value="25" /> 
    <property name="username" value="xxxxxx@naver.net"/> 
    <property name="password" value="#####"/> 
    <property name="javaMailProperties"> 
        <props> 
          <prop key="mail.smtp.auth">true</prop>
          <prop key="mail.debug">true</prop>
          <prop key="mail.smtp.auth.mechanisms">LOGIN</prop>
        </props> 
    </property> 
</bean>

<bean id="mailer" class="kr.co.xxxxxx.common.mail.Mailer">
    <property name="velocityEngine" ref="velocityEngine" /><!--velocityEngine bean참조 -->
</bean>

<bean id="velocityEngine" class="org.springframework.ui.velocity.VelocityEngineFactoryBean">
    <property name="resourceLoaderPath" value="WEB-INF/mailtemplate/"/>
</bean>

 

 

위의 코드에 "WEB-INF/mailtemplate/"를 확인할 수 있습니다

그 저장소에는 mailtemplate.vm이 지정되어있습니다

아래와 같이 설정되어 메일 형식을 지정하여 보낼 수 있습니다

 

<!DOCTYPE html>
<html lang="ko">
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  <meta http-equiv="X-UA-Compatible" content="ie=edge">
  <title></title>
</head>
<body>
  <!-- header -->
  <table width="600" border="0" align="center" cellpadding="0" cellspacing="0" style="text-align:left;font-size:16px;font-family:Malgun Gothic, '맑은고딕', Dotum, '돋움', Tahoma, Helvetica Neue, Helvetica, sans-serif;background-color:#fff;margin:0 auto">
    <tbody>
      <tr><td height="100">&nbsp;</td></tr>
      <tr>
        <td>
          <table width="600" border="0" align="center" cellpadding="0" cellspacing="0">
          <tbody>
          <tr>
            <td width="139" align="left"><a href="#"><img src="images/logo.png" alt="autobell" border="0"/></a></td>
            <td width="133">&nbsp;</td>
          </tr>
          </tbody>
          </table>
        </td>
      </tr>
    </tbody>
  </table>
  <!-- //header -->

  <!-- content -->
  <table width="600" border="0" align="center" cellpadding="0" cellspacing="0" style="text-align:left;font-size:16px;font-family:Malgun Gothic, '맑은고딕', Dotum, '돋움', Tahoma, Helvetica Neue, Helvetica, sans-serif;background-color:#fff;margin:0 auto">
    <tbody>
      <tr><td height="70">&nbsp;</td></tr>  
      <tr>
        <td>
          <table width="600" border="0" align="left" cellpadding="0" cellspacing="0" style="text-align:left;font-size:16px;font-family:Malgun Gothic, '맑은고딕', Dotum, '돋움', Tahoma, Helvetica Neue, Helvetica, sans-serif;background-color:#fff">
            <tbody>
            <!-- title -->
            <!-- //title -->

            <!-- text type1 -->
            <tr><td height="50">&nbsp;</td></tr>
            <tr>
              <td style="color:#222;font-size:18px;line-height:1.6">
                '${NAME}'님
            </td>
            </tr>
            <!-- //text type1 -->

            <!-- text type1 -->
            <tr><td height="50">&nbsp;</td></tr>
            <tr>
              <td style="color:#222;font-size:18px;line-height:1.6">
                번호 : '${NO}'<br />
                성명 : '${NAME}' <br />
                도착예정시간 : '${TIME}'<br />
                연락처: '${PHONE}'
              </td>
            </tr>
            <!-- //text type1 -->

            <!-- design line -->
            <tr><td height="56">&nbsp;</td></tr>
            <tr>
              <td>
                <table width="600" border="0" align="left" cellpadding="0" cellspacing="0">
                  <tbody>
                    <tr>
                      <td height="1" width="72" style="border-top:1px solid #d8d8d8">&nbsp;</td>
                      <td height="1">&nbsp;</td>
                    </tr>
                  </tbody>
                </table>
              </td>
            </tr>
            <!-- //design line -->

            <!-- text type2 -->
            <tr><td height="40">&nbsp;</td></tr>
            <tr>
              <td style="color:#222;font-size:14px;line-height:1.6">
            </td>
            </tr>
            <!-- //text type2 -->

            <!-- link -->
            <tr><td height="25">&nbsp;</td></tr>
            <tr>
              <td>
              </td>
            </tr>
            <!-- //link -->
            </tbody>
          </table>
        </td>
      </tr>
      <tr><td height="56">&nbsp;</td></tr>
    </tbody>
  </table>
  <!-- //content -->

  <!-- footer -->
  <table width="600" border="0" align="center" cellpadding="0" cellspacing="0" style="text-align:left;font-size:16px;font-family:Malgun Gothic, '맑은고딕', Dotum, '돋움', Tahoma, Helvetica Neue, Helvetica, sans-serif;background-color:#fff;margin:0 auto">
    <tbody>
    <tr>
      <td>
        <table width="600" border="0" align="center" cellpadding="0" cellspacing="0" style="text-align:left;font-size:16px;font-family:Malgun Gothic, '맑은고딕', Dotum, '돋움', Tahoma, Helvetica Neue, Helvetica, sans-serif;background-color:#fff;border-top:1px solid #aaa">
          <tbody>
            <tr><td height="30">&nbsp;</td></tr>
            <tr>
              <td style="font-size:14px;color:#777;line-height:1.5"><br />
            </tr>
            <tr><td height="27">&nbsp;</td></tr> 
            <tr>
              <td style="font-size:12px;color:#777;line-height:1.5">본 메일은 발신전용 메일로 회신이 되지 않습니다.<br />
            </tr>
          </tbody>
        </table>
      </td>
    </tr>
    <tr><td height="100">&nbsp;</td></tr>
    </tbody>
  </table>
  <!-- //footer -->
  
</body>
</html>

 

 

그럼 Velocity 설정 및 추가는 끝이 났습니다

이제는 데이터를 저장할 VO를 보며 어떤 데이터를 받을지 지정해봅시다

 

VO가 정의되어있습니다

템플릿을 미리 만들어놓고 적용한다면 true를 할당하여 메일링 값에 적용합니다

그리고 수신자, 발신자, 제목, 내용도 함께 할당되어 

서비스단의 메서드를 호출할 것입니다

 

 

 

public class MailVO {
    private boolean isTemplate = true;  // 템플릿적용 여부
    private String from = "";           // 발신자
    private String to = "";             // 수신자
    private String bcc = "";            // 숨은 참조자
    private String subject = "";        // 제목
    private String contents = "";       // 내용
    private String templateName = "";   // 메일템플릿명
    private String logoImageUrl = "";   // 로고이미지 경로
    private String successYn = "";
    private Map<String, Object> contentsMap; // Mapping Contents
    
    
    ....
}

 

 

아래와 같이 서비스단을 호출하게 됩니다 

로고, 제목, 내용을 정의하여 mailer.sendMail() 호출합니다

 

 

@Override
public void sendMailTemplate(MailVO mailVO) throws Exception {
    try {
        mailVO.setTemplateName(StringUtils.isBlank(mailVO.getTemplateName()) 
                                ? "commonTemplate.vm" 
                                : mailVO.getTemplateName());

        Map<String, Object> contentsMap = new HashMap<String, Object>();
        contentsMap.put("isTemplate", mailVO.isTemplate());
        contentsMap.put("subject", mailVO.getSubject());
        contentsMap.put("logoImageUrl", StringUtils.isBlank(mailVO.getLogoImageUrl()) 
                                        ? "/images/common/h1-logo.svg" 
                                        : mailVO.getLogoImageUrl());
        contentsMap.put("contents", mailVO.getContents());
        if(mailVO.getContentsMap() != null) {
            contentsMap.putAll(mailVO.getContentsMap());
        }
        
        mailVO.setContentsMap(contentsMap);
        mailer.sendMail(mailVO);
    } catch (Exception e) {
        logger.error("[ R E S ]/{} {}", "", StackTraceUtil.getStackTraceString(e));
    }
}

 

 

그리고 mailSender 객체로 MimeMessage의 객체를 만들어서 merge 작업하여

msg.setText()에 값을 정의하여

mailsender.send()로 메일을 발송합니다

 

그렇게 되면 메일 발송은 완료됩니다

 

 

@Autowired
private VelocityEngine velocityEngine;

@Autowired
private JavaMailSender mailSender;

@Autowired
private CommonLogService commonLogService;

public void setVelocityEngine(VelocityEngine velocityEngine) {
    this.velocityEngine = velocityEngine;
}

public void sendMail(MailVO mailVO) {
    MimeMessage msg = mailSender.createMimeMessage();
    mailVO.setSuccessYn("N");
    try {

        String veloTemplate = VelocityEngineUtils.mergeTemplateIntoString(velocityEngine, mailVO.getTemplateName(), "UTF-8", mailVO.getContentsMap());
        msg.setText(veloTemplate, "UTF-8", "html");
        if(!mailVO.getBcc().equals("")){
            msg.setRecipients(Message.RecipientType.BCC, mailVO.getBcc());
        }

        mailSender.send(msg);
        mailVO.setSuccessYn("Y");
    } catch (ParseErrorException | MethodInvocationException  e) {
        logger.error("[ R E S ]/{}{}", StackTraceUtil.getStackTraceString(e));
        return;
    } catch (ResourceNotFoundException e) {
        logger.error("[ R E S ]/{}{}", StackTraceUtil.getStackTraceString(e));
        return;
    } catch (MessagingException e) {
        logger.error("[ R E S ]/{}{}", StackTraceUtil.getStackTraceString(e));
        return;
    } catch (MailException e) {
        logger.error("[ R E S ]/{}{}", StackTraceUtil.getStackTraceString(e));
        return;
    } catch (Exception e) {
        logger.error("[ R E S ]/{}{}", StackTraceUtil.getStackTraceString(e));
        return;
    }

    try {
        commonLogService.insertMailLog(mailVO);
    } catch(Exception ex) {
        ex.printStackTrace();
    }

}

 

 

 

 

오늘은 자바를 활용해서 메일을 발송하는 방법을 알아보았습니다

node와 Java의 방식은 정말 다르기에

두 개 중 무엇이 좋다고 할 수 없지만

 

프로젝트 환경과 규모에 따라 다르게 대응하겠지요

그러니 많은 언어를 알고 있다는 것은 큰 장점일 수 있습니다

하지만 구글링만으로도 구현할 수 있다면

괜찮습니다 우선 빨리 구현하고 나서

난중에 다시 복습하면서 왜 이렇게 되는지 알아보는 게 핵심입니다

 

프로젝트 진행할 때는 결과를 빨리 보여주고

개별적으로 다시 코드 리뷰를 하면서 리팩터링과 모듈화 등을 하면서

자기 실력을 쌓아가는 것이 좋을 것 같습니다

 

그럼 다음 글도 기대해주시고

우리들의 IT 대모험은 끝나지 않았으니 힘내시길 바랍니다

 

 

 

 

728x90
반응형
728x90
반응형

 

오늘은 엑셀 데이터를 업로드해서 자바에서 데이터를 받아서

insert를 하든 아니면 다시 그 데이터를 다시 조합해서 웹에 다시 전달하는 등

핸들링하는 방법을 알아보겠습니다

 

그리고 클래스명을 잘 확인하도록 하시길 바랍니다

 


 

엑셀 데이터 읽어오기

   

@Override
public List<MemberVO> excelReadData(MemberVO memberVO) throws Exception {

    String[] columnNames = new String[20];
	
    // InputStream 클래스에 가지고 있는 파일의 bytes 생성자 매개변수에 할당하게 됩니다
    InputStream inputStream = new ByteArrayInputStream(memberVO.getMbFile()[0].getBytes());

	// inputStream에 엑셀파일이 들어가게 됩니다 이때 WorkbookFactory를 사용하여 파일의 엑셀데이트를 Workbook으로 만들어줍니다 
    org.apache.poi.ss.usermodel.Workbook workbook = WorkbookFactory.create(inputStream);
	
    // 그럼 workbook에 엑셀의 대한 정보값을 읽어올 준비가 됩니다 엑셀에 sheet도 정할수 있습니다
    // getSheetAt(0)의 값으로 엑셀의 첫번째를 읽어온다는 의미가된다
    org.apache.poi.ss.usermodel.Sheet sheet = workbook.getSheetAt(0);
    
    // row별로 이제 iterator() 메서드를 사용하여 행별로 값을 읽어옵니다
    Iterator<Row> rowItr = sheet.iterator(); 

    List<MemberVO> memberList = new ArrayList<MemberVO>();

		// 이제 rowItr를 while로 전체 행의 데이터를 불러옵니다
        while(rowItr.hasNext()) { 
            MemberVO member = new MemberVO();
            Row row = rowItr.next(); 

            if(row.getRowNum() == 0) { 
            	// 첫번째행은 제목이나 컬럼명이 들어있기 때문에 그 컬럼명을 모아서 배열로 넣어 줍니다
                // cellItr에 열에대한 데이터를 0번째 행의 전체 열에 대한 데이터를 가져올 준비를 합니다
                Iterator<org.apache.poi.ss.usermodel.Cell> cellItr = row.cellIterator(); 
                // cellItr에 0번째 행의 열에 대한 데이터를 가져옵니다 그 데이터는 컬럼명이다
                while(cellItr.hasNext()) {
                    org.apache.poi.ss.usermodel.Cell cell = cellItr.next();
                    int index = cell.getColumnIndex();
                    columnNames[index] = cell.getStringCellValue().toString();
                }
                continue; 
            } 
            Iterator<org.apache.poi.ss.usermodel.Cell> cellItr = row.cellIterator(); 

			// 컬럼명의 예상 값이다
            //String[] columnNames = {"우편번호","주소","상세주소","이름","아이디","휴대폰번호","이메일주소","회원가입구분"};
			
            // 이제 인설트할 비즈니스 코드를 우선 조합합니다
            String mbTpcd = "0020";
            String mbAprvKncd = "0010".equals(mbTpcd) ? "0020" : "0010"; 
            member.setMbSttCd("0010".equals(mbTpcd) ? "0030" : "0020");
            member.setMbAprvKncd(mbAprvKncd);
            member.setMbTpcd(mbTpcd);
            member.setSeqNo(memberVO.getSeqNo());
            member.setCtyCd(memberVO.getCtyCd());
            member.setLocCd(memberVO.getLocCd());

            String mbBrn = "";
			
            // 다시 전체 열에 대한 데이터를 가져옵니다 그 데이터를 하나씩 불러와 데이터를 셋팅한다
            while(cellItr.hasNext()) {
            
            	// 한개의 열에 대한 데이터를 가져와 cell에 담습니다
                org.apache.poi.ss.usermodel.Cell cell = cellItr.next();
                
                // 열의 인덱스 넘버를 받아와 처음 0번째 행의 컬럼명을 불러와 case문과 일치할 경우 그 데이터를 삽입합니다
                int index = cell.getColumnIndex();
                if(!"".equals(getValueFromCell(cell))) {
                
                	// columnNames 배열에는 컬럼명을 담아 놓았기때문에
                    switch(columnNames[index].replaceAll(" ","")) {
                       case "우편번호": // 우편번호
                       	   // 숫자를 읽어 올때 소수점으로 들고 올때가 있다 이 경우를 위해 분기작업을 진행한다
                           if(getValueFromCell(cell) instanceof Double) {
                               String stringValue = String.format("%f", getValueFromCell(cell));
                               int indx = stringValue.indexOf(".");
                               String value =  stringValue.substring(0, indx);
                               member.setMbZcd(value);
                               member.setMbStrZcd(value);

                           } else {
                               member.setMbZcd((String)getValueFromCell(cell)); 
                               member.setMbStrZcd((String)getValueFromCell(cell)); 
                           }
                           break; 
                       case "주소": // 주소 
                           member.setMbAddrEnc((String)getValueFromCell(cell)); 
                           member.setMbStrAddr((String)getValueFromCell(cell)); 
                           break; 
                       case "상세주소": // 상세주소
                           member.setMbDtlAddrEnc((String)getValueFromCell(cell)); 
                           member.setMbStrDtlAddr((String)getValueFromCell(cell)); 
                           break; 
                       case "이름": // 이름 
                           member.setMbNm((String)getValueFromCell(cell)); 
                           break; 
                       case "아이디": // 아이디 
                           member.setMbId((String)getValueFromCell(cell)); 
                           break; 
                       case "휴대폰번호": //  
                           member.setMbHpPnEnc(((String) getValueFromCell(cell)).replaceAll("-","")); 
                           member.setMbHpPn(((String) getValueFromCell(cell))); 
                           break; 
                       case "이메일주소": // 이메일주소 
                           member.setMbEmlAddrEnc((String)getValueFromCell(cell)); 
                           break; 
                       case "회원가입구분": // 회원가입구분 
                           String mbJoinDvcd = "";
                           String cellValue = ((String) getValueFromCell(cell)).replaceAll("\\p{Z}", "");
                           if("딜러".equals(cellValue)){
                               mbJoinDvcd = "0010";
                           } else if("대표".equals(cellValue)){
                               mbJoinDvcd = "0020";
                               member.setPeprNm(member.getMbNm());
                           }
                           member.setMbJoinDvcd(mbJoinDvcd);
                           break; 
                    }
                }
            }
            // member에 모든 데이터를 set한 상태이다 그리고 uploadType이 기능은 타입이 두가지이다
            // 데이터를 인설트 하는 것과 엑셀의 데이터를 읽어서 웹화면에 노출해주는 기능 두가지이다
            if("insert".equals(memberVO.getUploadType())){
                if(!mbBrn.equals(member.getMbBrn())){
                    member.setReprHpnoEnc(member.getMbHpPnEnc());
                    member.setEntrFaxnoEnc(member.getMbStrFaxno());
                    member.setBrn(member.getMbBrn());
                    member.setEntrZcd(member.getMbZcd());
                    member.setEntrAddrEnc(member.getMbAddrEnc());
                    member.setEntrDtlAddrEnc(member.getMbDtlAddrEnc());
                }
            }

			// List형에 member를 담아서 한방에 insert를 한다
            memberList.add(member); 

        }
        // while 끝나고 한방에 인설트 한다
        if("insert".equals(memberVO.getUploadType())){
            int resCnt = memberDealerService.insertMbInfoList(memberList);
            if(resCnt <= 0){
                memberList = new ArrayList<MemberVO>();
            }
        }
        
        // uploadType이 insert가 아닐 경우 데이트를 인설트 하지않고 그냥 데이터만 return한다
        return memberList;

}

 

 

반응형

 

 

위의 코드에서 getValueFromCell 메서드선언문을 살펴보자

String, Boolean, Numeric 등의 자료형일 경우 데이터를 return 한다

 

 

  // 셀서식에 맞게 값 읽기 
private static Object getValueFromCell(org.apache.poi.ss.usermodel.Cell cell) { 
    switch(cell.getCellType()) { 
        case STRING: return cell.getStringCellValue(); 
        case BOOLEAN: return cell.getBooleanCellValue(); 
        case NUMERIC: 
            if(DateUtil.isCellDateFormatted(cell)) { 
                return cell.getDateCellValue(); 
             } 
            return cell.getNumericCellValue(); 
        case FORMULA: return cell.getCellFormula(); 
        case BLANK: return "";
        default: 
            return ""; 
    } 
}

 

 

mybatisforeach를 활용해서 여러 개의 데이터를 insert를 합니다

아래와 같이 문법에 맞게 값을 할당하면 간편히 다중 insert가 가능합니다

 

 


다중 insert 하기

 

 

 <insert id="insertMbInfoList" parameterType="java.util.List">
        INSERT  
        INTO MB_MST 
        (
             MB_ID,                        /* 회원 ID                      */                      
            MB_NM,                        /* 회원 명                       */          
            MB_HP_PN_ENC,                 /* 회원 휴대폰 전화번호 암호화    */           
            MB_TPCD,                      /* 회원 유형코드                    */      
            MB_ZCD,                       /* 회원 우편번호                    */      
            MB_ADDR_ENC,                  /* 회원 주소 암호화              */       
            MB_DTL_ADDR_ENC,              /* 회원 상세 주소 암호화           */        
        )
        VALUES
     <foreach collection="list" index="index" item="mbInfo" separator="," >
        (
            #{mbInfo.mbId},
            #{mbInfo.mbNm},
            #{mbInfo.mbPwdEnc},
            XX1.ENC_VARCHAR2_INS(#{mbInfo.mbHpPnEnc},10,'GLVSSL'),
            #{mbInfo.mbTpcd},
            #{mbInfo.mbZcd},
            XX1.ENC_VARCHAR2_INS(#{mbInfo.mbAddrEnc},10,'GLVSSL'),
            XX1.ENC_VARCHAR2_INS(#{mbInfo.mbDtlAddrEnc},10,'GLVSSL'),
        )
     </foreach>
</insert>

 

 


 

이렇게 엑셀 데이터를 읽어와서 그 데이터를 조합하여 다중 insert를 만들어 보았습니다

이것을 활용해서 조합한 데이터를 인설트를 하지 않고 return 해서 웹 화면에 노출하는 것도 가능합니다

어드민 페이지를 만들다 보면 업무에 필요한 작업들을 코딩해야 하는 경우가 있는데

엑셀 작업을 많이 하는 작업자들의 요청은 피할 수 없는 것 같습니다

 

그럼 수고하시고!!

언제나 조금씩 조금씩 한 걸음씩 나갑시다

우리 대모험은 끝나지 않았으니까요!!

 

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
반응형

삼항연산자 (항이 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
반응형

생성자

기본 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
반응형

+ Recent posts

Powered by Tistory, Designed by wallel