JAVA study REVIEW

http://docs.oracle.com/javase/7/docs/api/index.html

<JAVA의 기본>

JDK, JRE, JVM

javac Hello.java(컴파일단계) -> Hello.class 생성

java Hello(실행단계)

Eclipse에서는 bin(class 저장) / src(java 저장), src에서 작업을 한다.

보통 project -> package -> class 생성

 

<Datatype>

문자 : Character ‘ ‘ / 문자열 : String  ” ” / 숫자: int (일반적으로)

변수 선언시 datatype을 반드시 선언해야 한다 .

int a = 1;  double a = 1.1; String a = “one”;

bit : 0 / 1만 있는 가장 작은 데이터 단위

1 byte = 8 bit

1 kilo byte = 1024 byte

1 mega byte = 1024 kbyte

mega < giga < tera < peta

정수는 기본이 int

1 byte = 2^8

short  = 2byte(2^16)

int = 4byte

long = 8byte

 

실수는 기본이 double

float = 4byte

double = 8byte

 

문자는

char = 2byte

 

int a = 1 / short a = 1 / byte a = 1 / long a = 1L

double a = 1.1 / float a = 1.1F

 

자동형변환 : double a = 3.0F / float a = 3.0 (error 3.0 double을 의미하므로)

int a = 3; float b = 1.0F; double c = a + b; -> c = 4.0 이 된다

명시적형변환 : float a = 100.0(error) => float a = (Float) 100.0 으로 명시적으로 나타내 줘야 한다

 

<연산자>

+, -< *, /, %(나머지를 의미)

+3, -3,++, —

i++ / ++i 의 차이는

i = 5; i++; => i = 6

i=5; ++i; => i = 5

i; => i=6

 

문자 비교시 .equals() 를 사용해야 한다

 

<조건문>

if(true){ 실행 }else{ }

if(false){ }else if(true){ 실행 }else{ }

switch(a){

case 1 : ~~~; break;

case 2 : ~~~; break;

default : ~~~; break;

*논리연산자 : && and / || or

 

<반복문>

int i = 0;

while(i<10){ ~~;  i++; }

는 for(int i=0; i<10;i++){ ~~ }와 같다

break; -> stop / continue; -> 그것만 pass

ex) for(int i =0; i<10; i++){

if(i ==5){continue; }

System.out.println(i); }

결과값 : 0 1 2 3 4 6 7 8 9

 

<배열 (Array) >

String[] group = {“a”, “b”, “c”};

group[0]; => “a”

group.length; => 5

String[] group = new String[4]; => 오직 4개만 담을 수 있는 그릇이 된다

group[0] = “a”; => 삽입한 것

 

*for-each문

String[] members = {“a”, “b”, “c”};

for(String e : members){

System.out.println(e); } => 결과값 : a b c

 

<method 메소드>

= function 함수

define & call 정의와 호출이 필요하다.

*매개변수와 인자

public static void numbering(int limit){

int i = 0;

while(i<limit){ System.out.println(i); i++}

}

numbering(5); => 0 1 2 3 4 출력

또한 void이므로 return값이 없다

 

public static String numbering(int init, int limit){

int i = init;

String output;

while(i<limit){output += i; i++;}

return output;

}

String result = numbering(1, 6);

System.out.println(result); => 12345 출력된다

 

Bufferedwriter out  = new Bufferedwriter(new Filewriter(“out.txt”));

out.write(result);

out.close(); => out.txt 파일에 12345가 저장된다

 

*출력값 return 1; return 2; return 3; 이 여러번 있으면 맨 처음 것만 출력된다

 

<입력과 출력 IO>

java -cp bin ScannerDemo 2; (cmd 창에, 이때 2는 입력하는 인자이다)

public class ScannerDemo{

public static void main(String[] args){

Scanner sc = new Scanner(system.in); // system.in은 입력한 인자의 값이다

int i = sc.nextInt();

System.out.println(i*1000); => 2000이 출력된다

sc.close();

}}

 

Scanner sc = new Scanner(System.in);

while(sc.hasNextInt()){

System.out.println(sc.nextInt()*1000); } => 이렇게 해주면 입력값 + enter시에 2000이 출력된다

sc.close();

 

File file = new File(“out.txt”);

Scanner sc = new Scanner(file); 도 가능하다

 

<객체지향 프로그래밍>

변수, 메소드(state, behave)  => 객체가 만들어진다.

클래스 class : 설계도 / 인스턴스 instance : 제품 이다

class Cal{

int l,r;

public void SetOprands(int l, int r){ this.l = l; this.r = r;}

public void sum(){ System.out.println(l+r); }

}

Cal c1 = new Cal(); // 인스턴스 생성

c1.setOprands(1, 3);

c1.sum(); => 출력값 4

 

<클래스멤버, 인스턴스멤버>

class Cal{

static double PI = 3.14;

static int base = 0;

int l,r;

public void sum(int l, int r){ System.out.println(l+r+base); }

public static void sum2(int l, int r){ System.out.println(l+r); }

}

Cal c2 = new Cal();

Cal.base = 10; // c2.base = 10;을 하면 에러가 난다. 왜냐하면 base는 클래스멤버이기 때문이다.

c2.sum(1, 2); => 출력값은 13이 된다.

cal.sum2(2, 3); => 출력값은 5가 된다. sum2는 static이므로 클래스 메소드이다. 따라서 클래스에서 직접 접근이 가능하다 .

이때 인스턴스멤버는 클래스멤버에 접근이 가능하나, 클래스멤버(static method, static field) 는 인스턴스멤버에 접근이 불가능하다.

 

<유효범위>

전역변수, 지역변수(메소드 안에서 정의를 해주면 지역변수가 된다)

public class Scope{}

static int i = 5;

static void a(){ int i = 10; b(); };

static void b(){System.out.println(i); };

public static void main(String[] args){

int i = 30;

a(); } => 결과값은 5 이다. 정적인 유효범위

}

 

<this>

class C{

int v = 10;

public void m(){ int v = 20;  System.out.println(v + “&” + this.v); } => 20 & 10이 돤다.  즉 this.v 는 클래스의 전역변수 v를 불러온다.

}

 

<초기화와 생성자>

class Cal{

int l,r;

public Cal(int l, int r){ this.l = l; this.r = r; }

public void sum(){ System.out.println(l + r); }

}

Cal c1 = new Cal(10, 20); // 이렇게 생성자를 만들면 직접 인자삽입이 가능하다.

c1.sum(); => 30이 출력.

 

<상속>

: 메소드를 기존 클래스에서 추가하기를 원할때

class Cal{

public void setOprands(){ }; sum(){ }; avg(){ }; }

 

class cal_sub extends Cal{ public void sub(){ }; }

이렇게 되면 cal_sub.sum() 도 불러올 수가 있다.

 

<상속과 생성자>

기본적으로 생성자가 자동으로 생성이 된다. public Cal(){ };

class Cal{

public Cal(){ }; – solution 1 

public Cal(int l, int r){ this.l = l; this.r = r; } ~~} — 그러나 이렇게 정의를 해주면 기본생성자가 없게 된다.

 

class cal_sub extends Cal{

public cal_sub(int l, int r){ this.l = l; this.r = r; 대신에 super(l, r); – solution 2 } — 에러가 난다. 왜냐하면 위에 기본생성자가 없기 때문에

}

 

<overriding>

이는 상속시에 내용을 변경해주는 것이다

class cal_sub extends Cal{

public int avg(int l, int r){ return (l+r)/2 + 2; } // overriding

}

조건) return 타입이 같아야한다 / 인자의 datatype이 같아야한다 / 이름이 같아야 한다.

 

<overloading>

이는 인자의 갯수가 달라지거나 인자의 형식이 달라지는 경우에 만드는 것이다

public class Over{

void A(){ ~~ };

void A(int arg1){ ~~ };

void A(String arg2){ ~~ };

}

Over o1 = new Over();

o1.A();

o1.A(1);

o1.A(“one”);  이 다 가능하다.

조건) return 타입이 같아야한다 / 이름이 같아야 한다

 

<클래스패스>

classPath.java  안에 class ClassPath{ ~~ }; class item{ ~~ }; 가 있을 경우에

javac classPath.java(cmd 창에서) -> item.class, classPath.class 가 생성된다

 

class item{

pubilc void print(){ ~~ };

}

class ClassPath{

public static void main(String[] args){

item it = new item();

it.print();}

}

만약 둘이 같은 경로에 없다면 java classPath; 가 실행이 안된다. 그때에는

java -classpath “.;lib” classPath; 로 해줘야한다. (item.class가 lib폴더에 있는 경우)

 

<환경변수>

classpath를 저장해주면 위 같은 일을 하지 않아도 된다. 고급시스템설정 -> 환경변수 -> 사용자변수에 .;lib 입력

 

<패키지>

package org.yellowpg.object.example1;

이렇게되면 C:\Users\Saea\src\org\yellowpg\object\example1에 모든 .java가 들어간다.

따라서 import org.yellowpg.object.example1.*; 로 이 안의 모든 .class를 가져온다.

손컴파일을 하면

javac \src\org\yellowpg\object\example1\*.java -d bin; (bin폴더에 .class를 넣는다)

 

import org.yellowpg.object.example1.*;

import org.yellowpg.object.example2.*;

만약 두 폴더에 같은 java 파일 즉 같은 class가 있다면 앞에 패키지명을 붙여준다.

org.yellowpg.object.example1.B b = new org.yellowpg.object.example1.B();

 

<접근제어자>

class A{

private String z(){ System.out.println(“Hi”); }

public String x(){ return z();}

}

A a = new A();

a.z(); => error, private 은 접근이 안된다

a.x(); => Hi 출력된다

 

public > protected > default > private

같은 패키지의 경우에 상속을 하는경우, private빼고 다 사용이 가능

그러나 다른 패키지에서 상속을 하는 경우, instance 생성시 public만, 그대로 사용시(this.) public, protected만 사용이 가능

클래스 접근 제어자 : public class PC{ ~~ } 이때, 다른 패키지의 경우는 public 클래스만 접근이 가능하다

 

<abstract>

abstract class, abstract method는 반드시 상속해서 사용해야 한다

abstract method => 자동으로 abstract class가 됨

abstract class => abstract method와 일반 method 모두 있을 수 있다

 

<final>

변경할 수 없는 것을 의미

final 변수는 변경 불가능

final method는 overriding이 불가능

final class는 상속이 불가능 하다

 

<interface>

class A implement I{

public void x(){ ~~ }

public void y(){ ~~ }

public void z(){ ~~ }

}

interface는 abstract class와 달리 모두 비워진 method만 가지고 있기 때문에 모두 overriding을 해줘야만 한다.

 

<다형성>

클래스의 다형성

class A{ public String x(){ ~~ } }

class B extends A{public String y(){ ~~} }

A obj = new B();

obj.x() => 가능 / obj.y() => error, 왜냐하면 데이터타입이 A이기 때문이다

인터페이스의 다형성

interface I{ public String A(){ ~~ }}

interface I2{ public String B(){ ~~ }}

class C implement I, I2{ A(){ ~~ }; B(){ ~~ }; }

I obj = new C(); obj.B(); => error, 오직 obj.A()만 사용이 가능하다

; 다양하게 사용,제한이 가능하다

 

<예외처리 Exception>

class Cal{

public void setOprands(int l, int r){ this.l = l; this.r = r; }

public void divide(){ System.out.println(l/r); }

}

Cal c1 = new Cal();

c1.setOprands(10, 0);

c1.divide(); => error, 0으로 나누어질 수 없기에 ArithmeticException 이 생긴다.

이때는 try catch로 감싸줘야 한다.

try{c1.divide(); }catch(Exception e){e.printStackTrace(); }

private int arr = new int[3];

arr[10]; => error, ArrayIndexOutofBounds Exception error

 

<finally>

무조건 실행되는 코드이다.

try{ ~~ }catch(Exception e){ ~~ }finally{ System.out.println(“finally”) } => finally는 무조건 출력된다

 

<throw>

try, catch를 던져줄 수 있다.

class B{

void run() throw FileNotException, IOException{ ~~ }}

B b = new B();

try{ b.run(); }catch(Exception e){ ~~ } // 여기서 try, catch를 해줘도 된다

 

<예외 만들기>

divide(){

if(r == 0){ throw new ArithmeticException(“0으로 나눌 수 없다”)}

~~ }

try{ c1.divide(); }catch(Exception e){ e.getMessage(); } => catch의 경우에 “0으로 나눌 수 없다” 라고 출력된다

혹은 나만의 예외를 만들 수도 있다

class DivideException extends ArithmeticException{

DivideException(String msg){ super(msg); } }

 

<Object>

모든 객체는 Object를 상속받고 있으므로 최고 조상 객체이다

class A{ ~~ } == class A extends Object{ ~~ } 같은 의미이다

Object가 가진 methods 예시)

toString()  : 객체의 문자화

equals() : 두 객체가 같은지 확인, String 타입만 올 수 있기때문에 만약 다른 경우에는 overriding해줘야 한다

Student s1 = new Student(“saea”);

Student s2 = new Student(“saea”);

s1.equals(s2)l => error

이때

Class Student{

public  boolean equals(Object obj){

Student s = (Student) obj;

this.name = s.name; } } 이렇게 해주면 에러가 나지 않는다

finalize() : 객체 소멸시 사용

clone() : 복제할때 사용 // 반드시 Clonable interface를 상속받아야 한다.

class Student implements Clonable{

public Object clone(){ return super.clone(); }

}

Student s1 = new Student(“saea”);

Student s2 = s1.clone(); 해도 됨

 

<상수와 enum>

변수 이름이 겹치는 것을 막기 위해서

Class Fruit{ public static final Fruit Apple = new Fruit(); }

Class Company{ public static final Company Apple = new Company(); }

Fruit type = Fruit.Apple; ((or Company type = Company.Apple;))

switch(type){ ~~ } 이렇게 사용이 불가능하다.

Fruit.Apple, Company.Apple이 구분된다. 그러나 switch문에서 인자로 들어갈 수 없다. 인자에 대한 제약때문에. 이때 enum을 사용한다.

enum Fruit{ Apple, Banana, … }

Fruit type = Fruit.Apple;

switch(type){ ~~ } 이렇게 사용이 가능하다.

또한,

enum Fruit{

public String color;

Apple(“red”); Banana(“yellow”);

Fruit(String color){ this.color = color; }

public String getColor(){ return this.color; }

}

for(Fruit f : Fruit.values()){

System.out.println(f + f.getColor()); } 이렇게 배열처럼 반복문도 가능하다

 

<참조>

A a = new A(1);

A b = a;

b.id = 2;

a.id ?? => 2가 된다

 

<제네릭>

class내의 데이터타입을 외부에서 지정하는 것

class Person<T, S>{

public T info; public S id;

public Person(T info, S id){ this.info = info;  this.id = id; }

public <U> printInfo(U info){ ~~ } // method에도 제네릭이 가능하다

}

Integer id = new Integer(1); <= 이렇게 wrapping을 해줘야한다. 제네릭에 그냥 int는 들어갈 수 없기 때문에.

Person<EmployeeInfo, Integer> p1 = new Person<EmployeeInfo, Integer>(EmployeeInfo(1), id);

Person p1 = new Person(EmployeeInfo(1), id); // 이렇게 생략도 가능하다

p1.id.intValue(); => 1, intValue()로 unwrapping을 해줘야 한다.

p1.printInfo(EmployeeInfo e); // 이렇게 메소드 사용시에 데이터타입을 명시해주면 된다

 

class Person<T extends Info>{ ~~ } // 이렇게 제네릭 데이터타입을 상속으로 제한할 수도 있다

 

<Collections Framework>

Collection의 구성 : Set / List — Map(key-value)

Array는 제한이 있다

<ArrayList>

ArrayList a = new ArrayList();

a.add(“one”);

a.add(“two”); … 제한이 없다

for(int i=0; i< a.size(); i++){

System.out.println(a.get(i)); } one two … 출력

String val = a.get(1); => error, 데이터타입을 명시해줘야 한다. (String) a.get(1);

 

ArrayList<String> a1 = new ArrayList<String>();

String val = a1.get(1); => ok; 제네릭을 통해서 명시해주면 괜찮다

 

<Set>

집합개념이다.

HashSet<Integer> A = new HashSet<Integer>();

A.add(1);

A.add(2); …

A.containsAll(B); => true or false(B가 A에 속한 경우)

A.addAll(B); => A+B가 A로 들어간다

A.retainAll(B); =>A,B의 교집합이 A로 들어간다

A.removeAll(B); => A-B가 A로 들어간다

 

Set의 경우에는 겹치는 경우에는 하나만 들어가지만, List는 다 하나씩 들어간다

iterator; collection의 method이다

Iterator(데이터타입)  hi = (iterator) A.iterator();

while(hi.hasNext()){ System.out.println(hi.next); } => 1,2 출력

A.add(1); A.add(1); A.add(2); => Set의 경우는 1,2 / List의 경우에는 1,1,2 가 출력된다

 

<Map>

key-value가 삽입된다. key는 중복이 될 수 없다. 정의역, 치역 개념

HashMap<String, Integer> a = new HashMap<String, Integer>();

a.put(“one”, 1);

a.put(“two”, 2);

System.out.println(a.get(“one”)); => 1이 출력

iteratorUsing(a);

static void iteratorUsing(HashMap map){

Set<Map.Entry<String, Integer>> entries = map.entryset(); // map을 set화 한다

for(Map.Entry<String, Integer> entry : entries){

System.out.println(entry.getKey()+entry.getValue()); => one1 two2 출력

}

Iterator<Map.Entry<String, Integer>> i = entries.iterator();

while(i.hasNext()){

Map.Entry<String, Integer> entry = i.next();

System.out.println(entry.getKey()+entry.getValue()); } => one1 two2 출력

}

<Collection>

Collections.sort(computers); 바로 사용이 가능하다. but computers가 comparable을 상속받아야한다.

class Computer implements Comparable{

Collections.sort(computers); 바로 사용이 가능하다

Computer(int serial, String owner){

this.serial = serial; this.owner = owner; }

public int CompareTo(Object o){ return this.serial – ((Computer).o).serial; }

public String toString(){ return serial + owner; }

}

List<Computer> computers = new ArrayList<Computer>();

computers.add(new Computer(500, “saea”));

computers.add(new Computer(300, “arum”));

Iterator i = computers.iterator();

while(i.hasNext){ System.out.println(i.next()); } => 500saea 300arum 출력

 

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s