웅지의 개발새발

라이브러리

라이브러리는 프로그램 개발 시 활용할 수 있는 클래스와 인터페이스들을 모아놓은 것을 말한다.

일반적으로 JAR(압축파일 .jar)형태로 존재한다.=> 클래스와 인터페이스의 바이트코드 파일(~.class)들이 압축되어 있다.

ClassPath에 라이브러리를 추가하는 방법

=>라이브러리를 이용하려면 jar파일을 classpath에 추가해야 한다.

* 콘솔(명령 프롬프트 또는 터미널)에서 프로그램을 실행할 경우

- java 명령어를 실행할 때 -classpath로 제공

- CLASSPATH 환경 변수에 경로를 추가

* 이클립스 프로젝트에서 실행할 경우

- 프로젝트의 Build Path에 추가

my_lib 라이브러리 프로젝트 생성

Project name: my_lib
Module: [체크안함] Create module-info.java file (중요)

package pack1;

public class A {
	public void method() {
		System.out.println("A-method");
	}
}

package pack2;

public class B {
	public void method() {
		System.out.println("B-method");
	}
}

my_lib 오른쪽 버튼 -> [Export] 클릭 -> JAR file -> [Next] -> my_lib 체크 -> 폴더 및 이름 지정 -> [Finish]

my_application_1 프로젝트 생성

[File] -> [New] -> [Java Project] -> 입력 -> [Finish]

my_application_1 오른쪽버튼 -> [Build Path] -> [Libraries] -> [Classpath] -> [Add External JARs] -> jar 추가 -> [Apply]

라이브러리 파일 사용하기

콘솔에서 -classpath 옵션 사용

명령 프롬프트에서 현재 경로를 bin디렉토리로 이동하고 Main클래스를 실행하면 에러가 발생한다. my_lib.jar를 인식하지 못했기 때문이다.

=>-classpath로 파일 경로를 추가해서 실행해보면 원하는 결과가 출력된다.

모듈

모듈은 패키지 관리 기능까지 포함된 라이브러리이다. 일반 라이브러리는 내부에 포함된 모든 패키지에 외부 프로그램에서의 접근이 가능하지만, 모듈은 패키지를 은닉하여 접근할 수 없게끔 할 수 있다.

모듈은 모듈 기술자(module-info.java)에 의존 모듈을 기술할 수 있어 모듈 간의 의존 관계를 파악할 수 있다.

my_module_a, my_module_b 생성

Project name: my_module_a
Module: [체크] Create module-info.java file (중요)
Module name: my_module_a

Project name: my_module_b
Module: [체크] Create module-info.java file (중요)
Module name: my_module_b

my_application_2 생성

[File] -> [New] -> [Java Project] -> 입력 -> [Finish]

Project name: my_application_2
Module: [체크] Create module-info.java file (중요)
Module name: my_application_2

[my_application_2]오른쪽 버튼 -> [Build Path] -> [Configure Build Path] -> [Projects] -> Modulepath에 추가 -> [Apply]

패키지 은닉

모듈은 모듈 기술자(module-info.java)에서 exprts 키워드를 사용해 내부 패키지 중 외부에서 사용할 패키지를 지정한다.

exports 되지 않은 패키지는 자동적으로 은닉된다.

모듈이 일부 패키지를 은닉하는 이유

* 모듈 사용 방법 통일

- 모듈 외부에서 패키지2와 3을 사용하지 못하도록 막고, 패키지1로 사용 방법을 통일한다.

* 쉬운 수정

- 모듈 성능 향상을 위해 패키지2와 3을 수정하더라도 모듈 사용 방법(패키지1)이 달라지지 않기 때문에 외부에 영향을 주지 않는다.

전이 의존

다음과 같이 의존 관계를 변경한다고 가정해보자.

module my_application_2{
	requires my_module_a;
}

module my_module_a{
	exports pack1;
    	requires my_module_b;
}

my_application_2에서 my_module_b에 있는 C 클래스를 사용해야 한다면

"requires transitive my_module_b"를 반드시 추가해야 한다.

module my_module_a{
	exports pack1;
    	requires transitive my_module_b;
}

중첩 클래스

중첩 클래스란 클래스 내부에 선언한 클래스

=>클래스의 멤버를 쉽게 사용할 수 있고 외부에는 중첩 관계 클래스를 감춤으로써 코드의 복잡성을 줄일 수 있다.

중첩 클래스도 하나의 클래스이기 때문에 컴파일하면 바이트코드 파일(.class)이 별도로 생성된다.

파일의 이름은 다음과 같이 결정된다.

A $ B .class (A: 바깥 클래스. B: 멤버 클래스)

A $1 B .class (A: 바깥 클래스. B: 로컬 클래스)

인스턴스 멤버 클래스

[public] class A{
	[public | private] class B{
    	...
    }
}

인스턴스 멤버 클래스 사용

A a = new A();
A.B b = a.new B();

A.B b = new A().new B();

정적 멤버 클래스

[public] class A{
	[public | private] static class B{
    	...
    }
}

정적 멤버 클래스 사용

A.B b = new A.B();

로컬 클래스

생성자 또는 메소드 내부에서 다음과 같이 선언된 클래스

[public] class A{
	//생성자
	public A(){
    	class B {}
    }
    
    //메소드
    public void method(){
    	class B {}
    }
}

* 로컬 변수를 로컬 클래스에서 사용할 경우 로컬 변수는 final 특성을 갖게 되므로 값을 읽을 수만 있고 수정할 수 없게 된다.

바깥 멤버 접근

바깥 클래스의 멤버 접근 제한

바깥 클래스의 객체 접근

바깥클래스이름.this => 바깥객체

중첩 인터페이스

중첩 인터페이스는 클래스의 멤버로 선언된 인터페이스를 말한다.

클래스 내부에 선언하는 이유는 해당 클래스와 긴밀한 관계를 맺는 구현 객체를 만들기 위해서이다.

class A{
	[public | private] [static] interface B{
    	//상수 필드
        //추상 메소드
        //디폴트 메소드
        //정적 메소드
    }
}

익명 객체

익명(Anonymous)객체는 이름이 없는 객체를 말한다.

익명 객체는 클래스를 상속하거나 인터페이스를 구현해야만 생성할 수 있다.

익명 자식 객체

부모클래스를 상속받아 생성.

new 부모생성자(매개값, ...){
	//필드
    //메소드
}

익명 구현 객체

인터페이스를 구현해서 생성. 보통 안드로이드와 같은 UI 프로그램에서 이벤트를 처리하는 객체로 많이 사용된다.

new 인터페이스(){
	//필드
    //메소드
}

인터페이스 역할

인터페이스는 두 객체를 연결하는 역할을 한다.

인터페이스와 구현 클래스 선언

인터페이스는 '~.java'형태의 소스 파일로 작성되고 '~.class'형태로 컴파일되기 때문에 물리적 형태는 클래스와 동일하다.

인터페이스 선언

interface 인터페이스명 {...} //default 접근 제한
public interface 인터페이스명 {...} //public 접근 제한

public interface 인터페이스명{
	//public 상수 필드
    //public 추상 메소드
    //public 디폴트 메소드
    //public 정적 메소드
    //private 메소드
    //private 정적 메소드
}

구현 클래스 선언

public class B implements 인터페이스명{...}

변수 선언과 구현 객체 대입

RemoteControl rc;
RemoteControl rc = null;//인터페이스는 참조 타입에 속하므로 null대입 가능

rc = new Television;
rc.turnOn();

상수 필드

인터페이스는 public static final 특성을 갖는 불변의 상수 필드를 멤버로 가질 수 있다.

public static final은 생략하더라도 자동적으로 컴파일 과정에서 붙게 된다.

[public static final] 타입 상수명 = 값;

public interface RemoteControl{
	int MAX_VOLUME = 10;
    int MIN_VOLUME = 0;
}

추상 메소드

인터페이스는 구현 클래스가 재정의해야 하는 public 추상 메소드를 멤버로 가질 수 있다.

중괄호{}가 붙지 말아야 한다.

public abstract를 생략하더라도 컴파일 과정에서 자동으로 붙게 된다.

[public abstract] 리턴타입 메소드명(매개변수, ...);

디폴트 메소드

인터페이스에는 완전한 실행코드를 가진 디폴트 메소드를 선언할 수 있다. 추상 메소드는 실행부({})가 없지만 디폴트 메소드는 실행부가 있다.

[public] default 리턴타입 메소드명(매개변수, ...){...}

정적 메소드

정적 메소드 선언도 가능하며 객체가 없어도 인터페이스만으로 호출할 수 있다.

[public | private] static 리턴타입 메소드명(매개변수, ...) {...}

private 메소드

다중 인터페이스 구현

구현 객체는 여러 개의 인터페이스를 implements할 수 있다.

public class 구현클래스명 implements 인터페이스A, 인터페이스B{
	//모든 추상 메소드 재정의
}

인터페이스A 변수 = new 구현클래스명(...);
인터페이스B 변수 = new 구현클래스명(...);

인터페이스 상속

인터페이스도 다른 인터페이스를 상속할 수 있으며, 클래스와 달리 다중 상속을 허용한다.

extends 키워드 뒤에 인터페이스들을 나열한다.

public interface 자식인터페이스 extends 부모인터페이스1, 부모인터페이스2 {...}

자식인터페이스 변수 = new 구현클래스(...);
부모인터페이스1 변수 = new 구현클래스(...);
부모인터페이스2 변수 = new 구현클래스(...);

타입 변환

인터페이스의 타입 변환은 인터페이스와 구현 클래스 간에 발생한다.

인터페이스 변수에 구현 객체를 대입하면 자동 타입 변환된다.

인터페이스 타입을 구현 클래스 타입은 강제 타입 변환이 필요하다.

자동 타입 변환

인터페이스 변수 = 구현 객체; //자동 타입 변환

강제 타입 변환

구현 클래스 변수 = (구현클래스) 인터페이스 변수; //강제 타입 변환

상속 개념

상속이란? 부모가 자식에게 물려주는 행위를 말한다.

객체 지향 프로그램에서는 부모 클래스의 필드 및 메소드를 자식 클래스에게 물려줄 수 있다.

public class A{
	int field;
    void method1(){...}
}

public class B extends A{
	String field;
    void method2(){...}
}

B b = new B();
b.field1=10;//상속받은 필드
b.field2=20;
b.method1();//상속받은 메소드
b.method2();

클래스 상속

자식은 물려받을 부모를 선택한다. 부모는 1개만 가능!

public class 자식클래스 extends 부모클래스{

}

부모 생성자 호출

자식 클래스 변수 = new 자식클래스();

//자식 생성자 선언
public 자식클래스(...){
	super();
    ...
}

//자식 생성자 선언2
public 자식클래스(...){
	super(매개값, ...);
}

메소드 재정의

메소드 오버라이딩? 부모 클래스의 모든 메소드가 자식 클래스에 맞게 설계된 것이 아니기 때문에 재정의해서 사용한다.

메소드 오버라이딩의 규칙

- 부모 메소드의 선언부(리터 타입, 메소드 이름, 매개변수)와 동일해야한다.

- 접근 제한을 더 강하게 오버라이딩할 수 없다.(public->private)으로 변경 불가

- 새로운 예외를 throws 할 수 없다.

class Parent{
	void method1(){
    	System.out.println("Parent");
    }
    
    void method2(){
    	System.out.println("Parent");
    }
}

class Child extends Parent{
	void method2(){
    	System.out.prinln("Child");
    }
}

class ChildExample{
	public static void main(Strings[] args){
    	Child c = new Child();
        
        c.method1();//Parent의 메소드1
        c.method2();//Child의 메소드2
    }

}

부모 메소드 호출

메소드 재정의 시 부모 메소드의 일부만 변경된다 하더라고 자식 메소드도 중복된 내용을 갖고 있어야 한다.

중복된 부분은 super()키워드와 도트(.)연산자를 이용한다.

class Parent{
	public void method(){
    ...
    }
}

class Child extends Parent{
	@Override
    public void method(){
    	super().method();
        ...
    }
}

final 클래스와 final 메소드

final 클래스

클래스를 선언할 때 final 키워드를 class 앞에 붙이면 최종적인 클래스이므로 더이상 상속할 수 없다.

즉, final클래스는 부모 클래스가 될 수 없어 자식 클래스를 만들 수 없다.

public final class 클래스{...}


//대표적인 예
public final class String {...}

protected 접근 제한자

타입 변환

자동 타입 변환

부모타입 변수 = 자식타입객체;

Cat cat = new Cat();
Animal animal = cat;

강제 타입 변환

자식타입 변수 = (자식타입) 부모타입객체;

Parent parent = new Child();
Child child = (Childe)parent;

다형성

다형성이란? 사용방법은 동일하지만 실행 결과가 다양하게 나오는 성질을 말한다.

상속으로 인해 부모의 메소드를 오버라이딩을 하면서 다양하게 수정해서 사용할 수 있다.

필드 다형성

필드 타입은 동일하지만, 대입되는 객체가 달라져서 실행결과가 다양하게 나옴.

public class Car{
	public Tire tire;
    
    public void run(){
    	this.roll();
        //tire필드에 대입된 객체의 roll()메소드를 실행. 
        //만약 Tire을 상속받은 hankook, kumho가 roll()메소드를 재정의하고 있다면, 그 roll()이 호출됨.
    }
}

매개변수 다형성

메소드가 매개변수로 클래스 타입을 갖고 있을 때도 다형성이 발생한다.

public class Driver{
	public void drive(Vehicle vehicle){
    	vehicle.run();
        //매개값으로 받은 vehicle의 run()을 실행할텐데
        //매개변수로 받은 객체가 Vehicle을 상속받아 run()을 재정의하고 있다면,
        //그 run()을 실행한다.
    }
}

객체 타입 확인

boolean result = 객체 instanceof 타입;

public void method(Parent parent){
	if(parent instanceof Child){
    	Child child =(Child)parent;
    }
}

추상 클래스

추상 클래스란?

객체를 생성할 수 있는 실체 클래스의 공통적인 필드나 메소드를 추출해서 선언한 클래스

Animal animal = new Animal(); //X

추상 클래스는 객체를 직접 생성할 수 없다.

추상 클래스 선언

pubic abstract class 클래스명{
//필드
//생성자
//메소드
}

추상 메소드와 재정의

abstract 리턴타입 메소드명(매개변수,...);

public abstract class Animal{
	abstract void sound();
}

봉인된 클래스

JAVA15 부터 무분별한 자식 클래스 생성을 방지하기 위해 봉인된(sealed) 클래스가 도입되었다.

public sealed class Person permits Employee, Manager {...}

Person의 자식 클래스는 Employee와 Manager만 가능하다.

인스턴스 멤버

인스턴스 멤버 선언 및 사용

public class Car{
	//인스턴스 필드 선언
    int gas;
    
    //인스턴스 메소드 선언
    void setSpeed(int speed) { ... }
}

Car myCar = new Car();
myCar.gas =10;
myCar.setSpeed(60);

Car yourCar = new yourCar();
yourCar.gas = 20;
yourCar.setSpeed(80);

=> 외부 클래스에서 사용하기 위해서는 Car객체를 먼저 생성하고 참조 변수로 접근해서 사용해야 한다.

this 키워드

: 객체 내부에서 인스턴스 멤버에 접근하기 위해 this사용. 객체는 자기 자신을 'this'라고 한다.

public class Car{
	//필드 선언
	String model;
    int speed;
    
    Car(String model){
    	this.model = model; //매개변수를 필드에 대입.(this 생략 불가)
    }
    
    void setSpeed(int speed){
    	this.speed=speed;
    }
    
    void run(){
    	this.setSpeed(100); //this 생략 가능
        System.out.println(this.model + "가 달립니다. (시속: " + this.speed + ")");
    }
}

정적 멤버

정적 멤버란 메소드 영역의 클래스에 고정적으로 위치하는 멤버를 말한다. 객체 생성 없이 바로 사용 가능.

정적 멤버 선언

필드와 메소드는 모두 정적 멤버가 될 수 있음. static 키워드 추가.

public class 클래스 {
	//정적 필드 선언
    static 타입 필드 [= 초기값];
    
    //정적 메소드
    static 리턴타입 메소드(매개변수,...){
    	...
    }
}

정적 멤버 사용

클래스 이름과 함께 도트(.) 연산자로 접근한다.

public class Calculator {
	static double pi = 3.141592;
    static int plus(int x, int y){ ... }
    static int minus(int x, int y){ ... }
}

double result1 = 10 * 10 * Calculator.pi;
int result2 = Calculator.plus(10,5);
int result3 = Calculator.minus(10,5);

정적 블록

//정적 블록 형태
static {
...
}

public class Television {
	static String company ="MyCompany";
    static String model = "LCD";
    static String info;
    
    static{
    	info = company + "-" + model;
    }
}

public class TElevisionExample {
	pulic static void main(Strings[] args){
    	System.out.println(Television.info);
    }
}

인스턴스 멤버 사용 불가

정적 메소드/블록은 객체가 없어도 실행된다는 특징 때문에 내부에 인스턴스 필드/메소드를 사용할 수 없다.

또한 객체 자신의 참조인 this도 사용 불가.

final 필드와 상수

final 필드 선언

final = 최종적. final 필드는 초기값이 저장되면 이것이 최종적인 값이 되어 수정할 수 없다.

final 타입 필드 [=초기값];

* 초기값을 줄 수 있는 방법

1) 필드 선언 시에 초기값 대입

2) 생성자에서 초기값 대입

상수 선언

상수는 불변값으로 static이면서 final인 특성을 가져야 한다.

상수 이름은 대문자로 작성하고 단어혼합일 경우 _로 연결한다.

static final 타입 상수;
static{
	상수 = 초기값;
}

static final double PI = 3.14159;
static fianl double EARTH_AREA = 5.147185403;

패키지

클래스는 패키지 안에 생성해서 관리한다. 디렉토리만을 의미하지 않으며 클래스의 일부분이다.

패키지 선언

역순으로 쓰며 소문자로 작성한다.

package 상위패키지.하위패키지;

public class 클래스명 {...}

com.samsung.projectname
com.lg.projectname
org.apache.projectname

import

다른 패키지에 있는 클래스를 사용하려고 할 때 쓴다.

package com.mycompany;

import com.hankook.Tire;

pubic class Car{
	Tire tire = new Tire();
}

만약 동일한 패키지에포함된 다수의 클래스를 사용해야 한다면 클래스명 대신 *로 표현한다.

import com.hankook.*;
import com.kankook.project.*;

접근 제한자

클래스의 접근 제한

클래스는 public과 default 접근 제한을 가질 수 있다.

[public] class 클래스 { ... }

생성자의 접근 제한

생성자는 public, default, private 접근 제한을 가질 수 있다.

pubic class ClassName{
	[public | private] ClassName(){...}
}

필드와 메소드의 접근 제한

필드와 메소드는 public, default, private 접근 제한을 가질 수 있다.

//필드 선언
[public | private] 타입 필드;

//메소드 선언
[public | private] 리턴타입 메소드(...){...}

Getter와 Setter

객체의 필드를 외부에서 마음대로 읽고 변경할 경우 무결성이 깨질 수 있다.

필드를 private 접근 제한을 갖게 하여 외부에서 접근하지 못하도록 하고 get/set 메소드를 이용하게 한다.

private 타입 fieldName;

public 타입 getFieldName(){
	return fieldName;
}

public 타입 setFieldName(타입 fieldName){
	this.fieldName = fieldName;
}

싱글톤 패턴

애플리케이션 전체에서 단 한 개의 객체만 생성해서 사용하고 싶다면 싱글톤 패턴을 적용한다.

생성자를 private 접근 제한해서 외부에서 new 연산자로 생성자를 호출할 수 없도록 막는 것이다.

public class 클래스{
	//private 접근 권한을 갖는 정적 필드 선언과 초기화
	private static 클래스 singleton = new 클래스();
    
    //private 접근 권한을 갖는 생성자 선언
    private 클래스(){}
    
    //public 접근 권한을 갖는 정적 메소드 선언
    public static 클래스 getInstance(){
    	return singleton;
    }
}

객체 지향 프로그래밍

객체란?

물리적으로 존재하거나 개념적인 것 중에서 다른 것과 식별 가능한 것.

속성과 동작으로 구성.

객체 간의 관계

-집합 관계: 완성품과 부품의 관계

-사용 관계 : 다른 객체의 필드를 읽고 변경하거나 메소드를 호출하는 관계

-상속 관계 : 부모와 자식 관계.

객체 지향 프로그래밍의 특징

-캡슐화 : 객체의 데이터, 동작을 하나로 묶고 실제 구현 내용을 외부에 감추는 것. 접근 제한자 사용

-상속 : 부모 객체는 자기가 갖고 있는 필드와 메소드를 자식 객체에게 물려주어 자식 객체가 사용할 수 있도록 한다.

=>코드의 재사용성을 높여줌

=>유지 보수 시간을 최소화 시켜줌

-다형성 : 실행 결과가 다양하게 나오게 해주는 성질. 자동 타입 변환과 재정의 기술 필요.

객체와 클래스

-객체를 생성하려면 클래스가 필요.

-클래스로부터 생성된 객체를 해당 클래스의 인스턴스라고 부른다.

-인스턴스화 : 클래스로부터 객체를 만드는 과정.

클래스 선언

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

객체 생성과 클래스 변수

클래스 변수 = new 클래스();

Student s1 = new Student();
System.out.println("s1변수는 Student 객체 참조.");

Student s2 = new Student();
System.out.println("s2변수는 또다른 Student 객체 참조");

클래스의 구성 멤버

- 필드 : 객체의 데이터가 저장되는 곳

- 생성자 : new 연산자로 객체를 생성할 때 초기화 역할을 담당.

- 메소드 : 객체가 수행할 동작.

public class ClassName{
	//필드 선언
    int fieldName;
    
    //생성자 선언
    ClassName(){...}
    
    //메소드 선언
    int methodName(){...}
}

필드 선언과 사용

필드 선언

타입 필드명 [ = 초기값 ];

public class Car{
	//필드 선언
    String model;
    boolean start;
    int speed;
}

필드 사용

[외부 객체에서 필드 사용]
void method(){
	//Car 객체 생성
    Car myCar = new Car();
    //필드 사용
    myCar.speed=60;
}

[내부 객체에서 필드 사용]
int speed;
//생성자에서 사용
Car(){
	speed= 60;
}

//메소드에서 사용
void method(...){
	speed=60;
}

생성자 선언과 호출

기본 생성자

[public] 클래스(){...}

생성자 선언

public class Car{
	//생성자 선언
    Car(String model, String color, int maxSpeed){...}
}

필드 초기화

public class Korean{
	//필드 선언
    String nation ="대한민국";
    String name;
    String ssn;
    
    Korean(String name, String ssn){
    	this.name=name;
        this.ssn=ssn;
    }
}

생성자 오버로딩

매개값으로 객체의 필드를 다양하게 초기화하려면 생성자 오버로딩 필요.

매개변수를 달리하는 생성자를 여러 개 선언하는 것을 말한다.

public class Car{
	Car(){...}
    Car(String model){...}
    Car(String model, String color){...}
    Car(STring model, String color, int maxSpeed){...}
}

다른 생성자 호출

생성자 오버로딩이 많아질 경우 생성자 간의 중복된 코드가 발생할 수 있다.

따라서 공통 코드를 한 생성자에게만 집중작성하고, 나머지 생성자는 this()를 사용한다.

Car(String model){
	this(model, "은색", 250);
}

Car(String model, String color){
	this(model, color, 250);
}

Car(String model, String color, int maxSpeed){
	this.model = model;
    this.color = color;
    this.maxSpeed = maxSpeed;
}

메소드 선언과 호출

메소드 선언

리턴 타입 메소드명 (매개변수1, ... ){

         실행 블록...

}

리턴 타입

리턴 타입은 메소드가 실행한 후 호출한 곳으로 전달되는 결과값의 타입을 말한다.

리턴값이 없을 때는 void로 작성!

void powerOn() { ... } //리턴값이 없는 메소드 선언
double divide(int x, int y){ ... } //double타입 값을 리턴하는 메소드 선언

메소드명

메소드명은 첫 문자를 소문자로 시작하고, 캐멀스타일로 작성한다.

*캐멀스타일 : 단어 연결할 때 두번째 단어의 첫 글자를 대문자로!

void run(){ ... }
void setSpeed(int speed){ ... }
String getName(){ ... }

매개변수

메소드를 호출할 때 전달한 매개값을 받기 위해 사용. 생략 가능

double divide(int x, int y){ ... }

실행블록

publi class calculator {
	//리턴값이 없는 메소드 선언
    void powerOn(){
    	System.out.println("전원을 켭니다.");
    }
}

void method(){
	Calculator c = new Calculator();
    c.powerOn();
}

메소드 호출

메소드 블록을 실행하는 것을 말한다. 객체가 존재해야 호출할 수 있다.

타입 변수 = 메소드();

//외부 객체에서 선언
void method(){
	Calculator calc = new Calculator();
    calc.powerOn();
    int r1 = calc.plus(3,5);
    double r2 = calc.divide(15,3);
}

//객체 내부에서 선언
Calculator(){
	powerOff();
}

void powerOn(){ ... }
void powerOff(){ ... }
int plus(int x, int y){ ... }
double divide(int x, int y){ ... }

void method() {
	powerOn();
    int r1 = plus(3,5);
    double r2 = divide(15,3);
}

가변길이 매개변수

매개변수의 개수에 맞게 매개값을 제공해야함.

만약 메소드가 가변길이 매개변수를 갖고 있다면 매개변수 개수와 상관없이 매개값 전달 가능.

int sum(int ... values){

}

int result = sum(1,2,3);
int result = sum(1,2,3,4,5);

int[] values = {1,2,3};
int result = sum(values);

int result2 = sum(new int[] {1,2,3);
//매개값들이 자동으로 배열 항목으로 변환되기 때문에 배열을 매개값으로 전달 가능

return 문

return은 메소드의 실행을 강제 종료하고 호출한 곳으로 돌아간다는 의미.

메소드 타입이 있을 경우 return 문 뒤에 맞는 리턴값 추가.

return [리턴값];

메소드 오버로딩

메소드 이름은 같되 매개변수의 타입, 개수, 순서가 다른 메소드를 여러개 선언하는 것.

void println(){...}
void pintln(double x){...}
void println(int x){...}
void println(String s){...}
void println(int x, double y){...}

변수 선언

변수란? 하나의 값을 저장할 수 있는 메모리 번지에 붙여진 이름

int age;//정수(int) 값을 저장할 수 있는 age 변수 선언
double value; //실수(double) 값을 저장할 수 있는 value 변수 선언

캐멀 스타일: 여러 단어를 혼합하여 쓸 때 대문자가 섞여있도록 작성하는 것.

=>변수 이름은 첫 번째 글자가 문자여야 하고, 문자, 숫자, &, _를 포함할 수 있다. 캐멀 스타일로 작성.

int score; //변수 선언
score = 90; //값 대입

정수 타입

문자 타입

문자 리터럴 : 작은따옴표(')로 감싼 것. char 타입은 유니코드를저장한다.

char var1 = 'A'; //'A'문자와 매필되는 숫자:65로 대입
char var2 = '가'; //'가'문자와 매핑되는 숫자:44032로 대입

실수 타입

double var = 3.14;
double var = 314e-2;

float var = 3.14f;
float var = 3E6F;

논리 타입

참과 거짓을 의미하는 true / false로 대입. 기본 초기화값은 false.

boolean stop = true;
boolean stop = false;

문자열 타입

작은따옴표(')로 감싸는 char타입과 다르게 큰따옴표(")로 감싸고 문자열이라 부른다.

String var1 = "A";
String var2 = "홍길동";

이스케이프 문자

자동 타입 변환

강제 타입 변환

연산식에서 자동 타입 변환

문자열을 기본 타입으로 변환

변수 사용 범위

콘솔로 변수값 출력

키보드 입력 데이터를 변수에 저장

.이클립스 설치 윈도우랑 맥

환경 변수 설정하기