190422_Day11 복습, String, Vector

복습

  • NullPointException 발생원인

    • null이란 메모리 할당 되지 않은 것
  • String

    • substring(int 시작인덱스, int 끝인덱스)
    • 단, 시작인덱스 포함, 끝인덱스 미포함
  • str.charAt(int 인덱스)

    • 인덱스에 해당하는 한 문자 리턴
  • 컴퓨터는 ‘a’문자를 내부에서 아스키코드 97로 인식

  • 문자열 공백 제거 str.trim();
  • 문자열 내용 비교 비교할대상.equals(비교할대상)
    • 소문자 대문자는 다르게 비교
    • 대소문자 상관없이 하고 싶다면 toUpperCase() 혹은 toLowerCase()로

- 물론 .equalsIgnoreCase() 가 있다 (자바는, SQL등에선 위의 방식)

  • 미션풀이

    • “`java
      package j0422;

    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;

    public class NameMenuTest
    {
    public static void main(String[] args) throws IOException
    {
    // 반복되는 메뉴출력( 화면 뷰 처리 )
    // 번호 입력을 위한 read() 또는 readLine() 메인에서 사용
    // 이름 입력을 위한 readLine() 메인에서 사용
    // 그러니까 통일성 위해 그냥 readline()쓰는게 좋겠넵…
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    NameMenu menu = new NameMenu();

        int no = 0;
        int cnt = 0;
    
    
        do
        {
            System.out.println("<이름메뉴>");
            System.out.println("1.추가  2.검색  3.수정  4.삭제  5.종료");
            System.out.print("번호를 입력해 주세요~ =>>");          
            String noStr = in.readLine();//문자열검사, 숫자로 구성되어있는지!
    
            boolean flag = menu.checkNum(noStr);
            if( !flag ) //( flag == false )
            {
                System.out.println("번호만 입력하세요");
                continue; // 제어문 
                //break : 스위치 혹은 반복문 종료,do while문 벗어남, 
                //continue : 반복문을 계속 진행, for문(증감자를 거친 조건식으로 이동), do-while문(조건식으로), while문(조건식으로) 
                //return : 메소드 프로그램 종료
            }
    
    
            no = Integer.parseInt( noStr ); // no에는 "1" "2" "3" 과 같은 문자열이 들어온다~!
    
            switch(no)
            {
            case 1 : { // 밑에 또 case3 에name이 등장하기 때문에(다시 밑에도 이름 바꿈) 영역괄호로 묶어버린다~!
                        if(cnt == 5)
                        {
                            System.out.println(" 더 이상 입력할 수 없습니다 \r\n " + " 한 개 이상의 이름을 먼저 삭제 한 후 입력하세요 ");
                            break; //switch 블록 벗어나기
                        }
                        System.out.print("이름 입력 : ");
                        String name = in.readLine();
    
                        if(menu.existName(name) ) // 중복된 이름을 발견했다면
                        {
                            System.out.println("이미 입력된 이름입니다!!");
                            break;
                        }
                        menu.add(name);
                        cnt++; // 유효성 검사 valid Check
    
                        //메소드호출 : 메소드명(데이터)
                        }
                        break;
    
            case 2 : 
                        menu.search();
                break;
    
            case 3 : 
                        System.out.print("변경하고자 하는 기존 이름 입력 : ");
                        String oldName = in.readLine();
    
                        if ( !menu.existName( oldName ) )
                        {
                            //수정할 이름이 존재하지 않는다면
                            System.out.println("존재하지 않는 이름입니다.");
                            break;
                        }
    
                        System.out.print("새로 수정 하는 이름 입력 : ");
                        String newName = in.readLine();
    
                        menu.update(oldName, newName);
                break;
    
            case 4 : 
                        System.out.print("삭제 할 이름 입력 : ");
                        String delName = in.readLine();
    
                        if ( !menu.existName( delName ) )
                        {
                            //수정할 이름이 존재하지 않는다면
                            System.out.println("존재하지 않는 이름입니다.");
                            break;
                        }
    
                        menu.delete(delName);
            }//switch
        System.out.println();
        }
        while( no != 5  ); //번호에 1,2,3,4,5 입력했다면! , String클래스이기 때문에 == 으로 하면 값이 아닌 주소를 찾는다., equals로! 
    
        System.out.println("E N D");
        //논리데이터 앞에는 !(not) 연산자를 붙일 수 있다~!
        //<!not연산자>
    
    }//main
    

    }

    /===

    package j0422;

    public class NameMenu
    {
    String names[]; // null

    public NameMenu()
    {
        names = new String[5];
    }
    
    //배열에 이름 저장
    public void add(String name)
    {
        //빈방찾기~!
        for( int i = 0 ; i < names.length; i++ )
        {
            if( names[i] == null ) //빈방을 찾았다면~!
            {
                names[i] = name;
                break;
            }
        }
    }
    
    //배열내의 이름들 조회
    public void search()
    {
        System.out.println("#이름목록");
        for( int i = 0; i<names.length; i++)
        {
            if(names[i] != null) 
                {
                System.out.println(names[i]);
                }
        }
    }
    
    //배열에 저장된 이름을 변경
    public void update(String oldName, String newName)
    {
        //oldName과 일치하는 이름을 배열에서 찾기
        for( int i = 0; i < names.length; i++) //배열 전체 인덱스
        {
    

    // if( names[i].equals( oldName ) )
    // {
    /*
    * NullpointerException 방지
    * 1. if(oldName.equals(names[i])) : oldName에 null값 절대 전달되지 않음
    * 2. if(names[i] != null && names[i].equals(oldName))
    * : names[i]번지의 값이 null이 아닐 때 equals()메소드 호출!
    */
    if(names[i] != null && names[i].equals(oldName))
    {
    names[i] = newName;
    break;
    }
    }

    }//update
    
    //배열에 저장된 이름을 삭제
    public void delete(String delName)
    {
        // 배열에 저장된 데이터 삭제표현 : 배열명[번지] = null;
        for( int i = 0; i < names.length; i++ )// 배열에서 삭제할 이름 찾기
        {
            if(names[i] != null)
            {
                if(names[i].equals(delName))
                {
                    names[i] = null;
                    break;
                }
            }
    
        }
    
    }//delete
    //추가 메소드 정의
    //문자열 데이터가 숫자 조합인지 체크
    public boolean checkNum( String str )
    {
        char ch;
        for( int i = 0; i < str.length(); i++ )
        {
            ch = str.charAt(i);
    
            if( ch < '0' || ch > '9' ) //숫자로 구성된 문자가 아니라면!
            {
                System.out.println("숫자만 입력하세요");
                return false;
            }
        }
        return true; // 전체 문자가 숫자로 구성되었다면
    }
    
    public boolean existName(String name)//중복(존재하는) 이름 체크
    {
        for(int i = 0; i < names.length; i++) //배열 인덱스
        {
            //null.equals("길동"); // NullPointerException발생
            //"길동".equals(null); //NullPointerException 발생 하지 않음
            if( name.equals(names[i] ) )
            {
                return true;
            }
        }
        return false;
    }//existName
    

    }
    “`


str.getBytes() str.toCharArray()
to <======= from =======>
byte []b = {97,98,99} String str = “abc”;
from =======> to <=======
new String(b); new String(ch);
package j0422;

public class StringTest2 
{
    public static void main(String[] args) 
    {
        String str = "abc";
        System.out.println("STR = " + str);

        byte[]b = str.getBytes();
        for (int i = 0; i < b.length; i++) 
        {
            System.out.println("b[" + i + "] = " + b[i] );
        }

        String str2 = new String(b);
        System.out.println("STR2 = " + str);

    }
}
package j0422;

public class StringTest 
{

    public static void main(String[] args) 
    {
        String str = "JavaProgramming";

        //특정 문자열로 시작하는 지 체크 boolean str.startsWith(String prefix)
        System.out.println("str은 'Jav'로 시작하는가?\n" + str.startsWith("Jav") + "\n");      
        System.out.println("str은 'Jav'로 시작하는가?\n" + str.startsWith("av") + "\n");       

        //특정 문자열로 끝나는지 체크 boolean str.endsWith(String suffix)
        System.out.println("str은 \"ing\"로 끝나는가? \n" + str.endsWith("ing") + "\n");

        //str.contains(CharSequence s)
        System.out.println("str이 \"pro\"를 포함하는가? \n" + str.contains("Pro") + "\n");

        String tel = "010-1234-5678";
        //tel 값은 02-123-4567 또는 053-123-5656 이렇게도 나올 수 있다.
        String teltel = "02-112-1119"; // 번호가 위의 식이 아니라면?!

        //문제 String tel1, tel2, tel3 변수를 선언하고 각각 "010", "1234", "5678"을 저장 후 
        //화면에 각 변수의 값을 출력하시오.
        //힌트 substring()메소드와 indexOf() 메소드를 사용

//      String tel1;
//      String tel2;
//      String tel3;
//      
////        
//      tel1 = tel.substring(0, 3);
//      System.out.println(tel1);
//      tel2 = tel.substring(4, 8);
//      System.out.println(tel2);
//      tel3 = tel.substring(9, 13);
//      System.out.println(tel3);

        int idx1 = teltel.indexOf("-"); //첫번째 "-"에 대한 인덱스
        int idx2 =teltel.indexOf("-", idx1 + 1); //두번째 "-"에 대한 인덱스
        System.out.println("idx1 = " + idx1 + "\nidx2 = " + idx2);
        idx2 = teltel.lastIndexOf('-');
        System.out.println("last index idx2 = " + idx2);

        String tel1 = teltel.substring(0, idx1);
        String tel2 = teltel.substring(idx1 + 1, idx2);
        String tel3 = teltel.substring(idx2 + 1);
        System.out.println("tel1 :" + tel1 + "\ntel2 :" + tel2 + "\ntel3 :" + tel3);
    }

}

/*
str은 'Jav'로 시작하는가?
true

str은 'Jav'로 시작하는가?
false

str은 "ing"로 끝나는가? 
true

str이 "pro"를 포함하는가? 
true

idx1 = 2
idx2 = 6
last index idx2 = 6
tel1 :02
tel2 :112
tel3 :1119
*/
package j0422;

import java.util.StringTokenizer;

public class StringTokenizerTest 
{

    public static void main(String[] args) 
    {
        //StringTokenizer : 문자열 데이터를 특정 구분자(delimiter)를 통해 분리해주는 클래스

        //StringTokenizer(String str, String delim) 생성자
        //str ==> 기준 문자열 (전체문자열), delim ==> 구분자
        //token(토큰) : 분리된 각각의 데이터
        String tel = "010-1234-5678";
        StringTokenizer st = new StringTokenizer(tel, "-");
        //st = ["010" , "1234", "5678"];

//      //토큰 데이터 꺼내오기 : String st.nextToken()
//      System.out.println(st.nextToken());
//      System.out.println(st.nextToken());
//      System.out.println(st.hasMoreTokens()); //st에 토큰 데이터 가지고 있으면 true
//      System.out.println(st.nextToken());
//      
//      
//      System.out.println(st.hasMoreTokens()); // st에 토큰 데이터 없다면 false
//      //System.out.println(st.nextToken());// 가져올 토근 데이터 초과하면 에러

        while(st.hasMoreElements())
        {
            System.out.println(st.nextToken());
        }
        System.out.println("=================");

        tel = "010-1234-5678";
        //String[] tel.split(String regex); //특정문자(매개변수)를 통해 데이터를 분리 - 결과는 문자열 배열
        //regex 는 정규식이라는 뜻
        //String[] tel.
        //split() 메소드는 빈문자열 ""도 저장해서 사용.
        String tels[] = tel.split("-"); // tels = {"010", "1234", "5678"};
        for (int i = 0; i < tels.length; i++) 
        {
            System.out.println("tels[" + i + "] = " + tels[i]);
        }
    }

}
package j0422;

public class MatchesTest 
{
    //String클래스 ==> boolean str.matches(String regex);
    //regex ==> regular expression( 정규표현식, 정규식 )
    //regex를 통해 전달되는 패턴에 str이 부합(match)된다면 true를 리턴.

    // 출현(발생)횟수 관련된 부호 : ?(0,1) , *(0~무한대) , +(1~무한대) 
    // 부호 없음 =>> 1번 출현
    // 
    public static void main(String[] args) 
    {
        String str = "";//false
        String str1 = "a";
        String str2 = "aa";
        String str3 = "";       
        String str4 = "abc";


                            //matches(패턴문자열)
        System.out.println("부호 없음\t:\t" + str.matches("[a]")); // a문자 한번 들어오기를 원한다!
        System.out.println("?부호\t:\t" + str1.matches("[a]?")); // a문자 : 0,1
        System.out.println("*부호\t:\t" + str2.matches("[a]*")); // a문자 : 0~무한대
        System.out.println("+부호\t:\t" + str3.matches("[a]+")); // a문자 : 1~무한대
        System.out.println("=================");
        System.out.println(str4.matches("[abc]")); //a또는 b또는 c문자 중 하나가 오직 1번        
        System.out.println(str4.matches("[abc]+")); //a또는 b또는 c문자 중 하나가 오직 1번

        String name = "jinju";
        //name변수에 대한 영문자 체크 !
        System.out.println("name변수의 이름체크(영어 소문자) : " + 
                name.matches("[qwertyuiopasdfghjklzxcvbnm]+"));
        //표현식 사용시 대괄호[]안에 '-'부호는 범위를 표현
        System.out.println(name.matches("[a-zA-Z]+")); //영문자 상관 없이 다 

        String su = "4567898765456";
        System.out.println("숫자체크 : " + su.matches("[0-9]+")); // 


        /*
         * 이제 이거 쓰면
         * 입력 받을 때 숫자만 입력하길 원한다면
         * if(!noStr.matches("[0-9]+"))
         * {
         *  //조건문~!
         * }
         * 이렇게 편하게 쓸 수 있다.
         */

        String hangul = "진주는자면서뿡뿡을한다그것도두번이나";
        //hangul 변수에 대한 한글 체크
        System.out.println("한글 체크 : " + hangul.matches("[ㄱ-힣]+"));

        String id = "aasdfgh123";
        //아이디는 8 ~ 12자리, 영문자와 숫자 조합


        String idPattern = "[a-zA-Z0-9]{8,12}"; //문자열 길이 = 최소 8자리에서 12자리
        //{8,12} 8이상 12이하,  {8,} 최소 8이상, {8} 무조건 8글자

        System.out.println("아이디체크 : " + id.matches(idPattern));

        String juminBunho = "931025-2022334";
        String juminPattern = "[\\d]{6}-[\\d]{7}";
        System.out.println("주민번호체크 : " + juminBunho.matches(juminPattern));
    }
}
package j0422;

public class StringConvertTest 
{

    public void convert1()
    {
        String s1 = "우리나라";
        String s2 = "대한민국만세";
        s1 = s1+s2;
        /*
         * String 클래스 : 고정(길이)문자열!
         * 1. String클래스 객체 생성
         * 2. 문자열 변환을 위해서 임시로 StringBuffer 클래스 객체 생성
         * 3. 내부에서 append() 메소드 호출
         * 4. StringBuffer객체를 다시 String객체로 변환
         * 5. 임시생성된 StringBuffer객체를 소멸
         * 이럴경우 가급적 s3이라는 변수 만들어서 넣는게 좋다!
         */
        System.out.println(s1);
    }

    public void convert2()
    {
        StringBuffer s1 = new StringBuffer("우리나라");
        s1.append("대한민국만세");
        /*
         * StringBuffer 클래스 : 가변(길이)문자열!
         * 1. StringBuffer클래스 객체 생성
         * 2. append() 메소드 실행
         */
        System.out.println(s1);
    }

    public void kan()
    {
        System.out.println("================");
    }
    public static void main(String[] args) 
    {
        StringConvertTest sct = new StringConvertTest();
        sct.convert1();
        sct.kan();
        sct.convert2();
    }

}

  • <배열 사용이유>

    • 여러개의 데이터를 한 변수명으로 정의 =>>(인덱스) 관리가 편해짐
    • 제약 : 동일한 자료형, 고정된(수) 데이터만 입력!
  • <벡터> : 데이터들을 담는 바구니

궁금상자 
    - matches에서 띄어쓰기까지 포함된거 검색하려면 띄어쓰기 제거 후?!

    * 바보야 String 비교는 .equals야....

    - break, continue, return이 헷갈려

190519_Day10 복습, 미션풀이, not연산자, NullPointException, String

복습

  • 속성변수와 참조변수의 차이점

    • 속성변수

    • 데이터 값(value)를 담는 변수

    • 자료형 변수명;

    • 사용

      no = 300;
      System.out.println( no );
      System.out.println( no + 200 );
      System.out.println( no. ); //얘는 에러
    • 참조변수

    • 데이터 주소( addr )를 담는 변수

    • 자료형 변수명;

      • String Integer A NameMenu Person 등…
      A a; // a에 주소를 담겠음
      a = new A();
      
      System.out.println( a.su );
      System.out.println( a.hello() );
    • 정수 100 =>> 데이터 저장

    • 저장되는곳에 주목

    • 변수 : int su = 100; System.out.println( su );

    • 배열 : int su[] = { 100 }; int su[] = new int[3]; su[0] = 100;

    • 클래스

      class A
      {
        int su = 100;
      }
      A a = new A();
      
      출력은 System.out.println( a.su );
  • 속성변수와 참조변수 차이점 2

    • 값복사와 주소 복사
    int su1;
    int su2;
    
    su1 = 100;
    su2 = su1;
    //su1이 가지고 있는 데이터를 su2에 전달( 그릇 말고 내용만 )
    su1 = su1 * 200;
    // su1 : 20000 su2 : 100 아! 100이란 값은 두개가 있었구나, 주소가 다르구나
    A a1;
    A a2;
        a1 = new A(); 203호 메모리 가르킴
        a1.su = 100; //메모리 값 100으로 바뀜
        //a1.su 출력  : 100
        a2 = a1; // a2도 203호(가칭) 메모리를 가르킴

미션풀이

// 로또 중복 없이 6개 출력
import java.util.Random;

public class LottoTest 
{
    public static void main(String[] args) 
    {
        int lotto [ ] = new int [ 6 ];
        Random r = new Random();

        lotto[ 0 ] = r.nextInt( 6 ) + 1; // 0~44 까지라 1더하기!
        do 
        {
            lotto[ 1 ] = r.nextInt( 6 ) + 1; 
        }while(lotto[1]==lotto[0]);

        do
        {
            lotto[ 2 ] = r.nextInt( 6 ) + 1;
        }while( lotto[2] == lotto[1] ||
                lotto[2] == lotto[0]);

        do
        {
            lotto[ 3 ] = r.nextInt( 6 ) + 1;
        }while( lotto[3] == lotto[1] || 
                lotto[3] == lotto[0] || 
                lotto[3] == lotto[2]);

        do
        {
            lotto[ 4 ] = r.nextInt( 6 ) + 1;
        }while(lotto[4] == lotto[1] || 
                lotto[4] == lotto[0] || 
                lotto[4] == lotto[2] ||
                lotto[4] == lotto[3]);
        do
        {
            lotto[ 5 ] = r.nextInt( 6 ) + 1;
        }while( lotto[5] == lotto[1] || 
                lotto[5] == lotto[0] || 
                lotto[5] == lotto[2] ||
                lotto[5] == lotto[3] ||
                lotto[5] == lotto[4]);

        for( int i = 0; i < lotto.length; i++ )
        {
            System.out.println("lotto[" + i + "] = " + lotto[i]);
        }
    }
}
//로또
import java.util.Arrays;
import java.util.Random;

public class LottoTest2 
{
    int lotto[]; // null
    Random r; // null

    public LottoTest2() 
    {
        lotto = new int[6];
        r = new Random();
    }//생성자

    public void printNum() 
    {
        for (int i = 0; i < lotto.length; i++) 
        {
            System.out.print( lotto[ i ] + "\t");//6번
            if( i < 5 )System.out.print("\t");//5번
        }
    }

    public void generateNum()
    {
        for (int i = 0; i < lotto.length; i++ )
        {
            lotto[ i ] = r.nextInt(45) + 1; // 1에서 45까지 난수 발생!
            //세번째 데이터를 입력 i =>> 2

//          boolean flag = duplicateNum(i);
//          if(flag)
//          {
//              i--;
//          } 이를 줄여서 아래에
            if(duplicateNum(i))i--;

        }//for문
        Arrays.sort(lotto);
    } //generateNum

    //중복숫자 체크 기능, 중복 숫자 발견시 true 리턴~!
    public boolean duplicateNum(int idx)
    {
        for( int i = idx - 1; i >= 0; i--) //1~0 , 
        {
            if( lotto[idx] == lotto[i] )
            {
                return true;
            }
        }//for
        return false; // for문을 다 실행한 다음에 내려옴. if를 한번도 만족하지 않았다. 중복된 데이터를 찾기 못했다.
    }//duplicateNum

    public static void main(String[] args) //생성자 : 초기화 메소드, 선행작업
    {
        LottoTest2 lotto = new LottoTest2(); // 생성자 먼저 호출

        for(int i = 1; i<6; i++)
        {
            System.out.print(i + "회 : ");

            lotto.generateNum();
            lotto.printNum();
            System.out.println(" ");
        }

    }
}
//다른 로또 방법도 있다 45개 짜리 배열 만들고 랜덤으로 섞고 0번부터 5번까지 꺼내오기
import java.util.Arrays;
import java.util.Random;

public class LottoTest3 
{
    public static void main(String[] args) 
    {
        int[] lotto = new int [45]; // 인덱스 0~44
        Random r = new Random();

        //첫번째 방 ~ 마지막 방 숫자 입력 : 1~45
        for (int i = 0; i < lotto.length; i ++)
        {
            lotto[i] = i + 1;
        }

        //숫자를 섞어주기
        int temp;
        for(int i = 0; i<1000; i++) 
        {
            int randomIdx = r.nextInt(44) + 1; // 밑에서 랜덤이 두번 쓰이는데 같은곳을 지정하기 위해 미리 변수 선언
            temp = lotto[0];
            lotto[0] = lotto[randomIdx]; //0부터 44번지 + 1 중, 한개!
            lotto[randomIdx] = temp;        
        }


        for ( int i = 0; i < 6; i ++) // 배열 맨 앞의 6개 숫자를 출력
        {   Arrays.sort(lotto, 0, 6);
            System.out.println( "lotto[" + i + "] = " + lotto[ i ] );
        }
    }
}

package nameManuMission;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class NameMenuTest 
{
    public static void main(String[] args) throws IOException 
    {
        // 반복되는 메뉴출력( 화면 뷰 처리 )
        // 번호 입력을 위한 read() 또는 readLine() 메인에서 사용
        // 이름 입력을 위한 readLine() 메인에서 사용
        // 그러니까 통일성 위해 그냥 readline()쓰는게 좋겠넵...
        NameMenu menu = new NameMenu();
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String no;
        do
        {
            System.out.println("<이름메뉴>");
            System.out.println("1.추가  2.검색  3.수정  4.삭제  5.종료");
            System.out.print("번호를 입력해 주세요~ =>>");          
            no = in.readLine(); // no에는 "1" "2" "3" 과 같은 문자열이 들어온다~!

            switch(no)
            {
            case "1" : { // 밑에 또 case3 에name이 등장하기 때문에(다시 밑에도 이름 바꿈) 영역괄호로 묶어버린다~!
                        System.out.print("이름 입력 : ");
                        String name = in.readLine();
                        menu.add(name);
                        //메소드호출 : 메소드명(데이터)
                        System.out.println( name );
                        }
                        break;

            case "2" : 
                        menu.search();
                break;

            case "3" : 
                        System.out.print("변경하고자 하는 기존 이름 입력 : ");
                        String oldName = in.readLine();

                        System.out.print("새로 수정 하는 이름 입력 : ");
                        String newName = in.readLine();

                        menu.update(oldName, newName);
                break;

            case "4" : 
                        System.out.print("삭제 할 이름 입력 : ");
                        String delName = in.readLine();

                        menu.delete(delName);
            }//switch
        }
        while( !no.equals( "5" ) ); //번호에 1,2,3,4,5 입력했다면! , String클래스이기 때문에 == 으로 하면 값이 아닌 주소를 찾는다., equals로! 

        System.out.println("E N D");
        //논리데이터 앞에는 !(not) 연산자를 붙일 수 있다~!
        //<!not연산자>

    }//main
}
/===
package nameManuMission;

public class NameMenu 
{
    String names[]; // null

    public NameMenu()
    {
        names = new String[5];
    }

    //배열에 이름 저장
    public void add(String name)
    {
        //빈방찾기~!
        for( int i = 0 ; i < names.length; i++ )
        {
            if( names[i] == null ) //빈방을 찾았다면~!
            {
                names[i] = name;
                break;
            }
        }
    }

    //배열내의 이름들 조회
    public void search()
    {
        System.out.println("#이름목록");
        for( int i = 0; i<names.length; i++)
        {
            if(names[i] != null) 
                {
                System.out.println(names[i]);
                }
        }
    }

    //배열에 저장된 이름을 변경
    public void update(String oldName, String newName)
    {
        //oldName과 일치하는 이름을 배열에서 찾기
        for( int i = 0; i < names.length; i++) //배열 전체 인덱스
        {
//          if( names[i].equals( oldName ) )
//          {
                /*
                 * NullpointerException 방지
                 * 1. if(oldName.equals(names[i])) : oldName에 null값 절대 전달되지 않음
                 * 2. if(names[i] != null && names[i].equals(oldName))
                 *      : names[i]번지의 값이 null이 아닐 때 equals()메소드 호출!
                 */
                if(names[i] != null && names[i].equals(oldName))
                {
                names[i] = newName;
                break;
                }
        }


    }//update

    //배열에 저장된 이름을 삭제
    public void delete(String delName)
    {
        // 배열에 저장된 데이터 삭제표현 : 배열명[번지] = null;
        for( int i = 0; i < names.length; i++ )// 배열에서 삭제할 이름 찾기
        {
            if(names[i] != null)
            {
                if(names[i].equals(delName))
                {
                    names[i] = null;
                    break;
                }
            }

        }

    }//delete

}

NullPointerException 발생원인!

  • null이란 메모리 할당되지 않은 것을 의미한다.

  • 메모리 할당을 하지 않은 상태에서 필드 또는 메소드를 참조 했을 때 발생하는 에러!

  • null.필드명 null.메소드명(); 시 발생!

    class A
    {
      void hello()
      {
    
      }
    }
    
    class test
    {
      A a; //null
    
      void print()
      {
          a.hello(); //null.hello()한것과 같다, nullpoint에러
          a mew A(); // a에는 메모리 주소정보가 저장
          a.hello(); // 싫
      }
    
      public static void main(String []args)
      {
          Test t = new Test();
          t.print();
      }
    }
    aa.bb(dd); 
    =>> ㅁㅁ\\\\\\\\NullPointrExeption 을 발생 킬 수 있는 요소, 는? aa 90%, bb 1-%
    
    
    null.bb(dd); =>> 예외 발생
    aa.bb(null);  예회 발생하지 않음
    
    A aa;
    class A
    {
    
    }

String

package j0419;

public class StringTest 
{
    public static void main(String[] args) 
    {
//      String 자바 = "abc";
//      String str = 자바;

//      String 문자열 : 문자들의 나열!
        String str = "Java Programming";
        //인덱스 ```````012345678901234
        //총 문자 15개가 들어갔다. str은 참조변수, 클래스잖아~! 속성은 뒤에 . 안됨, 참조변수는 . 가능~!

        System.out.println(" 바꾼값 = " + str.replace("Java", "자바") );

        //str에서 부분 문자열 "Programming"을 구하시오.
        System.out.println(str.substring( str.indexOf('P') ));

        //str.substring(4);
        System.out.println("str.indexOf( \"am\" )" +str.indexOf( "am" ));

        //마지막 'a' 문자의 인덱스를 구하시오
        System.out.println("str.lastIndexOf( \'am\' )" +str.lastIndexOf( 'a' ));

        //문자열 치환(대체)
        System.out.println("str.replace('a', 'o') = " + str.replace('a', 'o'));

        //"JovoProgromming"이 str에 저장되길 원한다면
        str = str.replace('a', 'o');
        System.out.println("STR = " + str);


//      str.~ String클래스에 있는

        //문자열 길이( 문자 갯수 )
        System.out.println("str문자열길이( 문갯수 ) : " + str.length());

        //부분문자열 =>> "Pro" 문자열 얻기
        //substring( int beginIndex, int endIndex)
        System.out.println( "str.substring(4, 6) = " + str.substring( 4, 6 ) );//여기서 4,6은 파라미터
        //beginIndex : 시작인덱스( 포함 )
        //beginIndex :  끝 인덱스( 미포함 )
        //=>> str.substring( 4, 7 ) 은  인덱스4 ~ 인덱스6 까지

        //부분문자열 =>> "Programming" 문자열 얻기
        System.out.println(str.substring( 5, 8 ));
        System.out.println(str.substring( 5 )); // 시작인덱스부터 끝까지

        //특정인덱스의 문자 얻어오기 : char str.charAt(int index)
        System.out.println( "str.charAt(4) = " + str.charAt( 5 ) );

        //특정 문자의 인덱스 얻어오기
//      int str.indexOf(int ch);
        int index = str.indexOf(97); //97은 소문자 a
        int index2 = str.indexOf('a'); //97은 소문자 a
        System.out.println("index = " + index2);
        System.out.println("index = " + index);

        System.out.println( (char)97 );

        //replace(CharSequence target, CharSequence replacement)
        //CharSequence 부모 - String 자식
        str = "Java Programming";
        //문자열에 공백 추가~!
            str = " " + str + " "; //str 앞에 공백 2개 , 뒤에 공백 2개 추가 
            System.out.println( "공백 추가 후 STR = " + str );
            System.out.println( "STR문자열 길이 = " + str.length( ) );

            //문자열 제거! ( 문자열 앞 뒤 연속된 공백제거 ) 
            str = str.trim();
            System.out.println("공백 제거 후 STR = " + str );
            System.out.println( "STR문자열 길이 = " + str.length( ) );


    }
}
package j0419;

public class StringTest2 
{
    public static void main(String[] args) {

        String s1 = "java";
        String s2 = "JaVA";

        //문자열 s1, s2를 비교( 문자열 내용비교 ) 하시오. ★★★★★
        System.out.println("s1.equals(s2) = " + s1.contentEquals(s2)); // false : 대소문자 비교하기에~!
        //"java".equals( "JaVA" ) 사용가능

        //대소문자 구분없이 s1과 s2철자를 비교하시오
        System.out.println( "대문자변환" + s1.toUpperCase() );
        System.out.println( "소문자변환" + s2.toLowerCase() );

        System.out.println("전체 소문자(s1 s2) 변경 후 비교 = " + s1.toLowerCase().equals(s2.toLowerCase()));

        //문제) str문자열 안의 있는 숫자의 갯수를 화면에 출력하시오.
        //아스키 코드값  = 0은 48, a는 97 A는 65
        String str = "Java3Pro7gra9mm0ing"; // 화면에 '4' 출력


        int count = 0;
        System.out.println("str문자열길이( 문갯수 ) : " + str.length());
        for( int i = 0; i < str.length(); i++ )
        {
            char ch = str.charAt(i);
            if( ch > 47 && ch <60 ) //혹은 '0' '9'랑 비교해도 가능하다.
            {
                //숫자로 구성된 문자라면 
                count++;
                System.out.print(ch);
                if(i < str.length())
                System.out.print(", ");
            }
        }
        System.out.println("갯수 : " + count);

    }
}
궁금상자
    - 갑자기 든 생각인데 메모리 주소 출력 받은걸로 입력도 가능할까?

    - 하나의 for문안에 변수 2개

    - 로또 하 면서 봤는데 
    for( int i = dex - 1; i > -1; i--)는 되고 for( int i = dex - 1; i == 0; i--)은 안되네?
        바보야 i == 0... 조건이 아니야...
    - 왜 0부터 5까지 배열을 Arrays.sort(lotto, 0, 6); 하면 되고 Arrays.sort(lotto, 0, 5); 하면 안되지?
        선생님이 알려주심 이상 미만의 범위라서 그럼..~!
    - String과 StringBuffer의 차이
        고정일땐 String 가변일 땐 StringBuffer???

190118_Day9 복습, 삼항연산자, 클래스 객체 비교, 오토박싱 언박싱


//3조 발표 후 ~! 스위치문의 간결함!
package SwitchTest;

public class SwitchTest 
{
    public static void main(String[] args)
    {
        final int SEARCH = 1;
        final int INCREMENT = 2;
        final int DECREMENT = 3;
        final int EXIT = 4; // 상수형 final 변수라 대문자 변수명

        int su = 1;

        switch (su) {
            case SEARCH : System.out.println(" 검색 "); break; // case 뒤에 변수는 못넣고 상수만 넣을 수 있다.
            case INCREMENT : System.out.println(" 증가 "); break; 
            case DECREMENT : System.out.println(" 감소 "); break;
            case EXIT : System.out.println(" 종료 "); break;
        default:
            break;
        }
    } //main
}

복습

  • 배열

    • 한개의 변수명에 여러 개의 데이터를 저장하기 위해! 단, 데이터들은 같은 자료형

    • 통신할때, 데이터 관리가 매우 편해진다! 변수명 하나만 건내면 안에 내용 열개 백개를 보낼 수 있음

    • 여러 개의 데이터를 변수명 한 개를 사용해 전달, 배열 인덱스 사용 =>> for문 사용 : 전체 데이터를 검색!

    • 형식

      1. 배열선언과 초기화! =>> 프로그램내에 확정된 데이터가 있을 때 사용

        • 자료형 [] 배열명 = {value_list};
      //자료형 [] 배열명 = { 데이터1, 데이터2, 데이터3 };
      int [] nums = { 100, 200, 300 };
      // ㅁㅁㅁ 방을 만들고 그 안에 100, 200, 300을 넣어줌
      // 번지는 nums[0] nums[1] nums[2]
      1. 배열 객체 생성 =>> 프로그램 생성 중 데이터 입력

        • 자료형 [] 배열명 = new 자료형 [배열 크기] //형식은 꼭 외워줘!
      int [] nums = new int [3];
      nums[0] = 10;
      nums[1] = 20;
      nums[2] = 30;
      1. 2차원 배열 객체 생성

        • 자료형 [] [] 배열명 = new 자려형 [행크기] [열크기];
      int [][] nums = new int [3][2]; //3*2 : 6개의 정수데이터 입력 준비
      num[0][0] = 10;
      num[0][1] = 20;
      
      num[1][0] = 30;
      num[1][1] = 40;
      
      num[2][0] = 50;
      num[2][1] = 60;
    10 20
    30 40
    50 60

    java
    int [][] nums = new int [3][]; //가변길이열
    //ㅁㅁ nums[0] = new int[2];
    //ㅁㅁㅁ nums[1] = new int[3];
    //ㅁ num[2] = new int[1];

  • newA();

    • 100 + 200
    • new A().hello();
  • A a = new A();
    • 변수 su + 200
    • a.hello();
  • A [] aa = new A[5];
    • 배열 su[0] + 200;
    • aa[0] = a;
    • aa[0].hello();

어제 미션

//mission 내가 푼것
package mission;

public class Mission0417
{
    public static void main(String[] args)
    {
        int su[] = { 1, 2, 3, 4, 5};
        // 배열 크기 (su.length) =>> 5

        System.out.println("================<1번>===============");
        for( int i = 0; i < su.length; i++ )
        {
            System.out.print(su[i] + "\t");
        }
        System.out.println();
        System.out.println("================<2번>===============");
        for( int i = su.length - 1 ; i >= 0; i-- )
        {
            System.out.print(su[i] + "\t");
        }
        System.out.println();
        System.out.println("================<3번>===============");

        int su2[][] = { { 1 }, { 1, 2 }, { 1, 2, 3 } };
        for( int i = 0; i < su2.length; i++)
        {
            for( int j = 0; j <= su2[i].length - 1; j++)
            {
                System.out.println("su[ " + i + " ] [ " + j + " ] = " + su2[i][j]);
            }
        }

        System.out.println();
        System.out.println("================<4번>===============");

        int su3[] = {5, 5, 5, 5, 5}; 
        for ( int i = 0; i < su.length; i ++)
        {
            su3[i] = su[i];
        }
        System.out.println(su[2]);
        //이거 원본도 한번 출력해 보자!

        System.out.println();
        System.out.println("================<5번>===============");

        int temp;
        temp = su[0];
        su[0] = su[4];
        su[4] = temp;

        temp = su[1];
        su[1] = su[3];
        su[3] = temp;

        temp = su[0];
        for (int i = 0; i < su.length; i++)
        {
            System.out.print(su[i] + "\t");
        }


        System.out.println();
        System.out.println("================<6번>===============");

        temp = su[0];
        su[0] = su[4];
        su[4] = temp;

        temp = su[1];
        su[1] = su[3];
        su[3] = temp;

        temp = su[0];
        for (int i = 1; i < su.length; i+=2)
        {
            System.out.print(i+ "번지" + "\t");
        }

        System.out.println();
        System.out.println("================<7번>===============");

        temp = su[0];
        for (int i = 0; i < su.length; i+=2)
        {
            System.out.print(su[i] + "\t");
        }
    }
}
//선생님 해설
//mission
package MissionA;

class A
{
    void hello()
    {
        System.out.println("안녕");
    }
}

public class MissionA
{
    public static void main(String[] args)
    {

        int su[] = { 1, 2, 3, 4, 5, 60};
        // 배열 크기 (su.length) =>> 6

        A a = new A();
        a.hello();
        a.hello();
        System.out.println("=================");

        new A().hello();
        new A().hello();
        System.out.println("=================");





        A []arr = new A[3];
        //A [] arr = {null, null, null};
        arr[1] = new A();
        //A [] arr = {null, new A(), null};

//        arr[0].hello(); 아직 arr[0]이 할당 못받았다. NullPinterException 발생
        arr[1].hello();
        System.out.println( "arr 배열 크기 : " + arr.length );

//      int []su = { 1, 2, 3, 4, 5 };
        //인덱스               0  1  2  3  4

        //arr.length ? =>> 0, 3
        System.out.println("\n===============");
        System.out.println("문제 1");

        for (int i = 0; i < su.length; i++) 
        {
            System.out.print( su[i] );
            if(i < 4)System.out.print(", ");
        }

        System.out.println("\n===============");
        System.out.println("문제 2");

        for (int i = su.length-1 ; i > -1; i--) 
        {
            System.out.print( su[i] );
            if(i>0)System.out.print(", ");
        }        

        System.out.println("\n===============");
        System.out.println("문제 3");
        //2차원 배열을 다중for문을 통해 출력
        //행              0        1           2
        int su2[][] = { { 1 }, { 1, 2 }, { 1, 2, 3} };
        //열              0      0   1     0   1  2
        for( int i = 0; i < su2.length; i++ ) // 기준 : 행 인덱스
        {
            for( int j = 0; j < su2[i].length ; j ++ ) //각 행의 열 인덱스
            {
                System.out.println("su2[" + i + "][" + 0 + "]번지 = " + su2[i][j]);
            }
        }

        System.out.println("\n===============");
        System.out.println("문제 4");

        int su3[] = new int[ su.length ]; // new int[5]


        su3 = su; // su3과 su는 참조변수이다.(속성변수가 아닌) , 이는 메모리 값의 주소! 주소 값을 전해준다.
        //su3[2] = 33; // 이렇게 해버리면 원본까지 바뀌어 버린다.

        for (int i = 0; i < su3.length; i++)
        {
            System.out.println("su3[" + i + "] = " + su3[i]);
        }

        System.out.println("원본출력");
        for (int i = 0; i < su3.length; i++)
        {
            System.out.println("su[" + i + "] = " + su[i]);
        }

        //원본까지 바뀌지 않기 위해
        for (int i = 0; i < su.length; i++)
        {
            su3[i] = su[i];
            System.out.print(su3[i]);
            if(i <4 )System.out.print(", ");
        }
        /*출력값
        문제4)
su3[0]=12
su3[1]=2
su3[2]=33
su3[3]=4
su3[4]=5
su3[5]=65
===원본su배열출력===
su[0]=12
su[1]=2
su[2]=3
su[3]=4
su[4]=5
su[5]=65
        */
        System.out.println("\n===============");
        System.out.println("문제 5");

        //데이터 교환
        //int j = 4; //교환할 오른 쪽 데이터 인덱스 4 3 
        int temp;
        for(int i = 0, j = su.length - 1 ; i < su.length/2; i++, j--) //교환할 왼쪽 데이터 인덱스 0, 1
        {
            temp = su[i];
            su[i] = su[j];
            su[j] = temp;

            //j--;
        }

        for(int i = 0; i < su.length; i++)
        {
            System.out.println("su[" + i + "] = " + su[i]);
        }

        /*
        문제5)
su[0]=65
su[1]=5
su[2]=4
su[3]=3
su[4]=2
su[5]=12

        */
        System.out.println("\n===============");
        System.out.println("문제 6 홀수번지 출력하기");
        for (int i = 0; i < su.length; i++)
        {
            if(i%2==1)//홀수번지 (==인덱스) 조건
                System.out.println( "su["+i+"] = " + su[i]);
        }

        System.out.println("\n===============");
        System.out.println("문제 7 홀수번지 출력하기");
        for (int i = 0; i < su.length; i++)
        {
            if(su[i]%2==1)//홀수데이터값 조건
                System.out.println( "su["+i+"] = " + su[i]);
        }


    }//main    
}

<삼항연산자>

  • 형식

    조건식 ? A : B
    (조건식) ? A : B
    => 조건식의 결과가 true였을 때 A리턴, 결과가 false였을 대 B리턴
  • 사용 예)

    boolean b =  (3<4)  ?  true  : false;
    //  ==> b변수에 true 저장
    
    int su=1;
    String gender =  su%2!=0  ?  "남자"  : "여자";
    //  ==> gender변수에 "남자" 저장
    
    int su2 =  ('남' == '여')  ?  100  : 300;
    //  ==> su2변수에 300 저장

<클래스 객체 비교>

  • 클래스 참조변수 == 클래스 참조변수2 =>> 메모리 주소 비교

    A a1 = new A(); 
    A a2 = new A();
    System.out.println(a1 == a2)
      //결과값 false : 서로 다른 메모리 주소
    
    a2 = a1 //a1이 갖은 주소를 a2에 전달
    System.out.println(a1 == a2)
      //결과값 true : 서로 같은 메모리 주소
  • 위와 비교해서 참고

    • 속성변수1 == 속성변수 =>> 데이터 값 비교!
    int su1 = 30;
    int su2 = 30;
    System.out.println(su1==su2)
    //결과값 true : 값은 값을 갖는다.
int su1; // 속성변수 (기본 자료형으로 선언된 변수)
su1 = 100;
su1.~ (x)

Integer su2; // 참조변수!! (데이터의 위치는 메모리이고 그 메모리의 주소를 담는 변수!)
su2 = new Integer(100);
su2.~ (o)

오토박싱 언박싱

  • JDK 5버전 이후 지원
  • int, double과 같은 기본형 자료형의 포장 클래스가 있어, 기본형을 객체로 다루어야 할 경우에 사용 가능
  • 포장하는 클래스, 기본 자료형을 포장한다!
  • 자바의 모든것은 객체?! =>> 객체가 아닌것들도 존재 =>> 기본 자료형(빈번한 연산을 하기 위해 높은 성능을 위해 객체화 하지 않은 듯?!)
  • 객체가 아니어서 컬렉션 또는 다형성 제네릭 이용시에 불편!
  • 그래서 래퍼 클래스를 사용한다!
  • 기본자료형과 래퍼간 == 연산과 equals연산 모두 성립.
  • 하지만 래퍼와 래퍼 사이는 equals 성립, == 성립 안함. 단 대소 비교 > < 가능
int su3 = new Integer(300);
Integer su4 = 300;
  • 기본자료형 래퍼클래스 (위치: 기본패키지 java.lang)
    byte —-> Byte
    short —-> Short
    int —-> Integer (정수와 관련된 속성,메소드를 지원하는 클래스)
    long —-> Long
    float —-> Float
    double —-> Double
    char —-> Character
    boolean —-> Boolean

  • 생성자는 위와 같이 해당하는 기본형을 줄 수도 있고 문자열로 줄 수도 있다. 문자열로 주는 경우 형식에 맞아야 함

  • 근데 래퍼클래스 사용시 참조형끼리 연산 불가… 다시 자료형으로 변환하여 연산…

  • 그래서 오토박싱과 언박싱이 등장!

  • 오토박싱은 기본자료형을 래퍼클래스로 감싸주지 않아도 박싱

    Integer k = 2; // 내부적 동작 Integer a = new Integer(2);
    Object L = 2 // Object o = new Integer(2) 로 동작, 다형성
  • 언박싱은 기본자료형으로 변환 안해도 포장을 풀어줌

    Integer k = new Integer(2);
    int i = a; // 내부적으로 int i = a.intValue(); 로 동작
  • 박싱이라는게 기본형->참조형 변환

  • 언박싱은 참조형-> 기본형 변환

  • 래퍼클래스 이용하여 문자열을 기본 자료형으로 변환 가능, 문자열을 래퍼클래스로 변환 가능

궁금상자
- 배열은 같은 자료형으로 모여야 하는데 , 그럼 2차원 배열에서 안에 배열은 스트링 밖에 배열은 숫자 이렇게도 가능할까?

- boolean 기본 값 false? char 는 '/u0000' 맞나?
for(int i = 0; i < su.length; i++)
    {
        for ( int j = 0; j < i; j++)
        {
            if(su[i] == su[j])
            {
                su[j]--;
                break;
            }   
        }
    }

190417_Day8 라인단위 입력, 클래스 객체 생성, 배열, 2차원 배열

복습

추상클래스

  • 메소드 구현을 상속받은 클래스에 강제한다.

  • 자식클래스들을 제어할 목적

  • 자식클래스들의 특징을 모아놓은 클래스

  • 추상 클래스는 객체생성 new 불가 => 자식클래스 객체생성

  • 형식

  • abstract class 클래스명
    {
      int su; // 변수선언;
      명시적 생성자;
      void hello() {} // 구현(정의)메소드;
      abstract void print(); // 선언 메소드, 이름만 짓고 , 자식클래스에서 기능넣기!, 얘는 접근제한자 안 적어도 public
    //*오버라이딩, 상속시에 자식 클래스는 반드시 부모클래스의 접근제한보다 같거다 커야 한다.   
    }
  • 클래스 사용 => 객체생성해서 사용

    class A{ void hello(){} }
    //==
    A a = new A();
    a.hello();
  • 인터페이스 사용 => 클래스에 구현(implements)해서 사용

    interface B {void hello(); }
    //==
    class a implements B { void hello(){} }
  • 추상클래스 사용 => 자식클래스 객체 생성해서 사용

    class Child extends Parent { void print() {} }
    //==
    A a = new A();
    a.hello();

메소드 호출

  • public void my()
    {
      m1( ); // 1. 메소드 호출
    
      m2(); // 에러 발생
      m2( 500 ); // 3. 500을 넣어서 매개변수 통해 전달,데이터 혹은 데이터를 담은 변수안의 데이터를 줘야 한다. 
      int num = m3( ); //6. 반환 받은 값 800을 num을 선언하며 초기화
    }
    
    //==
    void m1( ) // 이름을 불러주세요
    {
      문장1;
      문장2;
      문장3;
    } // 2. 반환
    
    void m2( int su ) // 정수 데이터 주세요
    {
    
    }// 4. 반환
    
    int m3( ) // 결과값을 정수로 드릴게요
    {
      return 800; //5. 반환
    }
//이거 좀 많이 헷갈리네...
class Parent{ }
class Child extends Parent{ }
//-------
//<메소드 정의>
pulic void  hello( Child c ) 
{

}
public void goodBye( Parent p ) 
{
    //Parent p = new Child(); 대체 가능
}
//-------
//<메소드 호출>
hello(new Child());

//위와 같은 표현
Child cc = new Child();
    hello( cc );

hello(new Parent( ) ); //? 안됩니다. 자식객체에 부모객체가 들어갈 수 없다!
//--------
goodBye(new Parent); // 가능

Parent pp = new Parent();
goodBye( pp );

goodBye( new Child( ) ); //가능!


//--------
void a(String greeting)
{

}

String b(int su)
{
    return "안녕하세요";
}

int c()
{
   return 500; 
}

//--------
a( b( c( ) ) ); //이런식으로도 가능하다! c-> b-> a 순으로 실행됨 
//<--실행순서---
//--------

  • <라인단위입력>
    클래스 BufferedReader –>> 메소드 readLine()
    API문서 정보 =>> BufferedReader
    A a = new A();
    Reader r = new Reader(); =>>(x)=>> 추상클래스 : 자식 ==> InputStreamReader

    InputStreamReader is = System.in;
    Reader r = new InputStreamReader(); =>>(o)
    BufferedReader br = new BufferedReader( r );
    이렇게 3줄이 나와야 br.readLine(); 사용가능 줄을 구분자로 하는 text입력

    근데 is 나 r은 한번 쓰고 다시는 안쓰는데… 굳이 변수지정?!
    BufferedReader br = new BufferedReader( new InpuStreamReader( System.in ) );

  • 클래스 객체 생성

    • 멤버 필드, 멤버 메소드들에 대한 메모리 할당

      1. 동적 메모리 할당

        • 사용안하는 객체에 대해서 가비지 컬렉터가 자동 소멸 관리

        • 키워드 : new

        • 사용법 : 참조변수를 통해 참조

      A a = new A();
      a.hello();
      1. 정적 메모리 할당

        • 자주 사용되는 필드, 메소드에 대해 정의
        • 객체들간의 통신에 사용 ( 공뷰 데이터를 표현 )
        • 키워드 : static
        • 사용법 : 클래스 명으로 참조
        • 클래스명.필드명 클래스명.메소드명(); =>> 클래스변수, 클래스메소드
      class B
      {
       static int su = 100; //static public == public static 이다!
       public static void goodBye(){}
      }
      
      //====================================
      //<길동개발자>          <라임개발자>
      //B.goodBye();         B.goodBye();
      //Syso(B.su); 100출력        
      // B.su++;
      //                     Syso(B.su); 101출력!
      //System.out.println();
      //out은 필드 .println();은 메소드
      public class System
      {
       static PrintStream out;
      }
//어제 mission 풀이
/*
*
**
***
****
*/

public class StarTest 
{
    public static void main(String[] args) 
    {
        for(int i = 1; i < 5; i ++)
        {
            for(int j = 1; j <= i  ; j++)
            {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}
//========================== 거꾸로

public class StarTest 
{
    public static void main(String[] args) 
    {

        for(int i = 4; i > 0; i--)
        {
            for(int j = 1; j <= i; j++)
            System.out.print("*");

            System.out.println();
        }
    }
}

배열

  • 자료형이 동일한 데이터들에 같은(한개의) 변수명을 정의한 자료들의 집합.

    • 자료형이 동인한 데이터들 => 조건

    • 같은(한개의) 변수명을 정의=>특성

    • 자료들의 집합 => 정의

    int su; -> 한 개의 정수를 저장할 준비

    int []su2; ->여러개의 정수를 저장할 준비

    • 서로 데이터들을 구분하기 위해 번지를 사용.

    • 시작번지는 0번지, 1씩 증가하는 번지를 가짐

    • 배열의 크기가 정해지면 인덱스를 벗어나는 참조를 하면 안됨.

    int [] su3 = { 10, 20, 30 };

    번지 인덱스 = su3[0] su3[1] su3[2]

    배열의 크기 ( 요소 갯수 ) : 3 ( 인덱스 0~2 )

  • <5000 데이터 출력>

    System.out.println(5000);
    
    int su = 5000;
    System.out.println(su);
    
    int []suArr = { 5000 };
    System.out.println( suArr[0] );
  • 배열의 크기 ( 배열의 요소 갯수 ) 를 구하는 속성 : 배엷명.length (배열은 객체다)

  • 배열선언시 []는 변수명 앞에 또는 뒤에 붙여도 상관이 없다.

    int []su;

    int su[];

    .

    int i;

    int j;

    int k;

    ===>> int i,j,k;

  • 차이점)

    int su1[],su2; =>> su1은 정수배열, su2는 정수

    int [] su1, su2; =>> su1, su2 둘다 정수배열

  • 참고)

    class A
    {
        int i; // 기본값 존재
    
        void hello()
    {
    int j; // 지역변수 기본값 존재 X
    System.out.println(i); // 출력? 0
    
    System.out.println(j); // 출력? 초기화하지 않았다는 에러 발생
        j = 0;
        System.out.println(j); // 출력? 0
    
      int a,b,c = 0;
      System.out.println(b); // 출력? 에러 발생, c만 0으로 초기화 된거야!, 방지하려면 int a = 1, b = 2, c =0; 이렇게 각각 초기화까지 해줘야 한다!
    }//hello
    }
  • <배열형식>

    1. 자료형 [ ] 배열명 = { 데이터List( 콤마로 구분되는 데이터 ) };

      =>> 배열 선언과 동시에 데이터를 초기화. ( 이미 데이터가 확정되었을 때 사용 )

      =>> 주의 : 배열 선언과 데이터 초기화하는 부분을 따로 작성할 수 없음!

      int [] su; // 배열선언
      su = {1,2,3,4,5}; // 배열초기화 (X)
      
      //===
      
      int [] su = { 1, 2, 3, 4, 5 } // 선언과 동시에 초기화 (o)
      
      //===
      A a = new A();
      a []su = { a, newA(), newA() };
    2. 자료형 [ ] 배열명 = new 자료형 [배열크기]; // 배열 객체 생성식 : 암기!

      =>> 프로그램 실행 도중 데이터 값을 입력, 변경할 때 주로 사용

      ​ =>> 데이터가 정해지지 않고 앞으로 입력받을 데이터들이 저장될 방(공간)만 준비

      ==>> 배열선언과 데이터 초기화하는 부분을 따로 작성하는 것이 가능

      ==>> 배열 크기 []는 반드시 자료형 뒤에 위치해야 함

      ==>> 배열크기에 정수값이 반드시 입력되어야 함.

        int []su; // 배열선언
      
        su = new int[5]; //배열초기화 (su 배열변수에 5개의 정수를 입력 받겠음!)
      
      // 이는 이렇게 써 된다.
      int [] su = new int [5];
      
      // 데이터 입력 
      su[0] = 11;
      su[1] = 22;
      su[2] = 33;
      su[3] = 44;
      su[4] = 55;
      
      su[5] = 66; // 얜 인덱스를 벗어났으므로 에러~!  
      // 배열 객체생성( 위의 2번 ) 을 하게 되면 그 위치에 상관없이 각방에는 초기값이 부여됨
      // ( 멤버변수 처럼 각 자료형의 기본값이 입력됨 )
      
public class ArrayTest 
{
    public static void main(String[] args) 
    {
        //1. 배열 선언과 초기화
//      int []su;
//      su = { 1, 2, 3, 4, 5 }; 에러 발생 : 반드시 선언과 동시에 초기화를 함게 기술할 것!

        int []su = { 1, 2, 3, 4, 5 }; // 이렇게 선언과 동시에 초기화 할 것! { su[0], su[1], su[2], su[3], su[4] }
        int su1[] = { 1, 2, 3, 4, 5 };

        System.out.println( "su[0]번지 = " + su[0]);
        System.out.println( "su[1]번지 = " + su[1]);
        System.out.println( "su[2]번지 = " + su[2]);
        System.out.println( "su[3]번지 = " + su[3]);
        System.out.println( "su[4]번지 = " + su[4]);
        // System.out.println( "su[5]번지 = " + su[5]); 에러발생 인덱스를 벗어남!


        System.out.println("=====================================");
        System.out.println("배열의 크기 ( 요소갯수 ) " + su.length);

        for(int i = 0; i < su.length; i++ ) 
        {
            //배열의 인덱스 표현 ( 0, 4)
            System.out.println("su[ "+ i + " ]번지 = " + su[i]);
        }
    }
}
package Rand;

import java.util.Random;

public class RandArrayTest
{       
        int []su; // null 값이 들어감
        Random r;

        public RandArrayTest() 
        {
            su = new int[5]; // [0]번지 ~ [4]번지 생성
            r = new Random();
        }

        public void inputArray() 
        {
            for (int i = 0; i < su.length; i++)
            {
                //랜덤(임의의 난수) 수를 발생해서 배열안에 입력
                //su[i] = (int)( Math.random() * 100 ); //0.0 ~ 0.999999999... * 100 을 다섯번 호출, 캐스팅이 우선순위라 괄호 하기
                //      ----- 캐스팅 연산자 (형변환 연산자) 
                su[i] = r.nextInt(1000) + 1; // 0~999,  + 1 : 0~1000
            }

        }
        public void printArray() 
        {
            for(int i = 0; i < su.length; i++)
            {
                System.out.println("su[ " + i + " ] = " + su[i] );
            }
        }
        public void sortArray() {}

        public static void main(String[] args) 
        {
            RandArrayTest rat = new RandArrayTest();
            rat.inputArray();
            rat.printArray(); // 배열값 출력
        }

}
/*
su[ 0 ] = 804
su[ 1 ] = 782
su[ 2 ] = 632
su[ 3 ] = 57
su[ 4 ] = 375
*/
//swap
package Rand;

public class SwapTest
{
    public static void main(String[] args)
    {
        int su1 = 50;
        int su2 = 30;

        int temp = su1; //임시변수 temp = 50;
        //교환식
        su1 = su2; // su1 = 30;
        su2 = temp; // su2 = 50; 

        System.out.println( "su 1 = " + su1 ); //30
        System.out.println( "su 2 = " + su2 ); //50

        //---------------------

        int []arr = { 300, 100 };

        //배열의 값 변경

        temp   = arr[0];
        arr[0] = arr[1];
        arr[1] = temp;

        System.out.println( "arr[0] = " + arr[0] );
        System.out.println( "arr[1] = " + arr[1] );

    }
}
package Rand;

import java.util.Random;

public class RandArrayTest
{       
        int []su; // null 값이 들어감
        Random r;

        public RandArrayTest() 
        {
            su = new int[5]; // [0]번지 ~ [4]번지 생성
            r = new Random();
        }

        public void inputArray() 
        {
            for (int i = 0; i < su.length; i++)
            {
                //랜덤(임의의 난수) 수를 발생해서 배열안에 입력
                //su[i] = (int)( Math.random() * 100 ); //0.0 ~ 0.999999999... * 100 을 다섯번 호출, 캐스팅이 우선순위라 괄호 하기
                //      ----- 캐스팅 연산자 (형변환 연산자) 
                su[i] = r.nextInt(1000) + 1; // 0~999,  + 1 : 0~1000
            }

        }
        public void printArray() 
        {
            for(int i = 0; i < su.length; i++)
            {
                System.out.println("su[ " + i + " ] = " + su[i] );
            }
        }
        public void sortArray() 
        {
            int temp;
            for(int i = 0; i < 4; i++) // 비교할 왼쪽(기준) 데이터 0 1 2 3 4
            {
                for(int j = i + 1; j < 5; j++) // 비교 오른쪽 데이터 1, 2, 3, 4     2,3,4       3,4     4
                {
                    if(su[i] > su[j]) //정렬조건 오름차순 ex) 정렬 12345, abcde, 가나다라마
                    {
                        //i와 j는 배열의 번지수를 표현
                        temp = su[i];
                        su[i] = su[j];
                        su[j] = temp;
                    }

                }
            }

        }

        public static void main(String[] args) 
        {
            RandArrayTest rat = new RandArrayTest();
            rat.inputArray(); //난수 데이터를 배열에 입력
            rat.sortArray(); //데이터 정렬(오름차순)
            rat.printArray(); // 배열값 출력
        }

}

<2차원배열>

  • 실제 저장은 1차원 배열과 같으나 논리적으로 데이터를 행과 열의 형태로 저장한다고 생각, 표현.

  • 행 사이즈는 반드시 기술해야 하며, 열 사이즈는 생략하는것이 가능

    //배열선언
    int [][]su;
    int su[][];
    int []su[]; //대괄호의 위치는 상관이 없다.
    //            ----0행----    ----1행----
    int [][]su = { { 1, 2, 3 }, { 4, 5, 6 } };
    //                -------     --------
    //                열:0,1,2     열:0,1,2
    
    System.out.println(su[0][2]); //0행 2열 데이터 =>> 3
    System.out.println(su[1][1]); //1행 1열 데이터 =>> 5
    
    su.length // 행의 갯수 => 2 
    su[0].length //== 0행의 열의 갯수 =>> 3
    su[1].length //== 1행의 열의 갯수 =>> 3
    
    for( int i = 0; i < su.length; i++ )  //기준(행) : 행의 인덱스 표현
    {
      for( int j = 0; j < su[i].length; j++ ) //각 행의 열 인덱스 : 0, 1, 2
      {
          System.out.prinln( su[i][j] ); // su i행 j열
      }
    }
    public static void main(String[] args) 
    {
      RandArrayTest rat = new RandArrayTest();
      rat.inputArray(); //난수 데이터를 배열에 입력
      rat.sortArray(); //데이터 정렬(오름차순)
      rat.printArray(); // 배열값 출력
    
      int [][]su2 = { { 1, 2, 3 }, { 4, 5, 6 } };
    
      System.out.println( "su2배열의 행 갯수" + su2.length );
      System.out.println( "su2배열 첫번째 행의 열(데이터) 갯수 " + su2[0].length );
      System.out.println( "su2배열 두번째 행의 열(데이터) 갯수 " + su2[1].length );
    
      //전체 데이터 조회
      for(int i = 0; i < su2.length; i++)
      {
          for(int j = 0; j < su2[i].length; j++ )
          {
              System.out.println("su2[" + i + "][" + j + "] = " + su2[i][j]);
          }
      }
    }
    
    /*
    su2배열의 행 갯수2
    su2배열 첫번째 행의 열(데이터) 갯수 3
    su2배열 두번째 행의 열(데이터) 갯수 3
    su2[0][0] = 1
    su2[0][1] = 2
    su2[0][2] = 3
    su2[1][0] = 4
    su2[1][1] = 5
    su2[1][2] = 6
    */
    //mission
    
    package mission;
    
    public class Mission0417
    {
    public static void main(String[] args)
    {
        int su[] = { 1, 2, 3, 4, 5};
        System.out.println("================<1번>===============");
        for( int i = 0; i < su.length; i++ )
        {
            System.out.print(su[i] + "\t");
        }
        System.out.println();
        System.out.println("================<2번>===============");
        for( int i = su.length - 1 ; i >= 0; i-- )
        {
            System.out.print(su[i] + "\t");
        }
        System.out.println();
        System.out.println("================<3번>===============");
    
        int su2[][] = { { 1 }, { 1, 2 }, { 1, 2, 3 } };
        for( int i = 0; i < su2.length; i++)
        {
            for( int j = 0; j <= su2[i].length - 1; j++)
            {
                System.out.println("su[ " + i + " ] [ " + j + " ] = " + su2[i][j]);
            }
        }
    
        System.out.println();
        System.out.println("================<4번>===============");
    
        int su3[] = {5, 5, 5, 5, 5}; 
        for ( int i = 0; i < su.length; i ++)
        {
            su3[i] = su[i];
        }
        System.out.println(su[2]);
    
    
        System.out.println();
        System.out.println("================<5번>===============");
    
        int temp;
        temp = su[0];
        su[0] = su[4];
        su[4] = temp;
    
        temp = su[1];
        su[1] = su[3];
        su[3] = temp;
    
        temp = su[0];
        for (int i = 0; i < su.length; i++)
        {
            System.out.print(su[i] + "\t");
        }
    
    
        System.out.println();
        System.out.println("================<6번>===============");
    
        temp = su[0];
        su[0] = su[4];
        su[4] = temp;
    
        temp = su[1];
        su[1] = su[3];
        su[3] = temp;
    
        temp = su[0];
        for (int i = 1; i < su.length; i+=2)
        {
            System.out.print(i+ "번지" + "\t");
        }
    
        System.out.println();
        System.out.println("================<7번>===============");
    
        temp = su[0];
        for (int i = 0; i < su.length; i+=2)
        {
            System.out.print(su[i] + "\t");
        }
    }
    
    }
    /*
    ================<1번>===============
    1 2   3   4   5   
    ================<2번>===============
    5 4   3   2   1   
    ================<3번>===============
    su[ 0 ] [ 0 ] = 1
    su[ 1 ] [ 0 ] = 1
    su[ 1 ] [ 1 ] = 2
    su[ 2 ] [ 0 ] = 1
    su[ 2 ] [ 1 ] = 2
    su[ 2 ] [ 2 ] = 3
    
    ================<4번>===============
    3
    
    ================<5번>===============
    5 4   3   2   1   
    ================<6번>===============
    1번지   3번지 
    ================<7번>===============
    1 3   5   
    */
궁금상자
- 동적, 정적 메모리가 변화 있고 없고 차이가 아니었나보네? 알아보자!

- 

190415 Day7 this, interface, mission, 배열, 자바빈즈, 추상클래스

복습

System.out.println(); 에서 out은 필드인데 어떻게 메소드인 println()을 포함하고 있지?

  • out은 PrintSteam이라는 메소드로 정의되어 있음 PrintStream out; 이렇게

명시하는 this

  • this는 보통 생략하지만 명시할 때도 있다. 생성자가 두개 있을 때

  • public class Abc
    {
      int su;
    
      public Abc()
      {
    
      }
    
      public Abc(int su)
      {
          su = su;
      }
    
      public void hello()
      {
    
      }
    }
    
    /*
    객체생성1
    abc a = new Abc();
    System.out.println(a.su);
    -> 이렇게 하면 0 출력됨
    
    객체생성2
    Abc a = new Abc(500); // 2번생성자 호출
    System.out.println(a.su);
    -> 이렇게 하면 0이 나옴, su = su는 지역변수에 500을 넣어라가 되어버림
    -> 500이 나오게끔 하고 싶다면 멤버와 지역변수의 이름을 다르게 한다 -> 하지만 이런 경우는 많이 없다. 연관성 주기 위해 이름 같게 함 보통, 그래서 this.su = su 이렇게 명시하면 된다.
    -> Abc(){this(100);} 을 넣어주면 Abc(int su)에 su 값에 100을 넣어주게 된다. 
    
    */

interface

  • 객체를 연결해주는 매개체, 메뉴판 같은, 손님과 주방장을 이어주는!

  • //내가 만든 것
    
    class A implements Common
    {
      void hello()
      {
          System.out.print("신짜오")
      }
    }
    
    //이미 Commmon에는 hello()가 정의되어있다.
    /*
    Common c;
    c = new A();
    c.hello();
    */
    
    class implements Common
    {
      void hello()
      {
          System.out.print("봉쥬르");
      }
    }
    
    /*
    c = new B();
    c.hello();
    */
    
    Common이라는 interface를 통해서 A와 B 클래스를 필요할때마다 쓴다
    느슨한 관계!

mission

package com.encore.$0415.misson;

import java.io.IOException;

/*
 * 기능정의
 * -단입력
 *  int inputDan ()
 * {
 *  int dan = read() 또는 readLine() 을 사용해서 받기 //그리고 단출력에 전달해야 함, return 타입 통해
 * }
 * 
 * -단출력
 *  void outputDan () 
 * {
 *  //전달받은 dan에 대한 출력
 * }
 * -계속여부
 *  char continueDan () 
 * {
 *  read() 또는 readLine()
 * }
 */

public class Gugudan 
{
    //public int dan;//=0
    //public char continuedan;//='\u0000'


    int inputDan() throws IOException
    {
        System.out.println("원하시는 단을 입력해주세요");
        int dan = System.in.read() - 48;
        System.in.read();
        System.in.read();
        return dan;

    }

    void outputDan(int dan)
    {
        System.out.println(dan + "단 구구단 출력");
        for (int i = 1; i <10; i++)
        {
            System.out.println(dan + "X" + i + " = " +  dan*i) ;
        }
    }

    char continueDan() throws IOException
    {
        System.out.println("계속하시겠습니까?");
        char continuedan = (char) (System.in.read());
        System.out.println(continuedan);
        System.in.read();
        System.in.read();
        return continuedan;

    }

}


//===

package com.encore.$0415.misson;

import java.io.IOException;

/*
 * main() 포함
 * 반복적인 실행을 할 것(while 또는 do~while 사용 하면 됨)
 * 이번은 while로 해보자!
 * 반복문 내에서 Gugudan클래스 안에 3개의 메소드가 있는데 3개의 메소드들을 적당히 호출.
 */

public class GugudanTest extends Gugudan
{

    public static void main( String[] args) throws IOException
    {
        Gugudan g = new Gugudan(); 


        System.out.println("구구단");

        int dan = g.inputDan();
        g.outputDan(dan);

//      
//      g.inputDan();
//      g.outputDan(dan);
//      g.continueDan();
//      

        while(g.continueDan() == 'y' )
        {
            dan = g.inputDan();
            g.outputDan(dan);
        }
            System.out.println("종료");
    }

}
//선생님이 설명해주시는 것
//MyTest.java

public class MyTest {

    public static void main(String[] args) {
        My my = new My();
        You you = new You();

        int su = my.juwon();
        you.lime(su);

    }

}
//My.java

public class My {

    int su; // 멤버변수, 필드 ==> 클래스내의 메소드들이 공유할 데이터

    public int juwon()
    {
        //발생되는 데이터
        su = 300;
        //발생된 데이터 주기 =>> 리턴
        return su;
    }




}

class You
{
    public void lime(int su)
    {
        System.out.println("su = " + su);
    }
}
package A0416;

public class MethodCallTest 
{
    public static void main(String[] args) {
        A a = new A();

        a.hello();

        //메인 메소드 실행 중 발생 데이터 : 100
        int su = 100;
        String name = "나길동";
        String name2 = "길라임";
        int age = 15;

        //m1()메소드에게 su를 전달
        a.m1(su);//메소드 호출 () 소괄호 안에 데이터를 표시
        a.m2(name); // 메소드 호출 시 ㅌ데이터를 전달 할 수 있다.

        //데이터 두개 : 15,"길라임" => m3에게 전달
        a.m3(name2, age);

        //String name2라는 변수는 m3에 전달되지 않음
        //name2가 담고 있는 데이터(value) "길라임"만 전달!

        //---------------
        int i = 10;
        int j = 20;
        int k = 30;
        // m4()메소드에게 정수값 10, 20, 30 전달!
        a.m4(i, j, k);


    } //main

}

//A.java
package A0416;

public class A {
    //메소드 정의!

    public void hello()
    {
        System.out.println("A클래스 안녕~!");
    }

    public void m1()
    {

    }

    public void m1(int su)
    {
        System.out.println("m1() : " + su );
    }

    public void m2(String name) 
    {
        //main()메소드에 a.m2("나길동"); 실행되면
        //m2()에서는 String name = "나길동";이 가장 먼저 실행되어집니다.
        System.out.println("m2() : " + name);
    }

    public void m3(String name2, int age) {
        System.out.println("m3() : " + name2 + ", " + age);

    }

    public void m4(int su1, int su2, int su3) {
        System.out.println(su1 + ", " + su2 + ", " + su3);

    }


}

배열

  • 데이터형이 동일한 자료에 같은 (하나의) 변수명을 정의한 자료들의 집합.

    ​ ——————-복수 데이터

  • 데이터형이 동일한 자료 ==>> 조건

  • 같은(하나의) 변수명을 정의 ==>> 특성

  • 자료들의 집합 ==>> 정의

  • -
11 22 33
ture false true
“길동” “라임” “주원”
‘j’ ‘a’ ‘v’

- int su1 =11; int su2 = 22; int3 =33;

  • int [ ] su = { 11, 22, 33 }; =>> su라는 배열변수에 복수 데이터를 대입!

  • 배열은 왜 쓸까?!

    • 그냥 나열하면 되는데…
    • 관리가 편하다!
    • but, 문제가 있다 구분이 안가… 그래서 구분을 만들었어!
    • 실제 {} 안에는 구분이 있음 {ㅁㅁㅁ} 이렇게!
    • 자바에서는 배열은 객체
    • su[]는 전체 데이터 su[0], su[1] , su[2] 는 각각의 데이터
    • 데이터를 구분하기 위해서 사용 =>> su라는 배열변수에 복수 데이터를 대입!
  • int su; =>> 한개의 데이터 입력

  • int []su; =>> 여러개의 데이터 입력 (배열)

  • boolean [ ] b = { true , false, true };

  • String [ ] str = { “길동”, “라임”, “주원” };
  • char []ch = { ‘j’, ‘a’, ‘v’, ‘a’ };

  • 데이터를 구분하기 위해서 번지를 사용

  • 시작번지는 항상 0번지부터 시작!
  • 첫번째 데이터 부터 인덱스(자동번호)가 부여
  • 인덱스는 0부터 시작해서 1부터 증가
  • 배열의 크기가 정해지면 인덱스를 벗어나는 참조를 하면 안됨
  • int [] su3 = {10, 20, 30};
  • 번지 =>> 0 1 2
  • System.out.println( su3[1] ); // 데이터 사용 (두번째 데이터 출력)
  • System.out.println( su3[3] ); // 하면 에러 발생 ArrayIndexOutOfBoundsException

  • for는 규칙적인 수 반복 할때, 배열과 친하다!


자바빈즈

  • 서로 관련성 있는 속성을 묶어주는 클래스(객체)

  • 사용하는 곳에 따라 VO(ValueObject) 또는 DTO(Data Transfer Object) 라는 이름을 사용하기도 함.

  • 사용하고자 하는 속성들을 규칙 약속함! - 개발자들끼리

  • 규칙)

    1. 속성데이터를 private하게 선언
    2. public 선언된 주고 받는 메소드 (get, set)를 정의

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

    1. public한 기본생성자, 오버로딩 생성자를 정의 할 수 있다.
    2. 반드시 속성의 수와 일치하는 get, set이 정의되지 않아도 됩니다.
  • 참고)

    1. get으로 시작되는 메소드들 : 게터(getter)메소드
    2. set으로 시작하는 메소드들 : 세터(setter)메소드
    3. public한 기본생성자, 오버로딩생성자 정의 할 수 있다.
  • public class Person 
    { 
      private String name; 
      private int age; 
      private String job; 
    
      public Person(){}
        public Person (String name, int age, String job)
      {
          this.name = name;
          this.age = age;
          this.job = job;
      }
    
    
          public void setName(String name) //main에 있는 홍길동 받아옴
          {
              this.name = name;
          }
          public void setAge()
          {
              this.age = age;
          }
          public String getName()
          {
              return name; // this. 생략
          }
          public String getJob()
          {
              return job; // this. 생략
          }
    
    }
    //private 붙이면 쓰레긴데?!
    
    //===main===
    Person p = new Person();
    p.name = "홍길동"; //=>> 이름 정보 주기(설정) : 에러발생
    p.setName("홍길동") //=>> 실행 OK
    //system.out.println(p.name); //=>> 이름정보를 받기(얻기) private없다면 "홍길동 출력"
    System.out.println( p.getName() );
    //but, Person class에 private String name; 을 해버리면 에러가 난다!
  •  
  • public class Person { String name; int age; String job; }

    •  

alt + shift + s 통해서 getter setter 자동 생성!

ctrl + shift +enter 기본생성자 생성!

필드값도 생성하자!

1555387690155

매개변수와 get는 같지만 방향성이 조금 다른것일 뿐


추상클래스

  • 후손 class를 제어할 목적으로 사용.
  • 객체화 될 수 없는 클래스
  • 구현(정의)된 메소드와 선언된 메소드로 구성
  • 스스로 객체생성 불가 ( new 사용 X ), 후손class 객체생성(지식은 부모다)해서 사용
class 기본클래스
{
    //정의(구현)된 메소드
    void hello(){}
}

//---

class 추상클래스
{
    //선언된 메소드, 정의된 메소드
    void hello();
    void goodBye(){}
}

//---

interface 인터페이스
{
    //선언된 메소드만!
    void hello(){};
}
//추상 클래스 형식
abstract class 클래스명
{
    //필드선언
    public void hello(){}//구현된(정의된) 메소드
    abstract void print(): // 선언된 메소드(abstract 붙여줘야해)
}
  • 주의!
    • 선언된 메소드를 사용하는 경우 반드시 abstract 명시!
    • 만약 abstract 미기재시에는 에러 발생!
궁금상자
- 배열에서 시작은 0인데 바꿀 수 없나? 그리고 순서가 +1이 아니라 +2 씩 증가하게 할 수 없나?

- 배열은 타입이 같아야 하는데 만약 문자 숫자 배열 두개를 매번 교차로 출력하고 싶다면 그냥 for문 써서 하나씩 해야 하나?
    선생님이 설명해주심 바로,,ㅋㅋ 숫자를 문자로 형변환 후!

- super(); ? 빼도 된다구?

- 매개변수와 getter

- 자바 ioc?

190415_6일차 이클립스 설치, 접근지정(제한)자, 자기참조연산자, 인터페이스, final, 클래스와 인터페이스 간의 상속 문법


이클립스 설치

  • 1555290513997
  • https://www.eclipse.org/downloads/packages/
  • 우리는 Enterprise용으로 받는다~! // 밑에 있는 버전은 자바만 개발 가능하고, 위의 버전은 자바도 가능하고 HTML, JavaScript, Spring, Git 등이 사용 가능하기 때문에!
  • 첫 화면에서 다운 받으면 .exe 실행파일 되기 때문에, zip 파일 선호, 자칫 실행파일로 설치하면 개발 설정을 바꿀 수도 있기에…

  • 1555292175950

  • 작업공간 설정

  • 1555292331690

  • 1555292361723

  • Open Perspective 는 작업환경~, 기본적으로 제공하는 플러그인, 자바 프로젝트 하면 보통 Java와 Java EE를 사용

  • 자바 클래스 = 자바 빈, 아직 우리는 Java로 한다!

  • /*
         * 이클립스 단축 키 : 메뉴 window - Preferences - General - Keys
         * 
         * Ctrl + space : 자동완성
         * Ctrl + 1 : 제안기능
         * Ctrl + / : 한줄 주석 추가, 삭제
         * Ctrl + Alt + 아래 화살표 : 설택된 블럭을 복사하여 아래로 붙여넣기
         * Alt + 위 아래 화살표 : 선택된 블럭을 위 아래로 이동
         */
  • 나는 폰트는 cambria로~!

  • 패키지 이름 달리하면 병합 할때 좋다. 그래서 com.~~~ 이런식으로 이름을 구성한다!

  • 웬만하면 Refector - rename 은 하지 말자, 할거면 그냥 코드 복사해서 붙여 넣는 방법이 더 좋음, 왜? 이클립스가 좋은 부분 중 하나가 작성하고 저장하면 히스토리를 다 남김,

  • //package선언 : 현재 프로그램(클래스)의 위치 지정
    //형식 ) package 상위패키지명, 하위패키지명;

    //import 선언 : 현재 프로그램(클래스) 에서 사용할 외부 클래스의 위치 지정
    //형식 ) import 패키지명, 클래스명;

//지난 과제
package com.encore.$0415;

import java.io.IOException;

//package선언 : 현재 프로그램(클래스)의 위치 지정
//형식 ) package 상위패키지명, 하위패키지명;

//import 선언 : 현재 프로그램(클래스) 에서 사용할 외부 클래스의 위치 지정
//형식 ) import 패키지명, 클래스명;

public class MenuTest 
{
    public static void main( String[] args ) throws IOException 
    //System.in.read() 하면 에러가 발생할 수도 있는데 예외처리 안할래! 라는 의미.
    // 왜 IOException을 예외처리할까? 지난번엔 그냥 Exception 이었는데, 
    //추후에 배운다!
    {
        int num;
        int su = 0;// 증가 또는 감소한 값을 유지하기 위해 반복문 밖에 선언
        do
        {
        System.out.println( " < < 메 뉴 > > " );
        System.out.println( "1. 검색  2. 증가  3. 감소  4. 종료" );
        System.out.print( "번호를 입력하세요 ==>> " );
        num = System.in.read() - 48;
                     System.in.read(); // CR (13) 맨 앞으로 이동
                     System.in.read(); // LF (10) 줄 바꿈

        switch(num)
            {
            case 1 : System.out.println( "#검색 결과\n" + su); break;
            case 2 : su++; System.out.println( "#1증가"); break;
            case 3 : su--; System.out.println( "#1감소"); break;
            }
        System.out.println();
        }while( num != 4 );
        //자바에서 { } 는 영역가로 Scope , Body 라고 말함, 

        System.out.println( "-- END --" );
    }
}

<접근지정(제한)자 : AccessControl>

  • public
    • 서로 다른 패키지에서도 접근가능
  • protected

    • 서로 같은 패키지에서 접근가능, 만약 상속관계를 갖는다면 자식에서 부모를 참조할 수 있는 것.
  • default

    • 생략, 서로 같은 패키지에서 접근가능
  • private
    • 같은 클래스 내에서만 멤버끼리만 접근 가능
##p1패키지
class Parent
{
    public void m1(){}
    protected void m2(){}
    void m3(){}
    private void m4()P{} //m1, m2, m3 만 호출 가능 다른 패키지, 클래스에서 불가
}

class Child extends Parent
{
    // m1, m2, m3 접근 가능하나 m4에서는 접근 불가
}

================================
##p2패키지
class Child extends Parent
{
    //m1 접근 가능, m2 접근 가능(부자 관계이기 때문), m3 불가, m4 불가
}
================================
##p3패키지
class other
{
    //m1만 호출 가능, 같은 패키지도 아니며 부자 클래스 관계도 아니기 때문
}
  • 접근 지정자 위치

    1. 필드

      • [접근지정자 4개] 자료형 변수명;
    2. 메소드

      • [접근지정자 4개] 리턴자료형 메소드명(매개변수){}
    3. 클래스

      • [접근지정자 2개 (public , default 만 가능)] class 클래스명 {}
      • 클래스인데 만약 private가 된다면 그냥 쓰레기임…
  • 접근 지정자 뭐 해야 하는데 고민이라면 그냥 public 깔아두고 생각해보자,

직접 해보자!

//p1패키지

package p1;

//기준!! (서로 다른 접근 제한자를 갖는 메소드 정의)
public class Parent { 

        public void m1()
        {
            System.out.println("m1");
        }
        protected void m2()
        {
            System.out.println("m2");
        }
        void m3()
        {
            System.out.println("m3");
        }
        private void m4()
        {
            System.out.println("m4");
        }

}

package p1;

//자식에서 부모클래스의 메소드 호출
public class Child extends Parent{

    void callTest() {
        m1();
        m2();
        m3();
        //m4(); // 에러 The method m4() from the type Parent is not visible , 자식도 호출 불가
        //m5(); // 에러 The method m5() is undefined for the type Child
    }

}

package p1;

//자식에서 부모클래스의 메소드 호출
public class Other {

    void callTest() {
        //m1(); // 에러 The method m1() is undefined for the type Other
        //m2(); // 에러
        //m3(); // 에러
        //m4(); // 에러 The method m4() from the type Parent is not visible , 자식도 호출 불가
        //m5(); // 에러 The method m5() is undefined for the type Child

        Parent p = new Parent();
        p.m1();
        p.m2();
        p.m3();
        //p.m4(); // 에러 , The method m4() from the type Parent is not visible
    }

}
//p2 패키지
package p2;
//import 안하면 패키지 달라서 에러
import p1.Parent;

//자식에서 부모클래스의 메소드 호출
public class Child extends Parent{
    void callTest() {
        m1();
        m2(); //같은 패키지에서 접근 가능하다 하지만 상속관계인 부자 패키지 관계이면 패키지가 달라도 접근 가능!
        //m3(); // 에러, 디폴트는 패키지가 다르면 호출 불가
        //m4(); // 에러 The method m4() from the type Parent is not visible , 자식도 호출 불가
        //m5(); // 에러 The method m5() is undefined for the type Child
    }
}
//-------------------------
package p2;

import p1.Parent;

//자식에서 부모클래스의 메소드 호출
public class Other {
    void callTest() {
        //m1(); // 에러 The method m1() is undefined for the type Other
        //m2(); // 에러
        //m3(); // 에러
        //m4(); // 에러 The method m4() from the type Parent is not visible , 자식도 호출 불가
        //m5(); // 에러 The method m5() is undefined for the type Child

        Parent p = new Parent();
        p.m1(); // 왜 여기서는 에러가 발생하지 않은걸까요? public이기 때문~!
        //p.m2(); protected는 같은 패키지에서 접근 가능
        //p.m3(); 디폴트는 같은 패키지 내에서만 접근 가능
        //p.m4(); // 에러 , The method m4() from the type Parent is not visible
    }
}

자기 참조 연산자

  • 1반 홍길동, 2반 홍길동, 3반 홍길동 이 있는데 모두가 모인자리에서 특정 홍길동을 부를땐 2반 홍길동~! 이렇게 말해야 하지만, 2반 안에서 길동이를 찾을때는 굳이 그래야 하는 필요가 있을까? 보통은 생략하고 홍길동이라고 부른다 하지만 아래와 같은 경우에 사용한다!
  • 현재 클래스를 가르키는 레퍼런스 변수(참조변수)!
  • 보통은 생략

    1. 메소드 내에서 사용
    2. 객체 생성자내에서 다른 생성자를 호출시 사용
    3. 매개변수(지역변수)와 멤버변수(필드)를 구분하기 위해 멤버변수 앞에 this.을 붙여 사용.
//형식
this.필드명;
this.메솓명();
this(); //생성자 호출
//참고
super.필드명;
super.메소드명();
super(); //부모클래스 생성자 호출
  • 오른쪽 버튼 눌러서 - source - generate constructor using fields 로 쉽게 생성 가능

%생성자 만드는 단축키 컨 + 스 + 엔


인터페이스

  • 인터페이스는 메뉴판이다!, 유지보수하는데 이점이 있다.

    • 형식

    • “`java
      interface 인터페이스명
      {
      //필드
      [고정 public static final] int su;
      //여기서 static이란 new처럼 메모리 할당 할 수 있음
      //new는 동적메모리 할당, static은 정적 메모리 할당
      //여기서 final이란 마지막 변수라는 뜻, 절대 변하지 않는 수!

      //선언된 메소드
      [고정 public abstract] void print();
      //대괄호 생략 가능
      }

      
      - 저장 : 인터페이스명.java -> 컴파일 -> 인터페이스명.class
      
      - interface의 구성멤버는 필드, 선언된 메소드로만 구성
      
      - ```java
      void print()
      {
          //정의된 메소드, 구현된 메소드!
      }
      
      ///////////////////////선언된 메소드!
      void print(); // 기능 없이 이름만 선언된 메소드 ( 바디없는, 영역괄호 없는 메소드 )
      //단지 연결시켜준것, 메뉴판처럼 손님과 요리사를!

    < 손님의 입장 >

    • 서로 다른 제품에 연결할 수 있는 공통 연결 모듈을 의미.

    < 주방장의 입장 ( 객체를 생성하는 곳 ) >

    • 클래스에 다중 상속을 구현 할 수 있다.

    • ★ 인터페이스는 어떻게 사용? 클래스에 구현해서 사용!!

    • 구현 키워드 : implements

    • “`
      class 클래스명(//주방) implements(//구현의 약속) 인터페이스(//메뉴판)명
      {

    }
    “`

  • 실습

    package com.encore.$0415;
    
    public interface MenuPan 
    {
    // public static final 고정
    //final은 유지할 고정값을 명시해야 함
    
    
    //int coin; 에러 발생, 반드시 초기화 해야 함
    int coin = 500;
    /*public abstract 고정 생략*/void 짜장면();
    /*퍼블릭이 고정 생략*/abstract void 짬뽕(); //선언된 메소드 : abstract method
    public abstract void 볶음밥();
    }
    
    //============
    package com.encore.$0415;
    
    public class Hongkong implements MenuPan  //주방
    { 
    //implements : 구현의 약속
    @Override //어노테이션 JDK5버전 이후
    public void 짬뽕() 
    {
        System.out.println("매콤한 짬뽕");
    }
    @Override 
    public void 짜장면() 
    {
        System.out.println("달콤한 짜장면");  
    }
    @Override
    public void 볶음밥() 
    {
        System.out.println("갓볶은 볶음밥");  
    }
    public void 초밥() // 추가해도 상관 없다!
    {
        System.out.println("초밥 한입에 쏙~");
    }
    }
    
    //============
    package com.encore.$0415;
    
    public class InterfaceTest  //extedns String : 에러 발생
    {
    public static void main(String[] args) 
    {
        //손님
        MenuPan menu = new Hongkong(); 
        //인터페이스는 new 못씀
    
        menu.짬뽕();
        menu.짜장면();
        menu.볶음밥( );
    
        //static멤버는 클래스명으로 접근!!
        System.out.println("코인값 : " + MenuPan.coin);
    }
    }
    
    

Final

  1. final 자료형 변수명;

    • 마지막 변수 : 상수 (constant)
    • 상수의 식별을 위해 전체 대문자로 표기
    //예)
    final int max = 100;
    max++; >> 101 // 에러 발생!
  2. final 리턴형 메소드명 () {}

    • 마지막 메소드 : 오버라이딩(메소드 재정의) 할 수 없는 메소드.
  3. final class 클래스명{}

    • 마지막 클래스 : 클래스는 자식클래스를 통해 기능을 확장하는데, final 클래스는 무자식상팔자 클래스 : 자식 클래스를 갖지 않는 클래스
    • 완벽한 클래스(자식클래스 통한 기능확장을 원치 않는다.)
    • 보안적인 측면에서 사용하기도 함

<클래스와 인터페이스 간의 상속 문법>

class A{}

class B extends A //extends 뒤에는 상속 받고자 하는 한개의 클래스 명만 정의! 
{
    //extends 는 확장의 의미를 갖는다. 자식클래스를 확장 클래스라고도 함   
}
//============================================
interface A
{}
interface B
{}

class C implements A,B 
{}
//위와 대조하여 클래스는 무조건 한개의 클래스만 상속 가능하지만 interface는 , 를 사용하여 다중 인터페이스를 다중 상속 할 수 있다
// A와 B인터페이스 내의 선언된 메소드를 C클래스에서 전부 구현!, 구현의 약속!
//============================================
interface A{}
class B{}

//class C implements A extends B? 
// 얘는 에러가 발생함
//클래스와 인터페이스를 동시에 상속 할때에는 순서가 중요하다.
//클래스를 먼저 상속 받고 인터페이스는 나중에!
//implements가 먼저 나오면 컴파일러가 extends Object를 implements 키워드 앞에 추가해줌! 그래서 implements 가 두개가 되어버리는것... 에러!

class C extends B implements A // 로 해줘야 한다!
{

}

//============================================
interface A { void hello(); }
interface B { void hi(); }

interface C implements A,B {} 는 에러
interface C extends A,B {}
/*interface C extends A,B 
{
    void hello();
    void hi();

}
*/ //이렇게 기능을 가져오겠데...
//엥 이건 무슨 소리야?!
//A 안에는 hello(); 선언되어있음, hi();

//============================================
class A {void hello(){}}
interface B ㅁ A {} // 이런 경우는 절대 없다. 말이 안됨 extends는 내려준다라는 뜻인데 중괄호 있는 애를 어케 내려줌, 
// 주방을 물려받는 메뉴판은 없다.
  • mission

    package com.encore.$0415.misson;
    
    import java.io.IOException;
    
    /*
    * 기능정의
    * -단입력
    *    int inputDan ()
    * {
    *    int dan = read() 또는 readLine() 을 사용해서 받기 //그리고 단출력에 전달해야 함, return 타입 통해
    * }
    * 
    * -단출력
    *    void outputDan () 
    * {
    *    //전달받은 dan에 대한 출력
    * }
    * -계속여부
    *    char continueDan () 
    * {
    *    read() 또는 readLine()
    * }
    */
    
    public class Gugudan 
    {
    //public int dan;//=0
    //public char continuedan;//='\u0000'
    
    
    int inputDan() throws IOException
    {
        System.out.println("point");
        System.out.println("원하시는 단을 입력해주세요");
        int dan = System.in.read() - 48;
        System.in.read();
        System.in.read();
        return dan;
    
    }
    
    void outputDan(int dan)
    {
        System.out.println(dan + "단 구구단 출력");
        for (int i = 1; i <10; i++)
        {
            System.out.println(dan + "X" + i + " = " +  dan*i) ;
        }
    }
    
    char continueDan() throws IOException
    {
        System.out.println("계속하시겠습니까?");
        char continuedan = (char) (System.in.read());
        System.out.println(continuedan);
        System.in.read();
        System.in.read();
        return continuedan;
    
    }
    
    }
    
    
    //----------------
    
    package com.encore.$0415.misson;
    
    import java.io.IOException;
    
    /*
    * main() 포함
    * 반복적인 실행을 할 것(while 또는 do~while 사용 하면 됨)
    * 이번은 while로 해보자!
    * 반복문 내에서 Gugudan클래스 안에 3개의 메소드가 있는데 3개의 메소드들을 적당히 호출.
    */
    
    public class GugudanTest extends Gugudan
    {
    
    public static void main( String[] args) throws IOException
    {
        Gugudan g = new Gugudan(); 
    
    
        System.out.println("구구단");
    
        int dan = g.inputDan();
        g.outputDan(dan);
    
    //        
    //        g.inputDan();
    //        g.outputDan(dan);
    //        g.continueDan();
    //        
    
        while(g.continueDan() == 'y' )
        {
            dan = g.inputDan();
            g.outputDan(dan);
        }
            System.out.println("종료");
    }
    
    }
    
궁금상자
    - 패키지 이름 2개 이상 권장하는 이유?

    - jdbc

    - 어노테이션?

    - throw와 throws의 차이
        https://jhkim2017.wordpress.com/2017/04/24/java-throws%EC%99%80-throw%EC%9D%98-%EC%B0%A8%EC%9D%B4/
    - 자바 프로젝트 패키지 클래스 이해
        https://skyilcts.tistory.com/5
    - 패키지
        https://opentutorials.org/course/2517/14135
    - 인터패이스 패키지
        https://nittaku.tistory.com/46
        https://studymake.tistory.com/428
        https://opentutorials.org/module/2495/14142
    - 





190412 5일차 Escape Character,printf, OOP, 오버라이딩, 오버로딩, 생성자





class GugudanPrintTest2 

{

    public static void main(String[] args) 

    {

        System.out.println("Hello World!");

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

        { //반복문 for 규칙적인 수, 바깥for문 : 기준 (고정)

            for(int dan=2; dan < 10; dan++)

            {

                System.out.print( dan + " X " + i + " = " + (dan*i) + "   ");

                //공백(WhiteSpace) : 한개 이상의 스페이스(한칸), 탭(일정간격), 엔터의 조합

                System.out.println();

        } 



        /*

        <Escape Character> Escape Sequence

        -특수문자, 확장문자

        -기능을 갖는 확장된 문자

        -주의 : 인용부호내에서만 사용해야 함, 인용부호는 작은따옴표 큰따옴표를 말함

        \n : new line, Line Feed(LF), 줄바꿈

        \r : Carriage Return(CR), 커서의 위치를 맨 앞으로 이동.

        \t : Tab, 일정간격 띄우기

        \\ : '\'문자표현

        \" : 큰따옴표

        \' : 작은따옴표

        */

    }

    }



 

  •  



자바 OOP(Object Oriented Programming)



<객체지향의 특징>



 

    1. 캡슐화 : 필드와 메소드를 묶어주는 것



        • 정보은닉

      • 모듈성

 

    1. 상속 ★



        • 부모가 갖는 자원( 필드, 메소드 )을 아낌없이 물려주는 것


        • 관련 키워드



          • extends


          예시



          class My extends 상속받고싶은 부모클래스명
          
          {
          
             //extends 는 is a 관계를 갖는다.
          
          }


          class Parent extends Object //import java.Object 과 같음 , 컴파일러가 자동 추가
          
          {
          
          
          
          }
          
          
          
          class Child exdends Parent
          
          {
          
          
          
          }
          
          /* 
          
          질문)
          
          Parent p = new Child();
          
          Child c = new Parent();
          
          이렇게 하려면, 에러가 발생하고 하나는 실행되는데 그건 
          
          Parent p = new Child();
          
          자식은 부모다, 자식은 언제든 부모가 될 수 있다, 하지만 부모는 자식이 될 수 없다.
          
          자바의 자식은 불효자!, 
          
          
          
          
          
          */

        • 단일상속이 기본 원칙.


      • API문서( Application Programming Interface )



        =>>



        java.lang.Object   //부모클래스, 상위 클래스 super class



        |



        +– java.lang.String     //자식클래스, 하위 클래스, sub class



        ※Object 클래스 =>> 최상위 클래스

 

    1. 다형성 ★★



        • 메소드 오버라이딩(MethodOverriding) ★★ =>> 메소드 재정의



          부모가 갖는 메소드를 울타리처럼 가져오는게 상속인데 그걸 자식이 재정의 할 때




          혹은 기존기능은 그대로 덧붙이는것


          상속에서 나온 개념, 상속과 연관




          부모가 갖는 메소드를 자식클래스에서 재정의



      • 메소드 오버로딩


        동일한 하나의 클래스에 동일한 이름의 메소드를 여러개 구현 




        ​  ( 단, 인자의 갯수가 다르거나 자료형이 달라야 한다.)



        매개변수의 개수 또는 타입이 달라야 한다.



        매개변수는 같고 리턴타입이 다르다고 오버로딩이 성립하지 않는다.



        class A
        
        {
        
         void hello() 
        
         {
        
        
        
         }
        
         void hello()
        
         {
        
            //에러 발생
        
         }
        
        }


        class A
        
        {
        
         void hello() 
        
         {
        
            System.out.println("안녕")
        
         }
        
         void hello(String name)
        
         {
        
            System.out.println("안녕," + name + " !! ")
        
              //인자 name을 쓰기 때문에 사용 가능!
        
         }
        
        }


        class Parent // extens Object가 생략된것
        
        {
        
         int x = 100;
        
         void hello()
        
         {
        
        
        
         }
        
        }
        
        class Child extends Parent
        
        {
        
         int y = 200;
        
         void goodbye()
        
         {
        
        
        
         }
        
        }
        
        
        
        /*
        
        1. Parent p = new Parent(); //new 는 동적 메모리 할당
        
        new가 Parent(); 오른쪽으로 감 , p는 Parent 왼쪽으로 감
        
        메모리 : 페어런트, 오브젝트
        
        2. Child c = new Child();
        
        child(); 에 new로 메모리 할당
        
        c는 chile에 대해서 참조
        
        메모리 : 차일드, 페어런트, 오브젝트 
        
        3. Parent p2 = new Child(); 
        
        또는 Parent p2 = c; // c는 2번에 있던 c , 위 아래는 같은 식이다.
        
        
        
        int su = 33;
        
        A a = new A();
        
        a. hello(); // 이거랑
        
        new A().hello(); //는 같은것임
        
        하지만 이렇게 같은데 다르게 쓰는 이유는 new는 계속 메모리를 할당하기 때문에 2번이상 나온다면 a. 을 사용하는게 더 좋음
        
        
        
        Parent p2 = new Child();
        
        앞뒤로 달랐을때
        
        p2 는 parent 참조, new는 메모리 할당
        
        
        
        p2.hello(); 는 parent 참조하기에 에러 안남
        
        p2.toString(); 도 Object에 있기에 에러 안남
        
        p2.goodBye(); 는 에러, 메모리는 할당되어있으나 참조가 Parent로 되어 있기에...
        
        
        
        부모 참조 변수를 통해 자식 호출 불가!
        
        반대로 자식 참조 변수를 통해 부모 호출 가능!(메소드 호출말하는 것)
        
        
        
        4. Child c2 = new Parent(); // 부자는 가능하지만 자부는 안된다!
        
        new Parent 하면 메모리에는 Object와 Parent가 할당 되는데 Child를 참조한다고?! 메모리에 없어 에러!
        
        
        
        Child c2 = p2; //에러
        
        Child c2 = (Child)p2; //는 에러 아님, 캐스팅(형변환)
        
        
        
        Child c3 = (Child)new Parent(); //컴파일때는 에러 안나지만 실행할때 에러
        
        부 = 자 아니면 안된다 대부분...
        
        */
        
        
        
        class Parent // extens Object가 생략된것
        
        {
        
         int x = 100;
        
         void hello()
        
         {
        
                System.out.println("신짜오");
        
         }
        
        }
        
        class Child extends Parent
        
        {
        
         int y = 200;
        
         void goodbye()
        
         {
        
            void hello()
        
             {
        
                System.out.println("신짜오");
        
             }
        
         }
        
        }
        
        /*
        
        p2.hello() 실행하면 신짜오가 실행된다. 
        
        오버라이딩 메소드만 자식클래스 메소드 호출 가능!
        
        무조건 위를 참조하지만 오직 오버라이딩만! 자식클래스 메소드를 호출한다.
        
        다형성!
        
        */


        //컴파일러가 import java.lang.*; 추가
        
        
        
        class Parent // extends Object 추가
        
        {
        
        int i = 11;
        
        void hello()
        
        {
        
            System.out.println("부모 안녕!");
        
        }
        
        void print()
        
        {
        
            System.out.println("부모 프린트~!");
        
        }
        
        void hello(String name) // ----> ? 오버로딩 메소드 ( 메소드명 같고 인자의 갯수 또는 자료형이 다른것)
        
        {
        
            System.out.println("부모 안녕! 스트링" + name);
        
        }
        
        void print(int age)
        
        {
        
            System.out.println("부모 안녕! 인트" + age );
        
        }
        
        
        
        }
        
        
        
        class Child extends Parent
        
        { // is a 관계 =>> 자식은 부모다!
        
        //         =>> 자식클래스는 부모클래스로 형변환이 가능하다!!
        
        int j = 22;
        
        
        
        void goodbye()
        
        {
        
            System.out.println("자식 안녕히가세요");
        
        }
        
        
        
        void print() //오버라이딩
        
        {
        
            System.out.println("자식 프린트~!");
        
        }
        
        }
        
        
        
        class InheritanceTest 
        
        {
        
        public static void main(String[] args) 
        
        {
        
            Parent p = new Parent(); //메모리 할당 : O P 
        
                            //참조별수                  p
        
            Child c = new Child();
        
            System.out.println( " j " + c.j);
        
            //부모            자식
        
            //Parent p = new Child(); //에러발생, 호환이 되지 않는 자료형, 변환할수 없습니다 에러 => extends Parent
        
            //---       ----------
        
            //기준        변환가능한지 여부?
        
        
        
            //c.abc();  에러 child, parent, Object 클래스에 순차적으로 확인후 존재하지 않기 때문에 에러
        
            c.toString(); // Object클래스에 toString(); 메소드가 정의 되어 이씩에 에러 발생 안함.
        
        
        
            System.out.println( "=================" );
        
        
        
        
        
            //자기 자신의 자원 호출
        
            p.hello();
        
            System.out.println( "=================" );
        
        
        
            //p.print();
        
            //p.goodbye(); 에러발생
        
            //기본 : 부모참조변수(p)를 통해 자식 접근 불가능! but 오버라이딩 했다면 접근 가능 오직 이것만!
        
        
        
            System.out.println( "=================" );
        
        
        
            Parent p2 = new Child(); // 메모리 할당 : O   P   C
        
            //----      -----------     //참조 변수 :     p2
        
            //기준        변환 가능 여부?
        
        
        
            p2.hello();
        
            p2.print(); // 기본원칙 : 부모참조 통해 자식 호출 불가!
        
                        // ★ 예외! 오버라이딩의 메소드의 경우에는 호출 가능~
        
                        //      =>> 정확히
        
                        //      =>> 오버라이딩 메소드가 존재한다면, 부모의 메소드는 은폐되고 자식의 메소드로 대체된다.
        
            System.out.print( p2.i); // i는 변수임으로 그냥 부모 변수 가져감, 오버라이딩은 오직 메소드에 대한 것임.
        
        
        
        }
        
        }
        
        

 





<생성자>  Constructor



 

    • 새로운 객체를 생성하기 위해서 초기화해주는 메소드



        1. 생성자의 이름은 반드시 클래스명과 일치( 대소문자 일치 )

        1. 리턴자료형을 명시하지 않는다. (void조차 명시하면 안된다.) 

          • 1번, 2번이 일반 메소드와의 차이점

        1. 객체 생성시 자동으로 호출

      1. 클래스내에 생성자가 하나도 없다면 자바컴파일러가 컴파일시 ( 기본생성자를 )자동으로 추가.

 



※주의 ) 만약, 클래스내에 한개 이상의 생성자가 정의 되어 있다면 컴파일러는 소스코드에 관여하지 않는다.





class Abc

{

    int su;

    My my;



    Abc( ) //기본생성자(매개변수 비어있는 생성자);  이름 클래스와 일치, 자료형 리턴자료형 없어야 한다. 

    {

        //=>>초기화 (값 할당) 메소드

        // 멤버작업에 대한 초기화 작업

        su = 10;

        my = new My();



        //(일반메소드 호출 전 1번 실행 하야 하는) 선행작업은 여기에 넣기.



    }//생성자



    Abc( ) //또 메소드 같은거 쓰면 에러

    {    

    }



    Abc( String name ) //오버로딩 생성자

    { 

    }



    ABc( int age ) //컴파일 에러 발생 : 클래스명과 일치하지 않으므로 일반메소드!, 리턴자료형을 명시하지 않았음! 이라고 에러가 남

    {



    }



    void hello()

    {



    } 

}/*class Abc();

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

    Abc a = new Abc( );

    a.hello(); 기본 생성자 호출

    */

    a.hello();

    /*

    Abc a2 = new Abc( "길동" )

    ====== 오버로딩 생성자 호출!

    */

a2.hello();





class Abc

{

    int su; //멤버변수(필드) - 여러 메소드가 공유할 데이터를 표현, 기본값이 존재 O

            //기본값 =>> 정수:0 실수:0.0 논리:false 클래스:null



    Abc() //기본생성자

    {

        System.out.println("Abc기본생성자"); //먼저 시작됨!

    }



    Abc(String name)

    {

        System.out.println( "Abc오버로딩생성자" );

    }

    void hello()

    {

        int min; //지역변수 - 현재 메소드에서만 사용할 데이터를 표현, 기본값이 존재 X

            //min = 0; 지역변수는 반드시 초기화 해서 사용!

        System.out.println( "초콜릿 안녕" );

    }

} //class Abc



class ConstructorTest 

{

    public static void main(String[] args) 

    {

        Abc a = new Abc();

        // 1. 메모리 할당 2. 생성자 호출

        a.hello();

        System.out.println( "" ) ;      

    }

}



//하지만 우리가 생성자 만드는 일은 드물다, 하지만 생성자를 알아야 그것에 많게 객체생성을 할 수 있기에 우리는 배웠다.





궁금상자 

- 한개의 글자가 스페이스 한칸을 의미하는가?...

    구구단할때 스페이스로 했지만, 다른것에서는 문자 숫자 합쳐 나올텐데...

    그리고 의아한게 \t은 스페이스 4칸인데 한자리수 뒤도 4칸 두자리수 뒤도 4칸이면 라인이 깨져야 하는거 아닌가?



- print println printf 밖에도 다른?! printf 에서 f의 의미

    printf 의 f의 의미는 format string 이다. 서식화된 출력이라는 뜻







- 오버로딩은 if같은거 아닌가? 인수가 들어오면, 인수 포함된 메소드 들어오고 아니면 인수 없는 메소드 시작하고

    오버로딩 사용 하지 않으면, 이름 다 제각각 지어줘야 하고(int일때, float일때, double일때), 메소드명만 봤을때 메소드들이 같은 기능을 하는지 모를 수 있다. 하지만 오버로딩 사용하면 메소드 이름이 같으니 같은 기능이구나! 알 수 있고 이름도 안지어도 된다!

    https://java.ihoney.pe.kr/99



- Parameter(인자, 매개변수), Argument(인수)

    Parameter는 함수 선언에 사용되는 입력 변수

    Argument는 함수 호출에 사용하는 입력 변수



- 자바의 인자와 매개 변수의 차이점

    인자는 함수를 호출할때 값을 전달하는 것 1, 2, 5 int func(b)의 b처럼

    매개변수는 함수 내에서 전달 된 값을 받아 들이는 변수 int a나 int b처럼

    https://yangyag.tistory.com/24



    선생님께 인자 인수 매개변수를 다시 한번 여쭤보자



- 오버로딩에서 hello(int a){} hello(int b){} 가능한가?인자의 갯수도 같고, 타입도 같은데?

    응 안됨, 인자 갯수가 다르거나 타입이 달라야 한다.

19044_4일차 자바의 입력,

자바의 입력

  • 프로그램 실행 도중 필요한 시점에 데이터를 입력받는 것.

  • 왜 필요할까?! => 변경되는 데이터를 소스프로그램 없이 외부에서 전달하기 위해 사용.

    (학점 구하기, 성별 구하기 등등…)

    1. byte 단위 입력

      • 숫자입력
      /*
      System.in.read();
      <hr />
      
      System.in : 표준입력 => 키보드 입력
      */
      int su = System.in.read() - 48;
      /*
      -48을 하지 않으면?
      int su =  System.in.read();
      키보드 입력     프로그램에서 받는 값
      0                   48
      1                   49
      5                   53
      
      이렇게 48이 더해져서 나온다...
      */
      • 문자입력
      /*
      (char)System.in.read();
      <hr />
      
      (char)를 앞에 붙여준다.
      키보드 입력     프로그램에서 받는 값
      a                   97
      b                   98
      A                   65
      9                   57
      
      자료형 = (기본자료형, 참조(클래스,사용자정의)자료형)
      (자료형)데이터
      <hr />
      
      캐스팅(casting) 연산자 : 형변환연산자!
      */
      int su = 300; double d = 3.14; 
      
      int su2 = 3.14; // 에러? => 발생
      su2 = (int)3.14; //3.14데이터를 int로 형변환 하겠음. 변환하고 나머지값을 버려버리겠다라고 명시하는 것.
      System.out.println(su2); // 3 나옴
      
      double d2 = 300; //에러? => 이상없음, 자동형변환 
      System.out.println(d2); // 300.0
      
      
      System.out.println(97); ==> 97 출력
      System.out.println( ( char ) 97 ); // 결과 a
      char ch = (char)System.in.read();
      */
      /*exception 에러 (unhandled, unreported)
      InputTest.java:9: error: unreported exception IOException; must be caught or declared to be thrown
      예외처리 해달랬는데 안했어, 방법은?
      */
      public static void main(String[] args) throws Exception
      //예외처리 하기
      
      class InputTest 
      {
      public static void main(String[] args) throws Exception 
      {
          System.out.println( "프로그램 실행도중 입력테스트 !" );
          System.out.println( 97 );
          System.out.println( ( char ) 97 );
      
          System.out.print( "한자리 수를 입력 : " );
          int su = System.in.read() - 48; // 입력받는 시점
          // 다시 3을 입력받고 싶다면 애래처럼 13 과 10처리 하기
          /*
              System.in.read();
              System.in.read();
          */
          System.out.print( "동일한 수를 다시 입력 : " );
          int su2 = System.in.read();
          int su3 = System.in.read();
      
          System.out.println( "당신이 입력한 값은 su = " + su + "아스키 코드는" + su2 );
          System.out.println( "10 나오나? = " + su3 );
      
          System.out.println( "===end===" );
      }
      }
      //엥? 왜 아스키코드는 13이 나오지? 3 입력하고 엔터를 입력해서 엔터의 아스키코드는 13임.
      //키보드 : 3   엔터
      //컴퓨터 : 51 13(CR) 10(LF)
      /*
      문제) 아래와 같이 실행하는 프로그램을 작성하시오(for문 사용)
      [실행결과]
      
      <3단>
      3 * 1 = 3
      ...
      3 * 9 = 27
      */
      
      class GugudanTest 
      {
      public static void main(String[] args) 
      {
          System.out.println( "<3단>" );
          for(int i = 1; i < 10; i++)
          {
              System.out.println( " 3 * " + i + " = " + ( 3 * i ) );
          }
      }
      }
      //미션 구구단!
      class GugudanTest 
      {
      public static void main(String[] args) 
      {
          for(int dan = 3; dan < 6; dan++)
          {
              System.out.println( "<" + dan + "단>" );
      
              for(int i = 1; i < 10; i++)
              {
                  System.out.println(  dan + " X " + i + " = " + ( 3 * i ) );
              }
      
              System.out.println( "\t" );
          }
      }
      }
      
      class GugudanTest4 
      {
      public static void main(String[] args) throws Exception
      {
          System.out.print( "시작단을 입력하세요 : " );
          int start = System.in.read() - 48;
          System.in.read();
          System.in.read();
          System.out.print( "끝단을 입력하세요 : " );
          int end = System.in.read() - 48;
          end++;
      
          for(int dan = start; dan < end; dan++)
          {
              System.out.println( "<" + dan + "단>" );
      
              for(int i = 1; i < 10; i++)
              {
                  System.out.println(  dan + " X " + i + " = " + ( 3 * i ) );
              }
      
              System.out.println( "\t" );
          }
      }
      }
    2. 라인단위 입력

    - 객체생성
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    
    - 문자열 입력
    String str = in.readLine(); // a b c d 엔터 ---> "abcd"
                            // 1 2 3 4 엔터 ---> "1234"
    str + 300 ? 1534(X) , "1234300"(이렇게 나옴)
    
    - 숫자입력 ( 위에서 입력된 값에 대해 사칙연산을 하고 싶다! )
    "" 큰 따옴표를 제거하자 ( 많이 쓰는 기능 )
    Integer.parseInt( str ) ; // parseInt();는 숫자로 구성된 문자열을 숫자로 변환하는 기능을 갖는다.
    su + 300 ? 1534 (0) 
    Integer.parseInt( "123" ); // 결과값 123
    import java.lang.*; //기본패키지 =>> 컴파일러가 자동으로 추가시켜줌! *=  모든것, 와일드카드가 뭐야?
    
    import java.io.BufferedReader;
    import java.io.InputStreamReader;
        // 사용하겠음, 사용하고자 하는 클래스의 소속( 폴더 , 패키지 )를 알려주는 역할
       //형식) import 패키지명.클래스명;
       // 근데 왜 String은 그냥씀? =>> 자주 쓰는 기능들은 임포트하기 넘나 귀찮, 자바 기본패키지에 모아둠
    
    class LineInputTest 
    {
    public static void main(String[] args) throws Exception
    {
        BufferedReader in = new BufferedReader( new InputStreamReader( System.in) );
    
        System.out.println( "숫자를 입력? " );
        String str = in.readLine(); // 입력시점
        System.out.println( "STR = " + str );
        System.out.println( str + 500 ); // 123500
    
    
        //숫자문자열 ---- 변환 ----> 숫자 "123" ----> 123 ( 큰따옴표 제거 ) : parseInt( 숫자문자열 )
        int su = Integer.parseInt( str ); // Integer.parseInt("123") ---> 123
        System.out.println( su + 500 ); // 123 + 500 =>> 623
    
    
    
        /*
            <자바 I/O의 4대 클래스>
                        ㅣ       읽기      ㅣ   쓰기
                =======================================
                byte단위  ㅣ   InputStream ㅣ   OutputStream
                문자단위    ㅣ   Reader      ㅣ   Write
    
                클래스 모아둔것 = 패키지 , 윈도우 폴더처럼 
        */
    
    }
    }
    import java.util.Calendar;
    import java.io.BufferedReader;
    import java.io.InputStreamReader;
    
    class JuminBunhoTest 
    {
    public static void main(String[] args) throws Exception
    {
        //주민번호를 입력받아 화면에 나이를 출력하기!! (readLine()메소드사용)
        //"920306-1012345"
        // =>> 전체문자열에서 "92"만 추출하기 : String
    
        //나이계산하기?       92라는 숫자를 가져왓, 2019 - ( 1900 + 92 ) + 1
        //자바 날짜 관련된 클래스 : 대표적 2가지 Date, Calendar Date는 별로 잘 안씀
    
        Calendar cal = Calendar.getInstance(); //객체를 Instance, Object를 사용하는데 특정 클래스 하나를 표현할땐 Instance를 사용함
        //cal 변수안에 현 시스템의 모든 날짜관련정보가 저장됨.
        //cal.get( 얻고자 하는 세부정보);
        //java 사용 설명서 https://www.oracle.com/technetwork/java/api-141528.html
        //https://docs.oracle.com/javase/8/docs/api/
    
        int year = cal.get( Calendar.YEAR );
        System.out.println( "year = " + year );
    
        BufferedReader in = new BufferedReader( new InputStreamReader( System.in) );
        String id = in.readLine(); // "931025-2011111"
                            //인덱스     012345-
        String birthYear = id.substring( 0, 2 ); //"92"
    
        System.out.println(birthYear);
        int age = year - ( 1900 + Integer.parseInt( birthYear ) ) + 1;
    
        System.out.println( "당신의 나이는 " + age );
    }
    }
궁금상자
1. 왜 키보드 숫자 입력받을때 -48? 왜?... 2진코드 머시기 알아보자
    - 아스키코드때문, 아스키코드 공부 하기!
    https://commin.tistory.com/41

2. 키보드 숫자 입력 받을 때, int -48이지만 short byte도? 다를거 같은데

3. 자바의 유명한 에러 뭐가 있을까?!

4. 입력 read(); 와 Scanner 의 차이?!

5. 자바 와일드카드가 무엇?!

6. import 시 특정 클래스 기재 안하고 * 해버리면 안됨?

190410_3일차 조건문 이어서, 반복문

조건문

  1. if문

    • 형식 : if(조건식) // boolean 데이터!

      {

      ​ boolean데이터! //조건식의 결과가 참일때 실행할 문장;

      }

      class D
      {
      void hello( int su ) //int su = 1
      {
          if( su == 1 )
          {
          System.out.println( "안녕" );
          }
          if( su == 2 )
          {
          System.out.println( "신짜오" );
          }
          if( su == 3 )
          System.out.println( "Hello" );
      }
      }
      class IfTest 
      {
      public static void main(String[] args) 
      {
          D d = new D();
          int num = 2;
          d.hello( num );
      }
      }
  2. if~else문

    • 형식
    if(조건식)
    {
       //조건식의 결과가 참일때 실행할 문장;
    }else
    {
       //조건식의 결과가 거짓일때 실행할 문장;
    }
    • 주의

      else는 홀로 사용이 불가!!

      반드시 if(){} 이후에 입력되어야 함.

  3. switch~case문 (다중택일 조건문)

    • 형식
    switch(기준데이터)
    {
       case 비교데이터1 : 실행할문장1;
       case 비교데이터2 : 실행할문장2;
       case 비교데이터3 : 실행할문장3;
    }
    
    class SwitchTest
    {
    public static void main(String[] args) 
    {
        int su = 55;
        switch( su )
        {
            case 1 : System.out.println( "하이" );
                    break;
            case 2 : 
                    System.out.println( "신짜오" );
                    break;
            case 3 : System.out.println( "안녕" );
                    break;
            default : // 일치하는 값이 없을때, 실행 문장 표현
                    System.out.println( "잘못된 입력입니다." ); 
        }
    }
    }
    class SwitchTest
    {
    public static void main(String[] args) 
    {
        int jumsu = 105;
        int su = jumsu/10;
        switch (su)
        {
        case 10 : 
        case 9 : System.out.println( "A학점" );
                        break;
        case 8 : System.out.println( "B학점" );
                        break;
        case 7 : System.out.println( "C학점" );
                        break;
        case 6: System.out.println( "D학점" );
                        break;
        default : System.out.println( "F학점." );
        }
    }
    }
    • java의 제어문 break와 continue가 있다.

    • break가 없다면 switch입력값에 해당하는 명령부터 끝까지 실행해버린다.

    • 제어문 break!! (수식의 데이터 값 : 정수(byte, short, int), … )

      • switch블럭, 반복문 블럭 내에서 사용.
      • break를 감싸는 불럭을 벗어나는 역할.
  4. if~else if~else문

    • 서로 연결된 조건식을 표현할 때 사용, 필터링, 수의 범위표현
    • 형식
    if( 조건식 )
    {
       //조건식1이 참일때 실행할 문장;
    }
    else if( 조건식2 )
    {
       //조건식1이 거짓이고, 조건식2가 참일때 실행할 문장;
    }
    else if( 조건식3 )
    {
       //조건식1,2가 거짓이고 조건식3이 참일때 실행할 문장;
    }else
    {
       //조건식1,2,3이 차례대로 거짓일때, 실행할 문장;
    }
class 클래스명
{
    //변수선언
    int su;
    boolean flag;
    double d;

    String str;
    A obj;

    //메소드 정의
    리턴형 메소드명( )
    {
        // 변수선언 int min;
        // 변수초기화 su = 300; min = 0;
        // 메소드호출 System.out.println("안녕");
        // 조건문 if(조건식) { }
        // 반복문
        6;
        for( ) {7;}
        8;
        9;
    } //메소드
} //클래스

<반복문> Loop

  1. for문

    • 일정횟수 반복할 때 사용
    • 규칙적인 수를 표현할 때 사용
    • 배열의 인덱스를 표현할 때 사용

    [형식]

    for( 초기화; 조건식; 증감연산자 )
    {
    //반복적으로 실행할 문장;
    }
    
    =>> 실행순서)
        초기화 -> 조건식 -> 실행문 ->증감연산자
              -> 조건식 -> 실행문 ->증감연산자
              -> 조건식 -> 실행문 ->증감연산자
              -> false -> for문 탈출!
    
    for(int i = 0; i < 5; i++)
    {
    System.out.println( "안녕" )    
    }
    
    class ForTestTest 
    {
    public static void main(String[] args) 
    {
        A a = new A();
    
        a.one(0);
        a.two(0);
        a.three(0);
        a.four(0);
        a.five(0);
    }
    }
    
    class A
    {
    void one( int i )
    {
        for( i = 1; i < 6; i++)
        {
            System.out.println(i);
        }
        System.out.println("=====");
    }
    
    void two( int i )
    {
        for( i = 1; i < 6; i++)
        {
            System.out.print( i + " " );
        }
        System.out.println();
        System.out.println("=====");
    }
    
    void three( int i )
    {
        for( i = 5; i > 0; i--)
        {
            System.out.print(i+ " ");
        }
        System.out.println();
        System.out.println("=====");
    }
    
    void four( int i )
    {
        for( i = 3; i < 13; i+=3)
        {
            System.out.print(i+ " ");
        }
        System.out.println();
        System.out.println("=====");
    }
    
    void five( int i )
    {
        System.out.print("[");
        for( i = 5; i <= 20; i+=5)
        {           
                System.out.print( " " + i );
    
                if(i<16)
                    System.out.print(",");
        }
        System.out.print(" ]");
    }
    }
  2. while문

    • 조건이 참인동안 반복실행

    • 조건이 만족되지 않는다면 한번도 실행되지 않을 수 있고 조건이 만족된다면 언제든 쓰일 수 있다.

    • 실행횟수 0 ~ 무한대 (if문의 경우 0또는 1)

    • 반복되는 횟수가 일정치 않을 때 사용

    • 서버의 리스너를 표현할때 =>> 무한 반복할 때

    • 형식

      while(조건식)
      {
       //조건식의 결과가 참인 동안 
      }
      class WhileTest
      {
      public static void main (String[] args)
      {
          int i = 1;
          int sum = 0;
          while(i < 11) //무한 루프, 반복
          {
              sum+=i;
              i++;
      
          }
          System.out.println("1부터 10까지 더한 값은 " + sum);
          }
      }
  3. do ~ while문

    • while문과 동일

    • 차이점 : 조건식의 결과와 상관 없이 무조건 한번은 실행한다, 실행횟수 : 1 ~ 무한대

    • [형식]

      do
      {
      반복실행할 문장
      }while(조건식); //세미콜론 무조건 달아줘야 한다 주의할 것!!!!!!!!!!!!!!!!
      
      class DoWhileTest 
      {
      public static void main(String[] args) 
      {
          //문제) "Hello World"를 화면에 3번 출력하시오.(단, do~while이라는 반복문을 사용)
      
          boolean flag = true;
      
          int count = 1;
          do
          {
              System.out.println("진푸 풍덩~!");
          //벗어날 수 있는 방법 두가지 여기서는 flag를 false로 바꿔주거나 break;
              if(count++ == 3)
              {
                  break; //flag = false;
              }
          }
          while (flag);
      
          //1부터 10까지의 합을 출력하시오 (do~while사용)
          int su = 1, sum = 0;
      
          do
          {
              sum += su;
              if(su < 10)
              {
                  su++;
                  continue;
              }
              flag = false;
          }while (flag);
          System.out.println(sum);
      }
      }
      
      //예시가 좋은 문제는 아니다.

<제어문>

  1. break문
    • switch블럭 또는 loop블럭(for, while, do~while)내에서 사용하며 해당 영역을 빠져나가는 역할.
    • 사용 : break;
  2. continue문
    • 반드시 loop영역내에서만 사용
    • loop영역의 끝괄호 역할
    • for : 증감자 => 조건식
    • while : 조건식
    • do~while : 조건식
    • 사용 : continue;
나의 궁금점 Q!
- if, else할때 실행문이 한줄일 때 영역괄호(스코프) 하는게 좋을까 안하는게 좋을까?
    검색 안됨, 모르겠다, 근데 하는게 좋지 않을까? 한줄짜리 긴 코드를 스코프 안에 넣어놔야 나중에 좋을거 같다는 막연한 생각이 든다.

- 변수 % 2 == 0이 좋을까 변수 % 2 != 1 이 좋을까?
    https://ict-nroo.tistory.com/11
    위의 링크의 글을 참조하니 위의 방법보다는 변수&1 = 1이면 홀수, 0이면 짝수의 방식이 더    빠르고 좋은 방식이라고 생각된다.
- case 뒤에는 상수만 들어갈 수 있다! 상수만 들어간다면 문제가 없다.
    final int j = 4; //변수면 에러남, 반드시 상수
    switch(i)
        case j :

- break마지막에 안해도 되지만 메모리 리소스 먹는거 아닌가?!
    리소스를 더 먹는 등의 문제는 없는거 같은데 유지보수 측면에서 나중에 추가할수도 있으니 웬만하면 추가 하는게 좋은것 같다.
https://stackoverflow.com/questions/2729813/switch-statements-do-you-need-the-last-break-javascript-mainly

- case문에 long은 왜 안될까?
    자바8 버전부터 String은 된다!
- case문에 조건에는 뭐가 들어갈 수 있을까?
    byte, short, int 확인 완료 short은 안된다.
- if문과 switch문 속도와 효율은?
    조건문이 4개 이하이면 if, else if가 좋지만
    조건은이 5개 이상이라면 switch case문이 더 효율이 좋다.
- for문 안에 if while문 안에 if 등 중첩시 문제?! 효율?!
    중첩되면 좋을리는 없다, 연산횟수의 증가로 효율을 감소시키고 에일리언코드가 되버릴 수 있다.
- 반복조건에 
- do~while에 대해서 어떤경우에 유용한지
    do while은 어셈블리 언어로 변환하면 forwhile보다 jump연산이 1개 적게 쓰여서 조금 빠르다고 함. 하지만 do while의 경우 하단에 조건이 위치되어 있어서 가독성이 안좋아서 논리를 꼬아버릴수도 있음.최초 1회 보장하려고 굳이 써야 할지는 모르겠음.

+ Recent posts