java 실습

ex>> Ex1.java

public class Ex1 {
    public static void main(String[] args) {
        System.out.println("go for it!");
    }
}


ex>> Ex2.java
public class Ex2 {
    public static void main(String[] args) {
        boolean var1; //지역변수 선언 boolean형
        //위의 var1변수에 대입할 수 있는 값은 true, false 다.
        //논리값. 다른 기본 유형에서 형 변환 불가. C/C++과 혼동하지 말기.  true나 false가 정수값인 1과 0으로 변환될 수 없음.

        var1 = true;

        //정수의 자료형은 byte < short < int < long 순으로 있다.
        // byte는 -128 ~ 127 까지만 쓸 수 있다.
        byte var2 = 127;
        short var3 = 10;
       
        //short var4 = 137;
        //short var4 = var2 + var3 ; // 자바에서는 32비트 이하의
        //자료형들이 연산을 하게 되면 자료형들 또한
        //연산이 되어 32비트 체제로 승격(Promotion)한다. (==>int 로)
        //승격(Promotion)으로 수정하면 다음과 같다.
        int var5= var2 + var3;

        //위의 내용을 다시 감등(demotion)으로 수정하면..
        short var6 = (short)(var2 + var3);

        float var7 = 3.4f; // 자바에서 소수점을 가지는 자원들은 기본이
        //double로 인식하므로 float형으로 지정할 때는 반드시 자원뒤에 알파벳 f
        //를 붙여야 한다.(대/소 구분없음)
      }
    }




ex>> Ex3.java
public class Ex3 {
    public static void main(String[] args) {
        //연산자
        // - 산술 : + , - , / , * , %(나머지 값 구하기)
        int var1 = 10;
        int var2 = 4;
        int var3 = var1%var2; // 결과값 2
        System.out.println("var3 = "+var3);  //자바에서 + 연산자는
        //산술 연산자이기도 하지만 피 연산자들 중
        //문자열이 있을 경우 나머지 피 연산자가 문자열로 변경된 후
        //문자열과 문자열을 "연결"하라는 "문자열 연결 연산자"가 된다.
       
        // - 대입 : = , += , -=, /= , *= , %=
        //int var4 = var1 + var2; //var2의 값의 변화가 없다.
        var2 += var1; //var2 = var2 + var1; //var2의 값에 var1의 값을 더하여 var2의 값이 변화를 가져왔다.
       
       
        // - 비교(조건) 왼쪽항이 기준이된다.
        // == : 같다.
        // >= : 크거나 같다.
        // <= : 작거나 같다.
        // != : 같지 않다.
        System.out.println("var1 >= var2 : "+(var1 >= var2));
        System.out.println("var1 != var2 : "+(var1 != var2));

        // - 증감 : ++, --
        ++var1; //var1의 값이 1 증가 11
        var1++; //var1의 값이 1 증가 (단독으로 쓰일때는 같은 결과) 12
        int var4 = ++var1 + var2++; //결과는 13 + 14 ==> 27
        // var4 = 27 , var2 = 15
        System.out.println("var4 = "+var4);
        System.out.println("var1 = "+var1);
        System.out.println("var2 = "+var2);

        // - 논리 : && (그리고), || (또는)
        boolean var5 = ++var1 > var2 && ++var2 > var1;
        // 변수값   true 14   > 15  &&  15 > 14 ; // && 연산자는 앞의 결과가 true 라야
        // 뒤의 연산자를 수행한다. 앞의 결과가 false이면 뒤의 연산자는 수행하지 않는다.
        System.out.println("var5 = "+var5);//
        System.out.println("var2 = "+var2); // 증감연산자를 수행하지 못했다.
        //이유는 &&연산자는 모든 조건이 true여야 true를 반환할 수 있다. 그런데 첫번째
        //조건에서 부터 false가 발생하여 &&연산자 뒤에 있는 두 번째 연산을 수행하지 못한 것이다.
        System.out.println("var1 = "+var1);//

        boolean var6 = ++var1 > var2 || ++var2 > var1 || var1-- != --var2;
        System.out.println("var6 = "+var6);  //true
        System.out.println("var2 = "+var2);  // 16
        System.out.println("var1 = "+var1);  // 15

    }

}

ex>> ForTest4.java
public class ForTest4 {
    public static void main(String[] args) {
        /*
         *  for문은 반복문이며 구성은 다음과 같다.
         *  구성)
         *      for( 초기식 ; 조건식 ; 증감식 )
         *          처리문;
         *
         * 초기식은 for문 처음에만 수행.
         *
         *  그럼 1부터 10까지 출력해보자!
         */
        for(int i=0; i<10; i++)     // i++은 ++i해도 무관(다른 연산자 없으므로)
            System.out.println("i : " + (i+1));
        //  System.out.println("i : " + i+1);
        //  이렇게하면 01 11  12 .... 출력된다.(연산자 우선순위)
        //  초기식 int i는 for문 안에서만 사용가능.(scope)
        //  즉, for문이 끝나면 메모리에서 소멸~
    }
}








ex>> ForTest5.java
public class ForTest5 {
    public static void main(String[] args) {
        /*
         *  1부터 20까지의 수들 중 3의 배수들만 출력하여라!
         */
        for(int i=1 ; i<=20 ; i++)
            if(i%3 == 0)
                System.out.println(i);
        for(int i=3 ; i<=20 ; i+=3)
            System.out.println(i);
    }
}





ex>> ForTest7.java
public class ForTest7 {
    public static void main(String[] args) {
        /*
         * 중첩 반복문
         * 1 2 3 4 5 6 7 8 9 10
         * 1 2 3 4 5 6 7 8 9 10
         * 1 2 3 4 5 6 7 8 9 10
         * 출력
         */
        for(int k=0 ; k<3 ; k++){
            for(int i=1 ; i<11 ; i++)
                System.out.print(i + " ");
            System.out.println();
        }
    }
}






ex>> ForTest8.java
public class ForTest8 {
    public static void main(String[] args) {
        /*
         * 구구단 찍어라!
         * 2*1  3*1  4*1 5*1 .....
         * 2*2  3*2 ...
         * 2*3 ...
         * ...
         */
        for(int i=1; i<10 ; i++){
            for(int j=2; j<10 ; j++){
                System.out.print(j + " * " + i + " = " + (j*i) + "\t");
            }
            System.out.println();
        }
    }

}










ex>> IfTest1.java
/* 제어문 */
// - 분기문 : if문
//          : switch문
// - 반목문 : for문
//          : while문
//          : do~while문
// - continue : 반복문에 많이 사용
// - break : 반복문에 많이 사용

/* if문 구성 */
// 1) if(조건)     * 조건의 결과는 반드시 boolean형이어야 한다.
//      처리문1;   //조건을 만족할때 수행
//      처리문2;   //무조건 수행
//                 //{ } 안에 넣어야 처리문1, 처리문2를 조건 만족시에만 수행
// 2) if(조건)
//      처리문1;   //조건을 만족시
//    else
//      처리문2;   //조건을 불만족시
// 3) if(조건1)
//      처리문2;   //조건1을 만족시
//    else if(조건2)
//      처리문2;   //조건1에 불만족하고 조건2에 만족시
//    else
//      처리문3;   //조건1과 조건2 모두를 불만족시

public class IfTest1 {
    public static void main(String[] args) {
        // a의 값이 95이상일 때 "A+"
        // a의 값이 90~94일 때 "A-"
        // a의 값이 85~89일 때 "B+"
        // 나머지는 "다시"
        int a = 100;

//        if(a >= 95  )
//            System.out.println("A+");
//        else if(a >= 90 && a <= 94)
//            System.out.println("A-");
//        else if(a >= 85 && a <= 89)
//            System.out.println("B+");
//        else
//            System.out.println("다시");
//        불필요한 비교

        if(a >= 95  )
            System.out.println("A+");
        else if(a >= 90)    //여기까지 왔다는 것은 a의 값이 95이상이 아니다.
            System.out.println("A-");
        else if(a >= 85)
            System.out.println("B+");
        else
            System.out.println("다시");
    }
}






ex>> SwitchTest2.java
public class SwitchTest2 {
    public static void main(String[] args) {
        /*
         * switch문은 if문과 비교 성질이 틀린다.
         * switch문 : 특정값으로 분기
         * if문 : 범위값으로 분기
         *
         * 왠만한건 if문으로 다 가능하지만,
         * switch문이 값과 값의 비교에서는
         * 가독성면에서나 코딩할 때
         * 더 좋을때가 있다.
         *
         *
         * 유니코드값은 정수화되어 사용된다(char형)
         * 아래의 조건값은 반드시 정수형(byte, short, int, char)
         * (32비트 이하만 가능하다)
         * switch(조건값){
         *      case 비교값1 :
         *          // 조건값과 비교값1이 일치할 경우
         *          // 수행하는 문장들;
         *      break;     ---> break 안 넣으면
         *                      비교값2가 일치할 경우 수행될 문장까지 수행된다.
         *                      (비교값2 비교 안하고~)
         *      case 비교값2 :
         *          // 조건값과 비교값2가 일치할 경우
         *          // 수행하는 문장들;
         *      break;
         *      default:
         *          // 조건값이 비교값1~비교값n까지 일치하는 것이
         *          // 없을 때 수행하는 문장들;
         * }
         */
       
        // 앞의 if문 예제를 switch문으로 하면~....걍 하지마ㅡㅡ;
        int a = 99;
        switch(a){
            case 100:
                System.out.println("A+");
                break;
            case 99:
                System.out.println("A+");
            default:
                System.out.println("글쎄다~");
        } // end of switch
    }
}








ex>> SwitchTest3.java
import java.util.Scanner;

public class SwitchTest3 {
    public static void main(String[] args) {
        // Scanner 객체를 이용하여 키보드로부터 값(int형)을 받는 방법
        // 현재 시스템의 모니터(콘솔창)에 출력하려면 System.out
        // 반대로 현재 시스템의 키보드를 의미하는 것은
        // 무조건 System.in
        Scanner scan = new Scanner(System.in);
        // 쉽게 Scanner는 자료형(단지 기본적인 자료형이 아니다.)
        // scan은 변수명이라고 생각하면 쉽다~
        int data = scan.nextInt();  // 키보드로부터 정수 받기

        // data의 값이 1~12중 하나라고 가정하자!
        // 1,3,5,7,8,10,12 일 경우는 "31일까지 입니다."
        // 2는 "29일까지 입니다."
        // 4,6,9,11일 경우는 "30일까지 입니다."
        // 위의 조건을 switch문을 이용하여 완성하세요.
        switch(data){
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                System.out.println("31일까지 입니다.");
                break;
            case 2:
                System.out.println("29일가지 입니다");
                break;
            case 4:
            case 6:
            case 9:
            case 11:
                System.out.println("30일가지입니다.");
                break;
            default:
                System.out.println("잘못 입력하셨습니다.");
        }
    }
}







ex>> ContinueTest3 .java
public class ContinueTest3 {
    public static void main(String[] args){
        // continue문은 반복문에 쓰이며 다음 반복 회차로 인양하는 제어문이다.
        for(int i=1 ; i<=10 ; i++){
            if(i%3 == 0)
                continue;   //반복문을 탈출하지 않고 다음 회차로 넘어간다!
            System.out.println(i);
        } // end for
    }
}










ex>> WhileTest1.java
/*
 *   while(조건)      // 결과는 반드시 boolean 형인 조건식, 선비교 후처리
 *      처리문1;
 *   처리문2;
 *
 *      for문(초기,조건,증가 3가지)은 무한루프에 빠질 수 있는 가능성이 적다.(초보자일시)
 *      while문(조건 하나만)은 무한루프에 빠질 수 있다.
 */
public class WhileTest1 {
    public static void main(String[] args) {
        int a = 10;
        while(a < 20){
            System.out.println(a);
            a++;
        }
        System.out.println();
       
        int b = 10;
        while(b++ < 20) // 우선 비교연산자 부터 수행하여 b가 20보다 작다는 것을
            System.out.println(b);  // 먼저 확인한 후 b의 변수를 1 증가 시킨다.
        // 그러므로 출력할 때는 증가된 값을 출력하게 된다.
    }
}








ex>> DoWhileTest2.java
public class DoWhileTest2 {
    public static void main(String[] args){
        // dowhile문의 구성
        //  do{
        //      처리문;
        //  }while(조건식);     <- 마지막 세미콜론 잊지말자!!
        //
        // do-while문은 선 처리, 후 비교다
        // 그러므로 무조건 1번은 수행하게 되어 있다.

        int a = 10;
        do{
            System.out.println(a);
        }while(--a > 0);    // 비교연산자를 수해하기 전에 a의 값을 1 감소한다.
        // 그러므로 마지막에는 0을 출력하지 않게 된다.
    }
}









ex>> BreakTest4.java
public class BreakTest4 {
    public static void main(String[] args) {
        int a=0;
        while(++a <= 10){
            if(a%3 == 0)
                break; //가장 가까운 반복문 탈출!
            System.out.println(a);
        } //end while

        int i = 0;
        while(++i < 4){ //3번 반복
            for(int k=65 ; k<80 ; k++){
                //대문자 i의 코드 값은 화면에 출력하지 않게 하기 위해
                //continue문을 사용해 보자!
                if(k == 'I')    //정수와 문자비교, 'I'의 아스키값 구할 필요없다.
                    continue;
                    //break;    //continue와 break의 비교?????
                                //다중 반복문에서 가장 근접한 하나의 반복문만 빠져나갈수 있다. 그래서 레이블을 사용. BreakLabelTest5.java 보자.
                if(k%5 == 0)
                    System.out.println();   //줄 바꿈
                else
                    System.out.printf("%3s",(char)k);
                    // %3s : 3자리 표현 ->두칸공백, 한칸문자~
            }
            System.out.println("---------------------------");
        }
    }
}






ex>> BreakLabelTest5.java
public class BreakLabelTest5 {
    public static void main(String[] args) {
        int i = 0;
       
        bk:while(++i < 4){  //label은 반복문의 바로 앞에만 사용가능~!
            for(int k=1 ; k<=5 ; k++){
                if(k == 3)      // k가 3이면 모든 반복문을 빠져나가자!
                    break bk;
                System.out.printf("%3d", k);
            }
            System.out.println();
        }

        // 반복문 안에 switch~case문을 같이 사용할 때 label 사용하면 된다.
        // 그냥 쓰면 switch~case문만 빠져나가기 때문이다.
        // 다음 BreakLabelTest6.java 예제 보자~
    }
}




ex>> BreakLabelTest6.java
import java.util.Scanner;

public class BreakLabelTest6 {
    public static void main(String[] args) {
        hb:while(true){    //무한 루프
            System.out.println("입력 : ");
            Scanner scan = new Scanner(System.in);
            String msg = scan.nextLine();       //키보드로부터 한줄 받기 - 100, 200, 300
            int var = Integer.parseInt(msg);   //숫자를 입력했다고 가정 : 문자열->숫자
            switch(var){
                case 100:
                    System.out.println("100을 입력하셨군요");
                    for(int i=0 ; i<var ; i++)
                        System.out.printf("%3d", i);
                    break;
                case 300:
                    System.out.println("300을 입력하셨습니다. 종료");
               //     break;  // 반복문을 탈출하는 것이 아니라 switch문을 탈출하는 문장!
                    break hb;   //hb라는 별칭(Label)이 붙은 반복문을 탈출!
                case 200:
                    System.out.println("200");
            } // end switch
        } // end while
    }
}






ex>> Computer.java
/*
 * 클래스를 만드는 행위는 프로그래머의 사고를
 * 추상적으로 코드화 하는 것이다.
 *
 * 우리가 필요한 것은 컴퓨터다.
 *
 * 모델명
 * 제조자
 * cpu
 * 메인보드
 * 메모리 용량
 * HDD 용량
 * DVD 존재 여부
 * VGA
 */

class Computer{
    // 멤버 변수들 선언
    String model;
    String vender;
    String cpu;
    String mainboard;
    int memory;
    int hdd;
    boolean dvd;
    String vga;

    // setter getter 만드는 팁!!
    // 커서를 멤버 영역에 두고
    // art+insert 또는 마우스 오른쪽버튼 insert Code 선택
    // 만들 메서드 선택하면 된다.

    // 기능을 의미하는 메서드들 정의
    // 특정한 값을 받아서 model 변수에 대입하는 기능(메서드)
    public void setModel(String model){
        this.model = model;
    }

    // model의 값을 반환하는 기능(메서드)
    public String getModel(){
        return model;
    }

    public String getCpu() {
        return cpu;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public boolean isDvd() {
        return dvd;
    }

    public void setDvd(boolean dvd) {
        this.dvd = dvd;
    }

    public int getHdd() {
        return hdd;
    }

    public void setHdd(int hdd) {
        this.hdd = hdd;
    }

    public String getMainboard() {
        return mainboard;
    }

    public void setMainboard(String mainboard) {
        this.mainboard = mainboard;
    }

    public int getMemory() {
        return memory;
    }

    public void setMemory(int memory) {
        this.memory = memory;
    }

    public String getVender() {
        return vender;
    }

    public void setVender(String vender) {
        this.vender = vender;
    }

    public String getVga() {
        return vga;
    }

    public void setVga(String vga) {
        this.vga = vga;
    }
}




ex>> ComputerTest.java
public class CompuerTest {
    public static void main(String[] args) {
        // Computer 객체 생성
        Computer c1 = new Computer();
        c1.setModel("똥컴");  // c1의 setModel 메서드 호출하면서 "똥컴" 문자열 전달
        System.out.println(c1.getModel());
        //String str = c1.getModel();   //c1객체를 통하여 getModel메서드 호출하면
        //System.out.println(str);     //String객체를 받는다. 그것을 출력하여 확인!

        Computer c2 = new Computer();   //c1과는 다른 객체가 생성되었다.
        String str2 = c2.getModel();
        System.out.println(str2);       // null

    }

나는야 자바 초보자 콩콩댕~ 투투가 짱임~