자바 신속 문법

https://wikidocs.net/book/31 점프 투 자바

파트 1. 자바시작

1. 주석

한 줄만 주석 처리 : // 주석 처리할 내용
여러 줄을 주석 처리 : /* 주석 내용 */
문서화 주석 : /** 주석 내용 */

파트 2. 변수와 계산

2-1. 변수, 상수

• 논리형 (boolean)
  논리형은 크기가 1byte이고 true와 false 중에 한 가지 값을 가질 수 있다.
• 문자형 (char)
  문자형은 char로 2byte크기를 가집니다. 문자는 작은따옴표를 이용하여 한 글자를 표현할 수 있다.
• 정수형 (int, long)
  정수형은 정수를 표현하는 데이터 타입인데 표현할 수 있는 정수의 범위에 따라서 다양하게 제공된다.

정수형에서 가장 자주 사용하는 int는 4바이트이다.

long형은 8byte크기를 가진다. int 보다 더 큰 범위의 정수를 표현하고 싶을때 사용한다.

• 실수형 (float, double)
  실수형은 float과 double형이 있다.

float은 4바이트, double은 8바이트로 double은 float보다 더 큰 범위의 실수를 표현할 수 있다.

• 리터럴
  컴퓨터 과학 분야에서 리터럴이란, 소스 코드의 고정된 값을 대표하는 용어다.

리터럴은 일종의 값이다. true, false, 10, 11.1, a 등 이런 값 자체를 리터럴이라고 한다.

• 상수 (final)
  고정된 값

2-2. 묵시적,명시적 형변환

묵시적 형변환(암묵적 형변환) : 크기가 작은 타입을 크기가 더 큰 타입으로 바꿀 때를 말한다.
명시적 형변환(강제 형변환) : 크기가 더 큰 타입을 작은 타입으로 바꿀 때에는 명시적으로 변환한다.

2-3. 산술연산자

부호(+,-), 증감(++,--), +,-,*,/,%

• i와 j의 합
  i + j;
• i와 j의 차
  i - j;
• i와 j의 곱
  i * j;
• i를 j로 나눈 몫
  i / j;
• i를 j로 나눈 나머지
  i % j;

2-4. 비교연산자

우항 좌항이
같다 ==
다르다 !=
우항이 더 크다 <
좌항이 더 크다 >
우항이 더 크거나 같다 <=
좌항이 더 크거나 같다 >=

파트 3. 제어문

3-1. if문

if(조건식1)
{
    실행문1;
} else if(조건식2) {
    실행문2;
} 

3-2. 논리연산자

• 논리곱 (&&, &) - 피연산자가 모두 true일 경우에만 연산 결과가 true 이다.
• 논리합 (||,|) - 피연산자 중 하나만 true이면 연산 결과는 true 이다.
• 배타적 논리합 () -> 피연산자가 서로 다른 값일 경우만 연산 결과가 true 이다.
• 논리 부정 (!) -> 피연산자의 논리값을 바꾼다. true는 false로 false는 true로 바꾼다.

3-3. 삼항연산자

조건식 ? 피연산자1 : 피연산자2

  int b1 = (5>4) ? 50 : 40;

3-4. switch

switch(변수){
        case 값1 : 
            실행문; 
            break;
        case 값2 : 
            실행문; 
            break;  
        default;    
    }

만약 같은동작을 하는 case라면

     switch(month) {
            case 1:
            case 2:
            case 12:
                season = "겨울";
                break;
            case 3:
            case 4:
            case 5:
                season = "봄";
                break;
            case 6:
            case 7:
            case 8:
                season = "여름";
                break;
            case 9:
            case 10:
            case 11:
                season = "가을";
                break;
        }

3-5. while

while(조건문){
    실행문; 
}

3-6. do while

do{
        실행문;
    }while(조건문);

무조건 한번은 실행된다.

3-7 for

 for(초기화식; 조건식; 증감식){
        실행문;
        실행문;
    }

파트 4. 배열

4-1. 1차원 배열

int[] array1 = new int[4];

// 선언과 동시에 초기화
int[] array1 = {1,2,3,4} 

4-2. 배열 길이

array.length;

배열 => length 문자열 => length();

4-3. 2차원 배열

int[][] array4 = new int[3][4];

// 선언과 동시에 초기화
int [][] array = {{1}, {1, 2}, {1, 2, 3}, {1, 2, 3, 4}};

4-4. for each

int[] iarr = {10,20,30,40,50};

    for(int value:iarr){
        System.out.println(value);
    }

배열 값을 집어 넣음

파트 5. 클래스와 객체

5-1. 클래스 선언

클래스 생성

public class Car{

    }

객체 생성

 public class CarExam{
        public static void main(String args[]){
            Car c1 = new Car();
            Car c2 = new Car();
        }
    }

5-2. 참조 타입

참조형 타입은 기본형 타입을 제외한 모든 타입이다.
앞서 배웠던, 배열도 참조형이고, 클래스도 모두 참조 타입이다.

5-3. String 클래스 인스턴스 참조

String str1 = new String("hello");
String str2 = new String("hello");

각 인스턴스에 같은 값을 저장한다고 해도 두 인스턴스가 같은 건 아니다 (==로 알 수 있음)
대신 값은 같기 때문에 같은 값으로 나온다.(String 비교는 A.equals(B)이다.)

5-4. field 필드

필드(field)란 객체의 속성이다.
(아래는 문자열 타입 필드 name과 정수 타입 필드 number를 저장하는 Car 클래스를 선언하는 코드)

public class Car {
    String name;
    int number;
}

5-5. 메소드(= 함수)

메소드는 입력값이 있고, 그 입력값을 받아서 무언가 한 다음 결과를 도출해 내는 수학의 함수와 비슷한 개념이다.

• 메소드 선언

 public class MyClass{
        public void method1(){
            System.out.println("method1이 실행됩니다.");
        }
    }

5-6. String 클래스 메소드(함수)

concat: 문자열을 붙일 때 사용합니다. [A.concat(B)]
substring: 문자열을 자를 때 사용합니다.[A.substring(1, 3)] => 1번부터 3번까지 출력 (0부터 시작)

5-7. scope와 static

scope : 프로그램상에서 사용되는 변수들은 사용 가능한 범위를 가진다. 그 범위를 변수의 스코프라고 한다.
static : 변수를 공유 -> static한 메소드는 Class가 인스턴스화 되지 않아도 사용할 수 있다.

5-8. 열거형(enum)

• 정의

enum Gender{
        MALE, FEMALE;
    }

• 사용

		Gender gender2;
		
		gender2 = Gender.MALE;
		System.out.println(gender2);
	    gender2 = Gender.FEMALE;
	 	System.out.println(gender2);
        
	// 출력결과
    MALE
	FEMALE

특정 값만 가져야 한다면 열거형을 사용하는 것이 좋다.

파트 6. 클래스 다듬기

6-1. 생성자

모든 클래스는 인스턴스화 될때 생성자를 사용한다.

생성자의 특징

• 생성자는 리턴타입이 없다.
• 생성자를 프로그래머가 만들지 않으면 매개변수가 없는 생성자가 컴파일할 때 자동으로 만들어진다.
• 매개변수가 없는 생성자를 기본생성자라고 한다.
• 생성자를 하나라도 프로그래머가 만들었다면 기본생성자는 자동으로 만들어지지 않는다.

6-2. this

this는 현재 객체, 자기 자신을 나타낸다.

6-3. 메소드 오버로딩

매개변수의 유형과 개수가 다르게 하여 같은 이름의 메소드를 여러 개 가질 수 있게하는 기술 (매개변수의 유형이 다른것! => 오버로딩)

 class MyClass2{
        public int plus(int x, int y){
            return x+y;
        }

        public int plus(int x, int y, int z){
            return x + y + z;
        }

        public String plus(String x, String y){
            return x + y;
        }
    }

6-4. 생성자 오버로딩

 public class Car{
        String name;
        int number;

        public Car(){

        }

        public Car(String name){
            this.name = name;
        }

        public Car(String name, int number){
            this.name = name;
            this.number = number;
        }
    }

6-5. 패키지

패키지(package)란 서로 관련이 있는 클래스 또는 인터페이스들을 묶어 놓은 묶음이다.
패키지를 사용함으로써 클래스들이 필요할 때만 사용될 수 있도록 하고,
클래스를 패키지 이름과 함께 계층적인 형태로 사용함으로써 다른 그룹에 속한 클래스와 발생할 수 있는 클래스 이름간의 충돌을 막아줌으로 클래스의 관리를 편하게 해준다.

파트 7. 상속

7-1. 상속

상속이란? 부모가 가진것을 자식에게 물려주는것을 의미한다.

// Car 클래스 선언
public class Car{ }

// Car 클래스를 상속 받는 Bus 클래스 선언
public class Bus extends Car{ }

7-2. 접근제한자

1. public
   어떤 클래스든 접근할 수 있다는 것을 의미
2. protected
   자기 자신, 같은 패키지, 서로 다른 패키지다 하더라도 상속받은 자식 클래스에서는 접근할수 있다는 것을 의미
3. private
   자기 자신만 접근할 수 있다는 것을 의미
4. 접근제한자를 적지 않으면 default접근 지정자
   자기자신과 같은 패키지에서만 접근할 수 있다는 것을 의미

7-3. 추상클래스

구체적이지 않은 클래스를 의미한다. 독수리, 타조는 구체적인 새를 지칭하는데 새, 포유류 같은 것은 구체적이지 않다.

추상 클래스 정의하기

• 추상 클래스는 클래스 앞에 abstract 키워드를 이용해서 정의한다.
• 추상 클래스는 미완성의 추상 메소드를 포함할 수 있다.
• 추상 메소드란, 내용이 없는 메소드 이다. 즉 구현이 되지 않은 메소드이다.
• 추상 메소드는 리턴 타입 앞에 abstract라는 키워드를 붙여야 한다.
• 추상 클래스는 인스턴스를 생성할 수 없다.

7-4. super 와 부모생성자

class가 인스턴스화 될때 생성자가 실행되면서 객체의 초기화를 한다. 그 때 자신의 생성자만 실행이 되는것이 아니고, 부모의 생성자부터 실행된다.

    public class Car{
        public Car(){
            System.out.println("Car의 기본생성자입니다.");
        }
    }

    public class Bus extends Car{
        public Bus(){
            System.out.println("Bus의 기본생성자입니다.");
        }

    }
    //================  Run ====================
    public class BusExam{
        public static void main(String args[]){
            Bus b = new Bus();
        }
    }
    
    // 출력결과 
    Car의 기본생성자입니다. 
    Bus의 기본생성자입니다.
    

• super

1. 자신을 가리키는 키워드가 this 라면, 부모들 가리키는 키워드는 super
2. super() 는 부모의 생성자를 의미한다.
3. 부모의 생성자를 임의로 호출하지 않으면, 부모 class의 기본 생성자가 자동으로 호출된다.
4. 아래 예제처럼 호출해보면 위에서 super()를 호출하지 않을때와 결과가 같다.

public Bus(){
        super();
        System.out.println("Bus의 기본생성자입니다.");
    }

7-5. 오버라이딩

부모가 가지고 있는 메소드와 똑같은 모양의 메소드를 자식이 가지고 있는 것이다. 즉 오버라이딩이란 메소드를 재정의 하는 것이다.

  //run 메소드를 가지고 있는  Car클래스 
    public class Car{
        public void run(){
            System.out.println("Car의 run메소드");
        }
    }
    @override
      public class Bus extends Car{
        public void run(){
            System.out.println("Bus의 run메소드");
        }
    }
    
 //   ============= Run ===============
  public class BusExam{
        public static void main(String args[]){
            Bus bus = new Bus();
            bus.run();  
        }
    }
// 출력결과
Bus run메소드

7-6. 클래스 형변환

• 정의됨

 public class Car{
        public void run(){
            System.out.println("Car의 run메소드");
        }
    }

    public class Bus extends Car{
        public void ppangppang(){
            System.out.println("빵빵.");
        }   
    }

• 형변환 없이 실행함

    public class BusExam{
        public static void main(String args[]){
            Car car = new Bus();
            car.run();
            car.ppangppang(); // 컴파일 오류 발생
        }
    }

• 형변환

 public class BusExam{
        public static void main(String args[]){
            Car car = new Bus();
            car.run();
            //car.ppangppang(); // 컴파일 오류 발생

            Bus bus = (Bus)car;  //부모타입을 자식타입으로 형변환 
            bus.run();
            bus.ppangppang();
        }
    }

형변환 없이 자식 객체가 가지고 있는 메소드나 속성 사용이 불가하다.

파트 8. 인터페이스와 다른 형식의 클래스

8-1. 인터페이스

서로 관계가 없는 물체들이 상호 작용을 하기 위해서 사용하는 장치나 시스템
인터페이스는 사용할때 해당 인터페이스를 구현하는 클래스에서 implements 키워드를 이용한다

• 인터페이스

public interface TV{
    public void turnOn();
    public void turnOff();
}

• 인터페이스 사용

public class LedTV implements TV{
    public void turnOn(){
        System.out.println("켜다");
    }
    public void turnOff(){
        System.out.println("끄다");   
    }
}

인터페이스는 변수가 없다. (정의된 변수는 모두 상수이다.)

8-2. default 인터페이스

public interface Meter{
    public void start();
    public int stop(int distance);
    
    public default void afterMidnight(){
        System.out.println("자정이 넘었습니다. 할증이 필요한경우 이 메소드를 오버라이드 하세요.");
    }
}

default는 따로 정의하지 않아도 에러가 발생하지 않는다.
단, 사용하고자 하면 메소드 오버라이드가 필요하다.

8-3. 다양한 클래스

내부클래스 : 클래스 안에 선언된 클래스

public class InnerExam1{
        class Cal{
            int value = 0;
            public void plus(){
                value++;
            }
        }

        public static void main(String args[]){
            InnerExam1 t = new InnerExam1();
            InnerExam1.Cal cal = t.new Cal();
            cal.plus();
            System.out.println(cal.value);

        }
    }

익명클래스 : 익명 중첩 클래스는 익명 클래스라고 보통 말하며, 내부 클래스이기도 하다.

파트 9. 예외처리

9-1. Exception

프로그램실행중 예기치 못한 사건을 예외라고 한다. 예외 상황을 미리 예측하고 처리할 수 있는데, 이렇게 하는 것을 예외 처리라고 한다.
try/catch 문을 이용한다.

int i = 10;
int j = 0;
try {
    int k = i / j; // j가 0일 때 ArithmeticException이 발생
    System.out.println(k);
} 
catch(ArithmeticException e){
    // catch에서 예외처리
    System.out.println("0으로 나눌 수 없습니다. : " + e.toString());
} 
finally {   
    // finally블록은 생략 가능합니다.
    System.out.println("오류가 발생하든 안 하든 무조건 실행되는 블록입니다.");
}

9-2. throws

예외가 발생했을때 예외를 호출한 쪽에서 처리하도록 던져준다.

public class ExceptionExam2 {

        public static void main(String[] args) {
            int i = 10;
            int j = 0;
            try{
                int k = divide(i, j);
                System.out.println(k);
            } catch(ArithmeticException e){
                System.out.println("0으로 나눌수 없습니다.");
            }

        }

        public static int divide(int i, int j) throws ArithmeticException{
            int k = i / j;
            return k;
        }

    }

오류를 main에 던저버린다.

9-3. Exception 발생시키기

throw : 강제로 오류를 발생시킨다.

public class ExceptionExam {
    public static void main(String[] args) {
        int i = 10;
        int j = 0;
        int k = divide(i, j);     // j가 0일 경우 오류를 발생시킵니다.
        System.out.println(k);
    }       
    public static int divide(int i, int j) throws IllegalArgumentException{
        if(j == 0){
            throw new IllegalArgumentException("0으로 나눌 수 없어요.");
         }
        int k = i / j;
        return k;
    }   
}

return 대신 throw로 예외를 강제로 발생시켜 넘기는 것이다.

9-4. 사용자 정의 Exception

예외 클래스(Exception)를 상속받는 경우 Checked exception(예외 체크)이 된다.
반드시 예외 처리해야하며 하지 않으면 컴파일 오류가 발생한다.

public class BizException extends RuntimeException {
    public BizException(String msg){    // 문자열로 된 오류메세지를 담는 생성자
        super(msg);                     // 부모의 생성자에게 메세지를 넘김
    }       
    public BizException(Exception ex){  // 실제 발생할 익셉션을 담는 생성자
        super(ex);                      // 부모의 생성자에게 ex를 넘김
    }
}