자바 핵심 요약

유튜브 동영상 링크

https://www.youtube.com/watch?v=MbJYVj_jWV8 

 

자바에서 카멜케이스 적용

소문자로 시작 - 변수, 매서드, 패키지 ex) isFun

대문자로 시작 - 상수, 클래스, 인터페이스 ex) Pi PiClass

 

주석달기

싱글라인 주석

// This Method is test

 

멀티라인 주석 

/*

comment line 1

comment line 2

*/

 

자료형

자료 유형

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

 

상수 선언 

초기 선언만 가능하다. 상수는  final 문으로 고정시킨다.

final int J = 10;  //단 1회만 값을 입력가능

 

변수 선언 - 영문으로 시작, 대소문자 구분, 특수문자($, _ 제외) 사용불가

변하는 값으로 초기값을 넣어서 선언 할 수 있다. 또는 null 값으로로 선언된다.

boolean isFun = true;
char c ='f'; //2바이트
int x = 59;
long big = 3456789L; //(값을 적을때는 뒤에 소문자 l이나 대문자 L을 적어야 합니다.)
float f = 32.5f //(float에 값을 대입할 때는 실수 뒤에 소문자 f나 대문자 F를 붙여야 합니다.)
double d = 23.34; //값뒤에 D나 d를 사용하지 않아도 됨
String str1 = "hello"; 
String str3 = new String("hello");  //새로운 인스턴스로 별도 메모리에 문자열 저장공간 생성
String str3 = str1 + 24; //문짜열과 숫자의 더한 결과는 문자열이며 문자열 hello24가 대입됨

 

String 주요 기능(메서드)

concat : 문자열 연결
substring : 문자열 자르기
length : 문자열 길이
toUpperCase : 대문자로 만들기
toLowerCase : 소문자로 만들기 
indexOf : 특정문자열의 위치
equals : 문자열 비교
trim : 문자열 공백제거
replace : 특정문자 변경
repalceAll : 특정문자열 변경
startsWith : 특정문자로 시작하는지
contains : 특정문자가 포함되었는지

 

package javaStudy;
public class StringClass {
	public static void main(String[] args) {
		String str = "hello";

		System.out.println(str);  //출력결과는 hello 
		System.out.println(str.concat(" world"));  //출력결과는 hello world 
		System.out.println(str);  //출력결과는 여전히 hello
		System.out.println(str.length());  //출력결과는 5
		
		str = "hello world";
		System.out.println(str.substring(1, 3)); //출력결과  el
		System.out.println(str.substring(2));   //출력결과 llo world
	}
}

 

클래스의 실행은 이클립스에서 클래스를 선택하고 우측버튼을 누른 뒤 RunAs 에서  Java Application을 선택하면 실행됩니다. 실행결과는 콘솔창에서 확인할 수 있습니다.

 

연산자

산술 연산자

int i = 10;
Int j = 3;
System.out.println(i + j); //더하기 연산자
System.out.println(i - j); //빼기 연산자
System.out.println(i * j);  //곱하기 연산자
System.out.println(i / j);  //나누기 연산자
System.out.println(i % j);  //나머지 연산자

 

비교 연산자

System.out.println(i == j ); // 같다
System.out.println(i != j );  //다르다
System.out.println(i < j);  //작다
System.out.println( i <= j);  //작거나 같다
System.out.println(i > j);  //크다
System.out.println(i >= j);  //크거나 같다

논리 연산자 -  AND OR NOT ( &&  ||  ! )

int x = 10;
int y = 20;

// && and연산자
if (x > 5 && y > 15) {
  System.out.println("두 조건이 참이어야 참값");
}

// || or 연산자
if (x > 15 || y > 15) {
  System.out.println("둘 중 하나만 참이어도 참값");
} 

// ! not 연산자
if (!(x == 10)) {
  System.out.println("10이 아니다");
}

 

대입 연산자

i = 10; //i에 10을 대입(할당)한다
i += 10; //복합대입연산자

 

예외처리 try ~ catch ~ finally

package javaStudy;
public class ExceptionExam {
	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으로 나눌수 없습니다.");
		} finally {
			//finally는 필수가 아니나 반드시 실행해야할 코드가 있을 경우 사용
			System.out.println("종료");
		}
	}


	//호출한 곳으로 오류를 던진다. -> 호출한 메소드에서 오류제어 해야 한다.
	public static int divide(int i, int j) throws ArithmeticException{
		int k = i / j;
		return k;
	}
}

예외가 발생하면 catch문이 실행되고 예외와 상관없이 반드시 실행되어야 할 코드는 finally에 구현한다.

예외에는 다양한 형태가 있으며 catch(ArithmeticException e)는 산술연산 오류이다.

 

자바에서 디버깅은 브레이크포인트를 이클립스 라인쪽을 클릭해서 설정하고 디버그 실행하면 해당 지점에서 멈춘다.

이때 변수값을 추적할 수 있고 F6키를 누르면 다음으로 이동한다.

함수내부로 이동하려면 F7 키이고 전체 실행을 계속 진행하려면 F8키를 누르면 된다.

 

if 조건문

조건에 따른 분기가 작을 경우 및 복합조건의 경우 사용한다.

package javaStudy;
import java.util.ArrayList;

public class IfExam {
	public static void main(String[] args) {
		boolean hasCard = true;
		ArrayList<String> pocket = new ArrayList<String>();
		pocket.add("paper");
		pocket.add("handphone");
		
		if (pocket.contains("money")) {
		    System.out.println("택시를 타고 가라");
		}else if(hasCard) {
		    System.out.println("택시를 타고 가라");
		}else {         
		    System.out.println("걸어가라");
		}
	}
}

 

switch case 분기 조건문

각 블록에는 break문을 삽입하여 하방 진행을 막아야 한다.

case 조건:(콜론) 블록에 조건에 따른 코드를 전개한다.

package javaStudy;
public class SwitchExam {
	public static void main(String[] args) {
        int month = 8;
        String monthString;
        switch (month) {
            case 1:  monthString = "January";
                     break;
            case 2:  monthString = "February";
                     break;
            case 3:  monthString = "March";
                     break;
            case 4:  monthString = "April";
                     break;
            case 5:  monthString = "May";
                     break;
            case 6:  monthString = "June";
                     break;
            case 7:  monthString = "July";
                     break;
            case 8:  monthString = "August";
                     break;
            case 9:  monthString = "September";
                     break;
            case 10: monthString = "October";
                     break;
            case 11: monthString = "November";
                     break;
            case 12: monthString = "December";
                     break;
            default: monthString = "Invalid month";
                     break;
        }
        System.out.println(monthString);
	}
}

month가 8일 때 문자열 "August" 을 출력하는 예제이다.

 

do while문 – 한번 실행 뒤 조건에 맞으면 연속 실행

package javaStudy;

import java.util.Scanner;

public class DoWhileExam {
	public static void main(String[] args) {
		int value = 0;

		/*Scanner는 java.util 패키지에 있는 클래스로써 키보드로 부터 값을 
		입력받는다던지 할 때 유용하게 사용할 수 있는 클래스이다.*/
		Scanner scan = new Scanner(System.in);
		//키보드로부터 값을 입력받을 수 있는 Scanner객체가 생성된다. 

		do{
			value = scan.nextInt(); 
			// Scanner클래스를 이용하여 키보드로 부터 숫자값을 입력받는다.
			System.out.println("입력받은 수 : " + value);  
		}while(value != 10);  
		// 입력받은 값이 10이 아닐 경우에는 계속 반복한다.

		System.out.println("반복문 종료");
	}
}

 

while문 – 조건에 맞아야 연속 실행

package javaStudy;

public class WhileExam {
	public static void main(String[] args) {
            int i = 1;
            int sum = 0;
            while (i <= 100) {
              sum += i;
              i++;
            }
            System.out.println("일부터 백까지 합은 " + sum);
	}
}

 

for문 - 범위형 반복문

- 조건(시작값, 제약조건, 증가) 

package javaStudy;

public class ForExam {
	public static void main(String[] args) {
		int total = 0;
		for(int i = 1; i <= 100; i++){
			if(i % 2 != 0){  //홀수를 의미
				continue; //홀수는 skip
			}
			if (i > 50) break; //50이 넘으면 루프 탈출
			total = total + i;
		}
		System.out.println(total);
	}
}

1부터 100까지 더하라. 단  짝수만 더하고 i >50 이면 빠져나와라.

 

- for each : 컬렉션이나 배열에서 아이템을 뽑아서 반복

package javaStudy;

public class ForEachExam {
	public static void main(String[] args) {	
		int numbers[] = {1, 2, 3, 4, 5};
		for (int number : numbers) {
			System.out.println(number);
		}
	}
}

 

자바 static 변수 및 static 메서드

Static(정적) 변수와 static 메소드는 클래스변수로 메모리의 데이터영역에 저장하여  Class를 인스턴스하지 않아도 참조할 수 있다.

package javaStudy;

class PiClass {
	public static final double PI = 3.1415;	//final을 사용하여 변경되지 않는 상수값을 지정
}

public class MainClass {
	public static void main(String[] args) {
		System.out.println("원주율 : " + PiClass.PI); //클래스를 인스턴스 생성없이 참조
	}
}

PiClass.PI 상수는 static형으로 PiClass인스턴싱없이 사용이 가능하다. 또한 main메서드도 static형으로 외부인스턴싱없이 실행이 가능하다. 클래스의 main()처럼 단독 실행이 필요한 매서드는 static형이어야 한다.

 

생성자

클래스명과 이름이 같은 메소드로 클래스가 인스턴싱할 때 사용됨. 비 선언시 디폴트 생성자가 생성됨.

package javaStudy;
class OpenCar{
	String name;
	int number;

	public OpenCar(String n){
		name = n;
		this.name = n; //this는 자기자신을 의미
	}
}

public class CarExam{
	public static void main(String args[]){
		OpenCar c1 = new OpenCar("소방차");
		OpenCar c2 = new OpenCar("구급차");
		//Car c3 = new Car(); // 컴파일 오류가 발생합니다.

		System.out.println(c1.name);
		System.out.println(c2.name);
	}
}

 

클래스 상속

클래스 상속을 어렵게 이해할 필요가 없다. 그냥 부모클래스를 상속하여 기능을 확장하기 위해 extends 키워드를 사용하여 상속 한다. 이 정도만 알면 된다.

부모에게 있는 것을 그대로 써도 되고 수정해서 써도 된다. 수정해서 사용하면 그게 오버라이딩이다. 부모에게 없는 것은 새로 만들어서 써도 된다.

package javaStudy;

//Car 클래스
class Car{
    public void run(){
        System.out.println("달리다.");
    }
}

//Bus 클래스 - Car상속해서 ppangppang메소드 추가
class Bus extends Car{
    public void ppangppang(){
        System.out.println("빵빵");
    }       
}

//Bus 클래스사용 - run메소드 및 추가한 ppangppang메소드를 사용할 수 있다
public class BusExam{
    public static void main(String args[]){
        Bus bus = new Bus();
        bus.run();  
        bus.ppangppang();
    }   
}

Bus클래스는  Car클래스를 상속받아서 확장하였다.

Bus bus = new Bus();  생성된 bus객체는
bus.run();  Car클래스를 상속받아 달리기도 하고 
bus.ppangppang();  부모에게는 없어도 난 버스라서 빵빵도 한다.

 

추상 클래스

추상 클래스는 직접 인스턴스를 생성할 수 없는 부모로서만 역할을 하며 abstract를 맨앞에 붙여 생성한다.

추상 메소드란, 내용이 없는 빈 메소드로 리턴 타입 앞에 abstract라는 키워드를 붙여 선언한다.

 

자식 클래스는 추상클래스를 상속받아서 확장할 때 반드시 추상 메소드는 오버라이드해서 내용을 구현해야 한다. 

추상클래스는 스스로는 추상적인 존재일 뿐 실체로서 동작할 수 없고 상속받는 객체가 가져야 하는 틀(형상)을 강요할 뿐이다. (ex 포유류>인간, 포유류>곰)

package javaStudy;

abstract class Bird{
	public abstract void sing(); //추상 메소드

	public void fly(){
		System.out.println("날다.");
	}
}

class Duck extends Bird{
	//오버라이드해서 해당 추상메소드를 실제 구현해야 한다.
	@Override
	public void sing() {
		System.out.println("꽥꽥!!");
	}
}

public class DuckExam { 
	public static void main(String[] args) {
		Duck duck = new Duck();	//Bird클래스는 인스턴스를 생성할 수 없고, Duck클래스 인스턴스를 생성
		duck.sing();
		duck.fly();

		//Bird b = new Bird();
	}   
}

추상클래스 Bird를 생성하고 추상메서드 sing()을 작성한다. 추상메서드 sing()은 {}이하 실체가 없다.

Bird클래스를 상속받아 Duck클래스를 구현한다.

sing()메서드는 상속받았지만 추상메서드로 @Override 오버라이드 어노테이션으로 오버라이드해서

sing()를 구현해야 한다.

 

Duck duck = new Duck(); Bird클래스를 상속받은 duck객체는
duck.sing(); 노래도 부르고
duck.fly(); 날라다닌다.

 

인터페이스

인터페이스는 추상클래스와 달리 클래스가 아니며 implements 해서 실체를 구현해야 한다. 또한, 객체 선언에는 참여해도 실체가 없으므로 스스로는 인스턴싱할 수 없다. 

 

ex) List<String> list = new ArrayList<>(); list는 인터페이스로  new list() 처럼 사용할 수 없다.

 

추상화된 공통 형태를 제공하는 녀석으로  이것을 인터페이싱한 클래스에서 동일한 기능을 하는 메서드가 존재하도록 구현을 강제하는 역할을 수행한다. 앞으로 우리는 이 인터페이스를 채용한 클래스는 어떻게 생겼는지 알 수가 있다.

 

구현 객체의 동일한 동작을 보장하기 위해서 사용되며 동일 인터페이스를 사용한 클래스는 동일한 동작 (상호작용)을 하는 메서드를 갖는다.

 

말이 어렵고 설명하기도 어렵다.  '내가 이렇게 생겼으니까 너도 이렇게 생겨야 해'  식의 껍데기만 제공한다고 보면 될 것 같다. 

 

implements 문을 사용하여 인터페이스의 형체를 따라 실체를 구현

package javaStudy;

interface TV{
	public int MAX_VOLUME = 100;
	public int MIN_VOLUME = 0;

	public void turnOn();
	public void turnOff();
	public void changeVolume(int volume);
	public void changeChannel(int channel);
}

//인터페이스는 implements를 사용해서 구현하며 모든 메소드를 정의하여야 한다.
//정의하지 않으면 추상클래스가 되어 인스턴스를 생성할 수 없다.
class LedTV implements TV{
	public void turnOn(){
		System.out.println("켜다");
	}
	public void turnOff(){
		System.out.println("끄다");   
	}
	public void changeVolume(int value){
		System.out.println(value + "로 볼륨조정하다.");  
	}
	public void changeChannel(int number){
		System.out.println(number + "로 채널조정하다.");         
	}
}

public class LedTVExam{
	public static void main(String args[]){
		TV tv = new LedTV();
		tv.turnOn();
		tv.changeVolume(50);
		tv.changeChannel(6);
		tv.turnOff();
	}
}

TV인터페이스는 클래스가 아니다. 클래스의 틀로 추상상태의 껍데기이다.

인터페이스는 클래스가 아니므로 상속받을 수 없고 implements 키워드로 구현해야 한다.

implements한 클래스는 모든 메소드를 정의해서 실체화 시켜야 한다.

 

실체가 구현된 LedTV 클래스는

TV tv = new LedTV();  TV인터페이스를 채용한 tv 객체로 생성되서
tv.turnOn(); 전원도 켜고
tv.changeVolume(50); 볼륨도 바꾸고
tv.changeChannel(6); 채널도 바꾸고
tv.turnOff(); 전원을 끈다.

 

ArrayList 컬렉션

package javaStudy;
import java.util.ArrayList;
import java.util.List;

public class ListExam {

	public static void main(String[] args) {
		List<String> list = new ArrayList<>();

		// list에 3개의 문자열을 저장합니다.
		list.add("kim");
		list.add("lee");
		list.add("kim");

		System.out.println(list.size()); //list에 저장된 자료의 수를 출력 (중복을 허용하므로 3 출력) 
		for(int i = 0; i < list.size(); i++){
			String str = list.get(i);
			System.out.println(str);
		}
	}   
}

ArrayList를 사용하기 위해서  패키지를 임포트한다.

import java.util.ArrayList;
import java.util.List;

 

List<String> list = new ArrayList<>(); ArrayList를 사용하여 list객체를 생성한다. ArrayList는 일반적으로 선언할 때 자신의 부모인 List 인터페이스로 선언하여 범용성을 높인다.

list.add("kim"); "kim"추가하고

for(int i = 0; i < list.size(); i++){  list의 사이즈만큼 반복해서
    String str = list.get(i);  get(인덱스)로 값을 가져와 str변수에 저장하고
    System.out.println(str); str을 출력한다.
}

 

HashMap

Map은 key와 value를 쌍으로 저장하는 자료구조로 키는 중복될 수 없고, 값은 중복될 수 있다. put, get 메소드를 사용하여 값의 추가와 가져오기가 가능하다.

 

Generic을 사용하여 값의 타입을 정의할 수 있다.

- Generic이라는 문법이 사용됨으로써 인스턴스를 만들때 사용하는 타입을 지정

 

Map<String, String> map = HashMap<String, String>();  HashMap은 일반적으로 선언할 때 자신의 부모인 Map 인터페이스로 선언하여 범용성을 높인다.

package javaStudy;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;   
public class MapExam {  
	public static void main(String[] args) {
	    Map<String, String> map = new HashMap<>(); // Key, Value가 모두 String 타입인 HashMap인스턴스를 만든다.

	    map.put("001", "kim");	// key와 value값을 put으로 저장
	    map.put("002", "lee");
	    map.put("003", "choi");	
	    // 같은 key가 2개 있을 수 없다. 첫번째로 저장했던 001, kim은 001, kang으로 바뀐다.
	    map.put("001", "kang");

	    System.out.println(map.size());	// map에 저장된 자료의 수를 출력 > 3

	    // 키가 001, 002, 003인 값을 꺼내 출력합니다.
	    System.out.println(map.get("001"));
	    System.out.println(map.get("002"));
	    System.out.println(map.get("003"));

	    Set<String> keys = map.keySet();// map에 저장된 모든 key들을 Set자료구조로 꺼냅니다.
	    Iterator<String> iter = keys.iterator();
	    // Set자료구조에 있는 모든 key를 꺼내기 위하여 Iterator를 구한다.
	    while (iter.hasNext()) {
		String key = iter.next();	// key를 꺼냅니다.
		String value = map.get(key); // key에 해당하는 value를 꺼냅니다.
		System.out.println(key + " : " + value);  // key와 value를 출력합니다.
	    }
	}
}

 

자바 JDBC

DriverManager - 드라이버관리자(db에 맞는 드라이버 로딩)

Connection  - DB연결 객체

Statement – 쿼리 실행 객체

PreparedStatement  - 준비된 쿼리 실행 객체

ResultSet – 쿼리 결과 집합 객체

 

package javaStudy;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class JDBCExam {
	public static void main(String[] args) {
		Connection db;  
		Statement  st;
		try {
			Class.forName("org.postgresql.Driver");
			db = 
            DriverManager.getConnection("접속정보", "ID", "패스워드");
			st = db.createStatement();
			st.executeUpdate("drop table if exists basic");    
			st.executeUpdate("create table basic (a int, b int)");
			st.executeUpdate("insert into basic values (1,1)");
			st.executeUpdate("insert into basic values (2,1)");
			st.executeUpdate("insert into basic values (3,1)");
			st.executeUpdate("update basic set b=8");
			PreparedStatement ps = db.prepareStatement("insert into basic values (?,?)");
			for(int i=2;i<5;i++) {
				ps.setInt(1,4);      // "column a" = 5
				ps.setInt(2,i);      // "column b" = i
				ps.executeUpdate(); 
			}
			ps.close();                
			ResultSet rs = st.executeQuery("select a, b from basic");
			if(rs!=null) {
				while(rs.next()) {
					int a = rs.getInt("a");
					int b = rs.getInt(2); 
					System.out.println("a=" + a + ", b=" + b);
				}
				rs.close(); 
			}   
			st.executeUpdate("drop table if exists basic");   
			st.close();   
			db.close();
		} catch (ClassNotFoundException | SQLException e) {
			e.printStackTrace();
		}
	}
}

 

Class.forName("org.postgresql.Driver"); 

JDBC드라이버를 로드하고
Connection db = DriverManager.getConnection("접속정보", "ID", "패스워드");

접속정보를 사용해 연결을 만들고
Statement  st = db.createStatement();

연결된 DB로 부터 Statement 객체 st를 생성
st.executeUpdate("drop table if exists basic");   

테이블이 있으면 삭제하고
st.executeUpdate("create table basic (a int, b int)");

테이블을 생성하고
st.executeUpdate("insert into basic values (1,1)");

데이터를 집어넣고
st.executeUpdate("insert into basic values (2,1)");
st.executeUpdate("insert into basic values (3,1)");

st.executeUpdate("update basic set b=8");

b=8인 레코드를 수정하고

 

PreparedStatement ps = db.prepareStatement("insert into basic values (?,?)");

`insert`문을 실행하는 PreparedStatement ps객체를 만들어서 파라미터 추가후 실행

ps.setInt(1,4); 
ps.setInt(2,1);  
ps.executeUpdate(); 

ResultSet rs = st.executeQuery("select a, b from basic");

 st 객체로부터 쿼리 실행후 결과셋 rs객체를 생성하고

while(rs.next()) {

     rs 객체가 next()일 때까지 읽어서
    int a = rs.getInt("a");

    필드명이 a인것을 가져오고
    int b = rs.getInt(2); 

    레코드의 컬럼인덱스가 2인것을 가져온다.
    System.out.println("a=" + a + ", b=" + b);
}

resultset의 컬럼인덱스는 1부터 시작한다.(배열인덱스는 0부터 시작)

 

다음 >> 스프링 프레임웍의 이해

https://itcamp24.tistory.com/181

스프링 프레임워크 이해