Roopretelcham

Proxy : 대리

Proxy는 JavaScript에서 객체의 기본 동작(예: 속성 접근, 할당, 열거, 함수 호출 등)을 사용자 정의 동작으로 가로채서(trap) 조작할 수 있게 해주는 기능입니다.

즉, 객체에 대한 작업을 가로채서 그 작업이 수행되기 전, 수행된 후, 또는 작업을 완전히 대체하여 추가적인 로직을 실행할 수 있게 해줍니다. 이런 특징 때문에 Proxy는 다양한 고급 작업과 패턴에 유용하게 사용될 수 있습니다.

const target = {
  message1: "hello",
  message2: "everyone",
};

const handler1 = {};

const proxy1 = new Proxy(target, handler1);

proxy1.message1 = 'hi';
console.log('target', target);

위의 코드에서 target의 message1 속성의 값은 hi로 변경되게 된다.

아래 예제를 통해 Proxy로 할 수 있는 다양한 가능성을 살펴보겠다.

1. 속성 읽기 접근 제어

속성을 읽을 때마다 로그를 출력하도록 합니다. get은 속성값을 가져오기 위한 trap(가로채기)이다.

(...)
const handler1 = {
  get(target, prop, receiver) {
    console.log(`속성 '${prop}'에 접근함`);
    return Reflect.get(...arguments);
  }
};

const proxy1 = new Proxy(target, handler1);

console.log(proxy1.message1); // 속성 'message1'에 접근함 -> hello
console.log(proxy1.message2); // 속성 'message2'에 접근함 -> everyone

Proxy는 반드시 new 키워드로만 생성가능하다.

2. 속성 쓰기 접근 제어

속성에 값을 할당할 때 유효성 검사를 추가합니다. 예를 들어, message1에는 오직 문자열만 할당될 수 있게 합니다.

(...)
const handler1 = {
    set(target, prop, value) {
        if (prop === "message1" && typeof value !== "string") {
            throw new Error("message1은 문자열이어야 합니다.");
        }
        target[prop] = value;
        return true; // 성공적으로 값을 할당했음을 나타냄
    }
};

const proxy1 = new Proxy(target, handler1);

proxy1.message1 = "안녕하세요"; // 성공
try {
    proxy1.message1 = 123; // Error: message1은 문자열이어야 합니다.
} catch (e) {
    console.error(e.message);
}

3. 속성 존재 여부 확인

객체에 특정 속성이 있는지 확인할 때마다 로그를 출력합니다.

const handler1 = {
  has(target, prop) {
    console.log(`${prop} 속성이 객체에 존재하는지 확인`);
    return prop in target;
  }
};

const proxy1 = new Proxy(target, handler1);

console.log('message1' in proxy1); // message1 속성이 객체에 존재하는지 확인 -> true
console.log('message3' in proxy1); // message3 속성이 객체에 존재하는지 확인 -> false

이외에도 다양한 Handler Function을 통해 객체의 기본동작을 정의하고 유연하게 사용할 수 있다.

Proxy생성자와 Handler Function에 대해서는 다음 문서를 참고

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/Proxy

finally 블록을 추가하면 try문에서 return을 해도 무조건 실행된다!

public class Ex4 {

	public static void main(String[] args) {
		try {
			inputScore(101);
		} catch (InvalidScoreException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	// throws로 예외처리의 책임을 상위로 위임함
	public static void inputScore(int score) throws InvalidScoreException {

		if (score < 0 || score > 100) {
        	// 사용자정의 예외클래스로 예외 발생
			throw new InvalidScoreException("0 ~ 100사이의 정수만 입력하셈");
		}
	}

}

// Exception(상위 예외클래스)를 상속하는 사용자정의 예외클래스
class InvalidScoreException extends Exception {

	public InvalidScoreException(String message) {
		super(message);
		// TODO Auto-generated constructor stub
	}

}

이클립스에서 웹 프로젝트 시 Unable to compile class for JSP: 나

java.lang.ClassNotFoundException 오류가 뜰 때가 있다.

[해결법]

첫번째 방법

Project - Clean 

두번째 방법

Project - Properties - Java Build Path - Order and Export - JRE System Library 에 체크 후 Apply

세번째 방법

Project - Build Automatically 가 체크해제 되어있으면 체크

추상(abstract)

추상(abstract)는 공통적인 특성을 정의하여 구체적인 부분은 자식클래스에서 정의하도록 하는 것이다.

이때 공통되는 특성을 가진 상위클래스를 추상 클래스, 이를 상속해 구체화하는 서브클래스는 실체화 클래스라고도 한다.

추상 클래스

추상 클래스는 new를 하지 못한다. (인스턴스 생성불가)

추상클래스는 멤버변수, 생성자, 일반메서드, 추상메서드를 가질 수 있다.

public class Ex3 {
	public static void main(String[] args) {
    	// Cannot instantiate the type AbstractClass
//		AbstractClass abstractClass = new AbstractClass();
	}
}

추상 메소드

서브클래스의 오버라이딩을 강제할 목적으로 정의하는 메서드로 외부에서 호출되지 않는다. 
모양은 동일하고 수행할 코드가 다른 메서드를 서브클래스에서 상속받아 오버라이딩하도록 강제성을 부여한다.

이전에 다형성에서 살펴봤지만 상속관계에서 오버라이딩이 기본적으로 강제되지는 못한다. 하지만 추상을 이용하면 이를 강제할 수 있는 것이다.

rutel.tistory.com/343

추상메소드는 아래와 같이 abstract 키워드를 사용하며 body (중괄호) 가 없이 세미콜론으로 선언한다.

[접근제한자] abstract 리턴타입 메서드명 ( [파라미터...] );

추상메소드는 반드시 추상 클래스 내에서만 정의 가능하다. 단, 모든 추상클래스가 추상메서드를 포함하는 것은 아니다

abstract class AbstractClass {
	public abstract void abstractMethod();
}

추상 클래스를 상속하는 클래스

추상클래스를 상속하는 클래스는 반드시 추상메소드를 재정의(override) 해 구현(implements)하거나

// The type SubClass must implement the inherited abstract method 
// AbstractClass.abstractMethod()
class SubClass extends AbstractClass { }	// error!

메소드 재정의(method override)하지 않을 경우 추상클래스로 선언해야 한다.

abstract class SubClass extends AbstractClass { }

final variable

값을 변경할 수 없으며 멤버변수에 초기화 값이 없을 시 (blank final), 생성자를 통해 초기화해야한다.

final 변수 이름은 모두 대문자를 쓰는 것이 기본 코딩스타일이다. (공백이나 단어구분시 언더스코어 _ 사용)

public class Ex {

	public static void main(String[] args) {
		FinalVariable f = new FinalVariable();
//		f.NUM1 = 10;
		f.num2 = 20;
		
		FinalVariable2 f2 = new FinalVariable2(100);
		FinalVariable2 f3 = new FinalVariable2(9098);
		
		System.out.println(f2.NUM1 + ", " + f2.NUM2);
		System.out.println(f3.NUM1 + ", " + f3.NUM2);
	}

}

class FinalVariable {
	final int NUM1 = 10;
	int num2 = 20;
	
	public void setNum() {
//		NUM1 = 99;
		num2 = 99;
	}
}

class FinalVariable2 {
	final int NUM1 = 30;
	final int NUM2;
	
	public FinalVariable2(int nUM2) {		
		NUM2 = nUM2;
	}
}

Output :

30, 100
30, 9098

final method

: 상속받은 메소드를 그대로 사용해야하며 오버라이딩이 금지된다

class FinalMethod {
	public void normalMethod() {
		
	}
	
	public final void finalMethod() {
		System.out.println("super class method");
	}
}

class SubFinalMethod extends FinalMethod {

	@Override
	public void normalMethod() { }	
	// Cannot override the final method from FinalMethod
//	public final void finalMethod() { }
}

final 클래스

: 클래스의 상속(is-a 관계)이 불가능하다.

final class FinalClass {

}

// The type subfinal cannot subclass the final class FinalClass
//class subfinal extends FinalClass {
//	
//}

: 대신 포함관계 (has-a)는 가능

final class FinalClass {
	public void method() {

	}
}

class SubFinalClass {
	FinalClass finalClass = new FinalClass();

	public void method() {
		finalClass.method();
	}
}

상수(Constant)

불변의 값. static final 키워드를 붙여서 표현
static 키워드에 의해 클래스명만으로 접근이 가능하며 모든 인스턴스가 하나의 값을 공유

class Car {
	private String company;    
	public static final String COMPANY_HYUNDAI = "HYUNDAI";
    
    public String getCompany() {
		return company;
	}
	public void setCompany(String company) {
		this.company = company;
	}
}

잘못된 값 입력확률을 줄이고 미리 정의된 값을 쉽게 가져다 쓸 수 있다.

public class Ex2 {
	public static void main(String[] args) {		
		Car car = new Car();		
		car.setCompany(Car.COMPANY_HYUNDAI);
		
		if(car.getCompany().equals(Car.COMPANY_HYUNDAI)) {
			System.out.println("현대자동차");
		} 
	}
}

상수는 생성자에서 초기화 될 수 없다. static은 인스턴스 생성전에 초기화되기 때문

 [ 클래스의 관계 ]

 1. Has-A 관계(포함 관계)
   => A has a B = A 가 B 를 가지고 있다 = B가 A에 포함되어 있다.
   => 일반적인 클래스의 관계이며, 특정 클래스 내에
        다른 클래스를 포함시켜 사용하는 관계
    ex) class A {
     B b = new B();
    }
2. Is-A 관계(상속 관계)
    => A is a B = A 는 B 이다 = A 는 B 를 상속받은 관계이다. (자신 포함)
    => 초등학생은 학생이다 = 초등학생 is a 학생(O)
       컴퓨터는 기계장치이다 = 컴퓨터 is a 머신(O)
       학생은 학생이다 = 학생 is a 학생(O)
    => 스파이더맨은 사람이다(O)
       사람은 스파이더맨이다(X)
    ex) class A extends B {}
  

 [ instanceof 연산자 ]

 - 좌변의 객체(참조변수)가 우변의 클래스 타입(상속관계)인지 판별하는 연산자
 - 주로 if문에 결합하여 판별하는데 사용되며
  판별 결과가 true 이면 형변환이 가능한 관계(업캐스팅 또는 다운캐스팅)
판별 결과가   false 이면 절대로 형변환 불가능
  
 < 기본 문법 >
 if(A instanceof B) {}
 => A는 참조변수(인스턴스), B는 클래스명

public class Ex {

	public static void main(String[] args) {		
		SmartPhone sp = new SmartPhone();
		// 참조변수 sp 로 접근 가능한 SmartPhone 객체의 메서드 : 3개
		sp.call();
		sp.sms();
		sp.kakaoTalk();
		
		if (sp instanceof SmartPhone) {
			System.out.println("sp is a smartphone");
		}
		
		System.out.println("=========================");
		
		if (sp instanceof HandPhone) {
			System.out.println("sp is a HandPhone");
			HandPhone hp = sp;
			hp.call();
			hp.sms();			
		}
		else {
			System.out.println("sp is not a HandPhone");
		}
		
		System.out.println("=========================");
		
		HandPhone hp = new HandPhone();
		hp.call();
		hp.sms();
		
		if (hp instanceof HandPhone) {
			System.out.println("hp is a HandPhone");			
			HandPhone handPhone = hp;
		}
		
		System.out.println("=========================");
		
		if (hp instanceof SmartPhone) {
			System.out.println("hp is a SmartPhone");
		}
		else {
			System.out.println("hp is not a SmartPhone");
//			SmartPhone sp2 = (SmartPhone)hp;
		}
		
		HandPhone hp2 = new SmartPhone();
		hp2.call();
		hp2.sms();
		
		if (hp2 instanceof HandPhone) {
			System.out.println("hp2 is HandPhone");			
		}
		if (hp2 instanceof SmartPhone) {
			System.out.println("hp2 is SmartPhone");
			
		    SmartPhone sp2 = (SmartPhone) hp2;
		    sp2.sms();
		    sp2.kakaoTalk();
		}
		else {
			System.out.println("hp2 is not a SmartPhone");
		}
		
		System.out.println("==========================");
		Child c = new Child();
		
//		Parent p = c;
//		p.parentPrn();
		
		if (c instanceof Parent) {
			System.out.println("c is a Parent");
			Parent p = c;
			p.parentPrn();
		}
		
		Parent p2 = new Parent();
		
		if (p2 instanceof Child) {
			System.out.println("p2 is a Child");
		} else {
			System.out.println("p2 is not a Child");
		}
	}

}

// HandPhone 과 Battery 의 관계는 has-a 관계이다.
class Battery {}

class HandPhone {
	Battery better = new Battery();
	
	public void call() {
		System.out.println("전화!");
	}
	
	public void sms() {
		System.out.println("문자!");
	}
}

// HandPhone 과 SmartPhone 의 관계는 상속관계이다.
class SmartPhone extends HandPhone {
	public void kakaoTalk() {
		System.out.println("카톡!");
	}
}

class Parent {
	public void parentPrn() {
		System.out.println("parentPrn");
	}
}

class Child extends Parent {
	public void childPrn() {
		System.out.println("childPrn");		
	}
}

상속관계의 오버라이딩

 - 슈퍼클래스의 메서드를 서브클래스에서 오버라이딩 하는 경우
   슈퍼클래스의 메서드는 은닉됨  
 

동적 바인딩 (Dynamic Binding)

 - 상속 관계에서 업캐스팅 후 상속된 메서드를 호출하여 실행할 때
   컴파일(번역) 시점에서의 실행 대상과 실제 실행 단계에서의 실행 대상이 달라지는 것(동적으로 변하는 것)
- 참조 변수의 데이터타입과 무관하게 실제 인스턴스에 따라 실행되는 메서드가 달라짐

public class Ex2 {

	public static void main(String[] args) {
		
		Parent2 p = new Parent2();
		p.parentPrn();
		
		p = new Child2(); // 업캐스팅
		// 참조변수 p 는 Parent2 클래스 타입의 변수이지만
		// 저장된 인스턴스 주소는 Child2 클래스 타입의 인스턴스이다.
		// 따라서, 참조변수 p 를 통해 접근하는 실제 인스턴스는 Child2 이므로
		// p.parentPrn() 메서드를 호출하면 실행되는 메서드도 Child2 의 메서드이다!
		p.parentPrn();
	}

}

class Parent2 {
	public void parentPrn() {
		System.out.println("슈퍼클래스의 parentPrn()");
	}
}

class Child2 extends Parent2 {	
	public void childPrn() {
		System.out.println("서브클래스의 childPrn()");
	}

	@Override
	public void parentPrn() {
		System.out.println("서브클래스에서 오버라이딩 된 parentPrn()");
	}	
}

다형성(Polymorphism)

- 하나의 참조변수로 여러 인스턴스를 참조하는 것
= 인스턴스를 다양한 형태로 변환하는 것
= 인스턴스를 업캐스팅하여 슈퍼클래스 타입으로 서브클래스의 멤버 접근

public class Ex3 {

	public static void main(String[] args) {
		Circle c = new Circle();
		c.circleDraw();
		
		Rectangle r = new Rectangle();
		r.paint();
		
		Triangle t = new Triangle();
		t.design();
		
		System.out.println("===================");
		c.draw();
		r.draw();
		t.draw();
		System.out.println("===================");
		
		Shape s;		
		s = c;
		s.draw();
		
		s = r;
		s.draw();
		
		s = t;
		s.draw();
	}

}

class Shape { // 도형 클래스
	// 공통적으로 도형을 그릴 수 있는 draw() 메서드 정의
	public void draw() {
		System.out.println("도형 그리기!");
	}
}

class Circle extends Shape {
	public void circleDraw() {
		System.out.println("원 그리기!");
	}

	@Override
	public void draw() {
		System.out.println("원 그리기!");
	}
	
}

class Rectangle extends Shape {
	public void paint() {
		System.out.println("사각형 그리기!");
	}
	
	@Override
	public void draw() {
		System.out.println("사각형 그리기!");
	}
}

class Triangle extends Shape {
	public void design() {
		System.out.println("삼각형 그리기!");
	}
	
	@Override
	public void draw() {
		System.out.println("삼각형 그리기!");
		
	}
}

Output : 

원 그리기!
사각형 그리기!
삼각형 그리기!
===================
원 그리기!
사각형 그리기!
삼각형 그리기!
===================
원 그리기!
사각형 그리기!
삼각형 그리기!

ex) 다형성은 아래와 같이 메소드의 파라미터를 통해서도 활용할 수 있다.

: 파라미터로 Circle, Rectangle, Triangle 인스턴스 전달 -> Shape 타입으로 업캐스팅됨

public class Ex3 {
	public static void main(String[] args) {		
		drawShape(new Circle());
//		drawShape(new Rectangle());  
		polymorphismDrawShape(new Circle());
		polymorphismDrawShape(new Rectangle());
		polymorphismDrawShape(new Triangle());
	}
	
	public static void drawShape(Circle c) {
		c.draw();
	}
	
	public static void polymorphismDrawShape(Shape s) {
		s.draw();
	}
}

class Shape { // 도형 클래스
	// 공통적으로 도형을 그릴 수 있는 draw() 메서드 정의
	public void draw() {
		System.out.println("도형 그리기!");
	}
}

class Circle extends Shape {
	@Override
	public void draw() {
		System.out.println("원 그리기!");
	}
	
}
(...)

ex) 다형성을 배열에 활용하는 경우 (업캐스팅)

	Circle[] cArr = new Circle[3];
		cArr[0] = new Circle();
//		cArr[1] = new Rectangle();
		
		Shape[] sArr = new Shape[3];
		sArr[0] = new Circle();
		sArr[1] = new Rectangle();
		sArr[2] = new Triangle();
		
		for (Shape shape : sArr) {
			shape.draw();
		}

사실 이건 자막 파일에서 시간정보만 빼고 추려내기 위해 만든 소스인데

containString을 수정해서 응용하기 나름일 듯 합니다

import java.util.List;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class FileReadWrite {

	public static void main(String[] args) {
		
		String readPath = "C:\\Users\\rutel\\Downloads\\sub.vtt";
		String newPath = "C:\\Users\\rutel\\Downloads\\sub.txt";
		String containString = "-->";
		
		//파일 객체 생성
        Path path = Paths.get(readPath);
        // 캐릭터셋 지정
        Charset cs = StandardCharsets.UTF_8;
        //파일 내용담을 리스트
        List<String> list = new ArrayList<String>();
        // 새 파일 내용담을 리스트
        List<String> nlist = new ArrayList<String>();
        try{
            list = Files.readAllLines(path,cs);
        }catch(IOException e){
            e.printStackTrace();
        }
        for(String readLine : list){
            //System.out.println(readLine);
        	if (readLine.contains(containString)) {
        		continue;
        	}
        	else {
        		nlist.add(readLine);
        	}
        }
        // 새 파일 내용쓰기
        try{
            //파일 객체 생성        	
            File file = new File(newPath);
            BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file));
            
            if(file.isFile() && file.canWrite()){
            	for(String readLine : nlist){
            		//쓰기
                    bufferedWriter.write(readLine);
                    //개행문자쓰기
                    bufferedWriter.newLine();
            	}
                
                bufferedWriter.close();
            }
        }catch (IOException e) {
            System.out.println(e);
        }
        
        System.out.println("작업 완료");
	}

}

0. 데이터타입 기초

0-1) 비트 ( bit = binary degit )

- 이진수의 하나의 자릿수를 나타내며 0과 1을 의미

- 컴퓨터에서 0은 전류가 흐르지 않는 상태, 1은 그 반대이다.

  또는 0은 거짓, 1은 참을 의미하기도 한다.

0-2) 진법 (Base N)

- 수를 셀 때, 자릿수가 올라가는 단위를 기준으로 하는 셈법의 총칭

- 일상에서 가장 보편적으로 사용하는 것은 10진법으로 (0~9의 범위를 가진다)

- 컴퓨터에서 사용하는 진법은 2진법으로 0과 1

- 8진법은 0~7, 16진법은 0~15까지의 수를 사용하는 진법이다.

단, 16진법은 9이후를 10으로 표기하지 않고 A로 표기한다. (A~F)

0-3) 진법 변환

- 10진법 -> 2진법 (소인수분해)

몫과 나머지를 쓰고 나머지를 마지막나머지 + 밑에서부터 차례대로 붙여가면 된다.

바꾼 값의 결과는 아래와 같으며 해당 수의 진법 표기는 괄호안에 적는다. (10)은 10진법 표기

13 ₍₁₀₎ -> 01101 ₍₂₎

- 8진법 -> 10진법 (자릿수 변환)

0307 ₍₈₎

(3 x 8²) + (0x8¹) + (7 x 8⁰) = 199 ₍₁₀₎    // 0승은 항상 1

0-4) 리터럴

소스코드에서 프로그래머에 의해 직접 입력된 값, 자바에서 실제 처리하는 데이터

1. 기본 데이터 타입

- 자바에서의 기본테이터 타입 (반대는 참조데이터 타입) 은 아래 8가지이다.

- 타입이름은 모두 소문자임에 유의

- 1Byte 는 8 bit이다.

   즉 0000 0000₍₂₎ ~ 1111 1111_{(2) 의 값을 표현을 가진다.}

        1Byte    2Byte    4Byte    8Byte
        (8bit)   (16bit)    (32bit)   (64bit)
-----------------------------------------
정수형   byte     short    int      long
실수형                      float    double
문자형              char  --- 실제로 char(캐릭터) 타입은 정수형에 포함되나 이는 뒤에서 설명
논리형  boolean

char는 ushort, int, uint, long, uyong, float, double 또는 10진수로 암시적으로 변환될 수 있다. 그러나 다른 유형에서 char 유형으로의 암묵적 변환은 없다.

1) 정수형(Interger Type)

저장되는 값의 허용범위 (char타입은 음수값을 포함하지 않으므로 제외)

n = 메모리bit수 - 1   (ex : 8bit크기는 8 - 1 = 7)
  -2^n ~ (2n-1)

byte : -128 ~ 127    | 0포함,  -2^7 ~ (2^7-1)

short : -32768 ~ 32,767

char : 0 ~ 65536 (유니코드) | 0 ~ (2^16-1)

int : 약 -21억 ~ 21억 | -2^31 ~ (2^31-1)

long : 약 -922경 ~ 922경

1-2) 정수 리터럴 표현

- 2진수 : 0b1011  (맨앞은 숫자 0)

- 8진수 : 013       (맨앞은 숫자 0)

- 10진수 : 365     (소수점없는 10진법 숫자)

- 16진수 : 0x3B0F (맨앞은 숫자 0)

- long타입 (기본적으로 자바 컴파일러는 정수 리터럴을 int타입으로 간주한다!)

long l = 12_345_678_999;	// int타입으로 간주해서 타입이 맞지 않다는 에러 출력
long l = 12345678999L;   // int타입 범위를 벗어나면 L을 붙여서 롱타입임을 알려줌, 에러 없음

* 숫자밑에 _은 자릿수 구분을 위한 임의 표기로 에러사항이 아님

1-3) char타입

작은 따옴표로 감싼 형식을 쓰며 이것을 문자 리터럴이라고 한다.

문자 리터럴엔 유니코드값인 2byte크기 (0~65535)에 세계각국의 문자코드가 변환되어 저장된다.

유니코드 값은 크게 a, A, 0 값만 알고 있어도 유용하다.

char타입엔 아래와 같이 정수값을 저장해 쓸 수 있다.

char ch1 = 'A';	// unicode : 65
char ch2 = 65;	// A와 같음
char ch3 = '0'; // unicode : 48
char ch4 = 48;  // 문자 0과 같음
char ch5 = 'a'; // unicode : 97
char ch6 = '97';// a와 같음

아래와 같이 16진수 표현 또는 유니코드 표현을 쓸 수도 있다.

char c1 = 0x0041;	// 10진수값으로 65이며 unicode문자 A
char c2 = '\u0042'; // 문자 B

또한 int타입 변수에도 저장할 수 있지만 이 때는 콘솔로 출력해보면 유니코드 값이 출력된다.

char ch1 = 'A';		// A출력
int i = 'A';		// 65출력

2) 실수 타입

자바에서는 실수 연산은 기본적으로 double 타입으로 처리한다. (정수는 int)

따라서 float타입의 변수 선언 시 반드시 f를 붙여 float형으로 간주하도록 한다.

float f = 3.14f;  // 대문자 F로도 표기 가능, f생략 시 컴파일 에러

실수 타입은 항상 정수보다 표현범위가 크다. 

부동 소수점 방식으로 저장되어 더 큰 범위의 값을 저장할 수 있다. 

float : (+/-) 1.4 x10−45 ~ (+/-) 3.4028235 x 1038

double : (+/-) 4.9 x10−324 ~ (+/-) 1.7976931348623157 x 10308

0.1 == 0.1f
실수저장방식인 부동소수점 방식이 0.1을 정확히 표현불가 
0.1f는 0.1의 근사값 (.1.......) 따라서 0.1보다 큰값이 됨

2. 참조타입

Date today = new Date();

데이터 클래스 타입의 참조형 변수 today선언

참조타입은 4byte를 가진다.

문자열을 저장가능한 String 타입또한 클래스 타입의 참조타입이다.

String str = "이것이 문자열입니다.";

0. 샘플 소스

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<script type="text/javascript">
function fun1() {
	alert("안녕 자바스크립트");
	return;
}
function fun2(money) {
	alert("받은 동전 : " + money)
	return;
}
function fun3(money) {
	alert("무료음료수 전달")	
	return "커피";
}

function fun4(a, b) {
	alert("받은 동전" + a + b);
	alert("음료수 선택");
	return "사이다";
}
	
</script>
<body>
<h1>WebContent/js1/test3.html</h1>
<input type="button" value="출력버튼" onclick="fun1()">
<input type="button" value="값을 받아서 뽑기출력버튼" onclick="fun2(500)">
<input type="button" value="무료음료수받기" onclick="alert('전달받은 음료수: ' + fun3() )">
<input type="button" value="음료수받기" onclick="alert('받은 음료수: ' + fun4(500, 100) )">
</body>
</html>

위의 funtion 인 fun4에서 "받은 동전" + a + b와 같이 쓰면 문자열로 서로 연결된다.

이를 피하고 a와 b변수의 값을 더하고자 한다면 아래와 같이 수정한다.

function fun4(a, b) {
	alert("받은 동전" + (a + b) );
	alert("음료수 선택");
	return "사이다";
}​

1. 가변인자를 통한 함수 정의

(...)
<script type="text/javascript">
// 입력받은 값 평균 구하기
function fun4(...args) {
    let res = 0;    
    for (let i = 0; i < args.length; i++) {
        res += args[i];
    }    
    avg = res / args.length;
    return avg;
}
</script>
(...)
<input type="button" value="두수합리턴받아서 평균 구하기"
 		onclick="alert('리턴받은값 : ' + fun4(10, 20) )">

2. 내장함수

: 자바스크립트에서 기본적으로 제공하는 함수

ex) alert, confirm 등

1) alert

- alert는 리턴값이 없고 사용자에게 팝업창으로 알려주는 역할

var a = alert("메시지");
	alert(a);

- 리턴값이 없으므로 undefined 메시지가 뜸

2) confirm

- 사용자가 확인 / 취소를 선택할 수 있는 팝업을 제공

var r = confirm('확인/취소 선택하세요');
alert(r);

- 확인 시 true, 취소 시 false를 리턴

3) prompt

- 사용자에게서 입력받은 값을 반환, 입력값은 문자로 인식

var v = prompt("입력하세요", "입력란");
	alert(v);

alert(v + 100);	// 문자열로 더해져서 출력됨
alert(v * 100); // 곱하기는 숫자로 인식

4) parseInt

- 숫자 정수로 변환하는 함수

alert(parseInt(v) + 100);	

5) isNaN

- 숫자 / 문자열인지 판별하는 함수로 문자이면 true, 숫자면 false반환

(문자열과 숫자가 함께 포함되면 문자로 인식)

var isString = isNaN(v);
if (isString) {
	alert ('문자를 입력하셨습니다');
}
else {
	alert ('숫자를 입력하셨습니다');
}	

식별자 (Identifiers)

- 자바에서 각 대상을 구분하는 이름

- 변수, 상수, 클래스, 인터페이스, 패키지 등과 같은 개체(entity)의 이름

식별자 작성 규칙
[ 필수 사항 ]
1. 첫글자에 숫자 사용 불가(ex. 7eleven 사용 불가)
2. 특수문자 $ 또는 _ 만 사용 가능(ex. channel#5 사용 불가)
3. 대소문자 구별(ex. name 과 Name 은 다름)
4. 예약어(키워드) 사용 불가
5. 공백 사용 불가

6. 한글 사용도 가능 (권장사항 아니며 실제 사용하지 않음)
--------------------------------------------
[ 권장 사항 ]
6. 길이 제한 없음
7. 의미가 있는 단어 사용
8. 한글 사용 가능(하지만 실제 사용하지 않음 => 문제 발생 가능성 있음)
9. 두 개 이상의 단어를 조합할 경우 두번째 단어부터 첫글자를 대문자 사용
   ex) myfirstname => myFirstName(Camel-case 표기법)