public interface Iterator{
    
    boolean hasNext();
    ObjectNext();
    void remove();
}

public interface Collection {
    public Iterator();
}

import java.net.*;
import java.io.*;

public class NetworkEx3{
    public static void main(String[] args){
      URL url = null;
      String address = "http://www.javahome.com/sample/hello.html";
      String line ="";
      
      try{
          url = new URL(address);
          URLConnection conn = url.openConnection();
          
          System.out.println("conn.toSTring(): "+conn);
      }catch(Exception e){
          e.printStackTrace();
      }
    }
}

import java.net.*;
import java.io.*;

public class NetworkEx4{
    public static void main(String[] args){
      URL url = null;
      BufferedReader input = null;
      String address = "http://www.javahome.com/sample/hello.html";
      String line ="";
      
      try{
          url = new URL(address);
          
          input = new BufferedReader(new InputStreamReader(url.openStream()));
          
          while((line= input.readline()) != null) {
              System.out.println(line);
          }
          input.close();
      }catch(Exception e){
          e.printStackTrace();
      }
    }
}

import java.net.*;
import java.io.*;

public class NetworkEx5{
    public static void main(String[] args){
      URL url = null;
      InputStream in = null;
      FileOutputStream out = null;
      String address = "http://www.javahome.com/sample/hello.zip";
      int ch = 0;
      
      try{
          url = new URL(address);
          in = url.openStream();
          out = new FileOutputStream("hello.zip");
          
          while((ch= inlread()) != -1) {
              out.writy(ch);
          }
          in.close();
          out.close();
      }catch(Exception e){
          e.printStackTrace();
      }
    }
}

class ThreadEx1{
    public static void main(String[] args){
      ThreadEx1_1 t1 = new ThreadEx1_1();
      
      Runnable r = new ThreadEx1_2();
      Thread t2 = new Thread(r);
    }
}

class ThreadEx1_1 extends Thread{
    public void run(){
        for(int i = 0; i < 5; i++) {
            System.out.println(getName());
        }
    }
}

class ThreadEx1_2 implements Runnable{
    public void run(){
        for(int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName());
        }
    }
}

ThreadEx1_1 t1 = new ThreadEx_1();
t1.start();
t.start();//이건 불가능
``` 


```java
ThreadEx1_1 t1 = new ThreadEx1_1();
t1.start();
t1 = new ThreadEx1_1();
t.start();//이건 가능

import javax.swing.JOptionPane;

class ThreadEx6{
    public static void main(String[] args) throws Exception{
        String input = JOptionPanel.showInputDialog("아무 값이나 입력하세요.");
        System.out.println("입력하신 값은 "+input+"입니다.");
        
        for(int i = 10; i > 0 ; i--) {
          System.out.println(i);
          try{
              Thread.sleep(1000);
          }catch(Exception e){}
        }
    }
}

import javax.swing.JOptionPane;

class ThreadEx7{
    public static void main(String[] args) throws Exception{
        
        ThreadEx7_1 th1 = new ThreadEx7_1();
        th1.start();
        
        String input = JOptionPanel.showInputDialog("아무 값이나 입력하세요.");
        System.out.println("입력하신 값은 "+input+"입니다.");
       
    }
}
class ThreadEx7_1 extends Thread{
    public void run(){
        for(int i = 10; i > 0 ; i--) {
           System.out.println(i);
           try{
                Thread.sleep(1000);
           }catch(Exception e){}
          
        }
    }
}

void setPripority(int new Priority);
int getPriority();

public static final int MAX_PRIORITY =10;
public static final int MIN_PRIORITY =1;
public static final int NORM_PRIORITY = 5;

class ThreadEx9{
    public static void main(String[] args) throws Exception{
        
        ThreadEx9_1 th1 = new ThreadEx9_1();
        ThreadEx9_2 th2 = new ThreadEx9_2();
        th2.setPriority(7);
        System.out.println("입력하신 값은 "+input+"입니다.");
        th1.start();
        th2.start();       
    }
}

class ThreadEx9_1{
    public void run(){
        for(int i = 0; i < 300 ; i++) {
          System.out.println("-");
          for(int j = 0; j < 1000000 ; j++) {}
        }
    }
}
class ThreadEx9_2{
    public void run(){
        for(int i = 0; i < 300 ; i++) {
          System.out.println("|");
          for(int j = 0; j < 1000000 ; j++) {}
        }
    }
}

Thread(ThreadGroup group, String name)
Thread(ThreadGroup gorup, Runnable target)

class ThreadEx15{
    static long startTime=0;
    public static void main(String[] args) throws Exception{
        
        ThreadEx15_1 th1 = new ThreadEx15_1();
        ThreadEx15_2 th2 = new ThreadEx15_2();
        th1.start();
        th2.start();
        try{
            th1.sleep();
        }catch (InterruptedException e){}
        System.out.println("<<main종료>>");
    }
}

class ThreadEx15_1{
    public void run(){
        for(int i = 0; i < 300 ; i++) {
          System.out.println("-");
        }
        System.out.println("<<TH1종료>>");
    }//run()
}
class ThreadEx15_2{
    public void run(){
        for(int i = 0; i < 300 ; i++) {
          System.out.println("|");
        }
        System.out.println("<<TH2종료>>");
    } //run()
}
```  

왜 th1이 sleep()으로 잠들어있어도 가장 먼저 종료될까?  
sleep()이 항상 현재 실행중인 쓰레드에 대해 작동해서 th1.sleep()호출해도 main메서드를 실행하는 main쓰레드가 영향받는다.   
static으로 선언되어 있어서 참조변수로 sleep()을 호출하기 보다는 Thread.sleep()이렇게 호츨해야 함.

## 9. 쓰레드의 동기화  
멀티쓰레드는 여러 쓰레드가 같은 프로세스내의 자원을 공유하기 때문에 데이터가 원래 의도했더것과는 다르게 변경 될 수 있음.  

### 9.1 synchorized를 이용한 동기화  
공유 데이터에 lock을 걸어 먼저 작업중이던 쓰레드가 작업을 완전히 마칠때까지는 다른 쓰레드에게 제어권이 넘어가도 데이터가 변경되지 않도록 보호함.  

- synchronized 사용방법 두가지.  
가능하면 메서드에 synchronized를 사용하는 메서드 단위 동기화를 권장함.  

```java
// 1. 특정한 객체에 lock을 걸고자 할때
    sysnchronized(객체의 참조변수){
    
    }
// 2. 메서드에 lock을 걸고자 할때
    public void synchronized void calcSum(){
    
    }

class ThreadEx21 {
    public static void main(String[] args){
      RunnbaleImpl r =  new RunnableImpl();
      Thread th1 = new Thread(r);
      Thread th2 = new Thread(r);
      th1.start();
      th2.start();
    }
}

class RunnableTmpl implements Runnable {
    int iv = 0;
    public void run(){
        int lv = 0;
        String name = Thread.currentThread().getName();
        
        while(lv<3){
            System.out.println(name+"Local var: "+ ++lv);
            System.out.println(name+"Instance var: "+ ++iv);
            System.out.println();
        }
    }
}

Thread-0 Local var: 1
Thread-0 Instance var: 1 

Thread-0 Local var: 2
Thread-0 Instance var: 2 

Thread-0 Local var: 3
Thread-0 Instance var: 3 

Thread-0 Local var: 1
Thread-0 Instance var: 4 

Thread-0 Local var: 2
Thread-0 Instance var: 5 

Thread-0 Local var: 3
Thread-0 Instance var: 6

balance:700
balance:400
balance:200
balance:0
balance:-100
```  

잔고(balance)가 임의의 출금금액(money)보다 클 경우에만 출금하도록 되어있는데 잔고에 -100이 나왔음.  
if조건문 통과하고 출금직전에 다른쓰레드가 끼어들어서 먼저 출금했기때문이다.  
if문과 출금하는 기능은 하나로 synchronized되어야 한다.  

```java
public synchronized void withdraw (int money){
    if(balance>=money){
        try{ Thread.sleep(1000);} catch(Exception e){}
        balance -=money;
    }
}//withdraw
```  

```java
public void withdraw (int money){
    synchronized(this){
        if(balance>=money){
            try{ Thread.sleep(1000);} catch(Exception e){}
            balance -=money;
        }
    
    }
}//withdraw

class Account{
    int balance =1000;
    public synchronized void withdraw (int money){
        if(balance>=money){
            try{ 
                wait();
            } catch(Exception e){}
            balance -=money;
        }
    }//withdraw
}

public synchronized void desposit(int money){
    balance += money;
    notify();
}

interface 인터페이스이름{
    public static final 타입 상수이름 = 값;
    public abstract 메서드이름(매개변수 목록);
}

interface Movable{
    void move(int x, int y);
}
interface Attactable{
    void move(Unit u);
}

interface Fightable extends Movable, Attackable{}

class 클래스 이름 implements 인터페이스이름{
    //인터페이스에 정의된 추상메서드 구현
}
class Figther implements Fightable{
    public void move(int x, int y){
        //기능 구현
    }
    public void attack(Unit u){
        //기능 구현
    }
}

abstract class Fighter implements Figtable{
    public void move(int x, int y){
        //기능 구현
    }
}

class Figther extends Unit implements Figthable{
    public void move(int x, int y){
        //기능 구현
    }
    public void attack(){
        //기능 구현
    }
}

Fightable f = (Fightable) new Figther();
Fightable f = new Fighter();

viod attack(Figtable f){}

Fightable method(){
    // ...
    return new Fighter();
}

abstract class 클래스이름{
    
}

abstract 리턴타입 메서드이름();

abstract class Player{
        abstract void play(int pos);
        abstract void stop();
}

class AudioPlayeer extends Player{
    void play(int pos){
        // 기능 구현   
    }
    void stop(){
        //기능 구현
    } 
}
abstract class AbstractPlayer extends Player{
    void play(int pos) {
        // 기능 구현
    }
}

abstract class Player{
    boolean pause;
    int currentPos;
    
    Player(){
        pause = false;
        currentPos = 0;
    }
    abstract void play(int pos);
    abstract void stop();
    
    void play(){
        play(currentPos);
    }
    
    void pause (){
        if(pause){
            pause = false;
        }else {
            pause = true;
            stop();
        }
    }
}

class CDPlayer extends player{
    void play(int currentPos){
        //기능 구현
    }
    
    void stop(){
        //기능 구현
    }
    
    int currentTrace;
    void nextTrace(){
        currentTrace++;
    }
    void preTrace(){
        if(currentTrace>1){
            currentTrace--;
        }
    }
}

class Marine{
    int x,y;
    void move(int x, int y){}
    void stop(){};
    void stimPack(){}
}
class Tank{
    int x,y;
    void move(int x, int y){}
    void stop(){};
    void changeMode(){}
}
class Dropship{
    int x,y;
    void move(int x, int y){}
    void stop(){};
    void load(){}
    void unload(){}
    }

abstract class Unit{
    int x,y;
    abstract void move(int x, int y);
    void stop(){};
}
class Marine extends Unit{
    void move(int x, int y){}
    void stimPack(){}
}
class Tank extends Unit{
    void move(int x, int y){}
    void changeMode(){}
}
class Dropship extends Unit{
    void move(int x, int y){}
    void load(){}
    void unload(){}
    }

Unit[] grop = new Unit[4];
group[0] = new Marine();
group[1] = new Tank();
group[2] = new Marine();
group[4] = new Dropship();

class Tv{
    boolean power;
    int channel;
    
    void power(){power = !power;}
    void channelUp(){++channel;}
    void channelDown(){--channel;}
}

class CaptionTv extends Tv{
    String text;
    void caption(){};
}

Tv t = new Tv();
CaptionTv c = new CaptionTv();

Tv t = new CaptionTv();

CaptionTv c = new CaptionTv();
Tv t = new CaptionTv();

//이렇게는 불가능함
CaptionTv c = new Tv();

class Car{
    String color;
    int door;
    void drive(){
        System.out.println("drive, Brrr~");
    }
    void stop(){
        System.out.println("stop!!");
    }   
}

class FireEngine extends Car{
    void water(){
        System.out.println("water!!!");
    }
}

class Ambulance extends Car {
    void siren(){
        System.out.println("siren~~!");
    }
}

Car car = null;
FireEngine fe = new FireEngine();
FireEngine fe2 = null;

car = fe;  //car = (Car) fe; 형변환이 생략된 형태
fe2 = (FireEngine) car; //형변환 생략 불가.

class CastingTest2{
    public static void main(String args[]){
        Car car = new Car();
        Car car2 = null;
        FireEngine fe = null;
        
        car.drive();
        fe = (FireEngine) car; //실행시 여기서 에러 발생
        fe.drive();
        car2 = fe;
        car2.drive();
    }
 }
```  

car가 Car타입의 인스턴스여서 FireEngine을 받을 수 없음.
- 캐스트연산자를 사용하면 서로 상속관계에 있는 클래스 타입의 참조변수간의 형변환은 양방향으로 자유롭게 수행될 수 있다.  
그러나 참조변수가 참조하고 있는 인스턴스의 자손타입으로 형변환을 하는것은 허용되지 않는다.  

### 5.3 instanceof연산자  
참조변수가 참조하는 인스턴스 실제타입을 확인하기 위해 instanceof연산자 사용.  
주로 조건문에사용. 
* 값이 ull인 참조변수에 대해 instanceof연산을 하면 false나옴.  

```java
void doWork(Car c){
    if(c instanceof FireEngine){
        FireEngine fe = (FireEngind) c;
        fe.water();
    } else if( c instance of Ambulance){
        Ambulance a = (Ambulance) c;
        a.siren();
    }
}

class InstanceOfTest{
    public static void main (String args[]){
        FireEngine fe = new FireEngine();
        
        if(fe instanceof FireEngine){
            System.out.println("FireEngine instance");
        }
        if( fe instanceof Car){
            System.out.println("Car instance");
        }
        if( fe instanceof Object){
            System.out.println("Object instance");
        }
    }
}

FireEngine instance
Car instance
Object instance

class BindingTest{
        public static void main(String[] args){
            Parent p = new Child();
            Child c = new Child();
            
            System.out.println("p.x =" + p.x);
            p.method();
            
            System.out.println("c.x= "+c.x);
            c.method();
          
        }
}

class Parent {
    int x = 100;
    void method(){
        System.out.println("Parent Method");
    }
}

class Child{
    int x = 200;
    void method(){
        System.out.println("Child Method");
    }
}

p.x=100
Child Method
c.x=200
Child Method

package 패키지명;

import 패키지명.클래스명;
import 패키지명.*;

class StaticTest{
    static int width =200;
    static int height = 120;
    
    static {
        // static 변수의 초기화 수행
    }
    
    static int max(int a, int b){
        return a>b?a:b;
    }
}

final class FinalTest{
    final int MAX_SIZE = 10;
    
    final void getMaxSize(){
        final int LV = MAX_SIZE;
        return MAX_SIZE;
    }
}

class Card{
    final int NUMBER;
    final String KIND;
    static int width = 100;
    static int height =250;
    
    Card(String kind, int num){
        KIND = kind;
        NUMBER = num;
    }
    
    Card(){
        this("HEART",1);
    }
}

abstract class AbstractTest{
    abstract void move();
}

public class Time{
    private int hour;
    private int minute;
    private int second;
    
    public int getHour(){return hour;}
    public void setHour(int hour){
        if(hour<0 || hour > 23){
            return;
        }
        this.hour = hour;
    }
    public int getMinute(){return minute;}
    public void setMinute(int min){
        if(min<0 || hour > 59){
            return;
        }
        this.minute = min;
    }
    public int getSecond(){return second;}
    public void setSecond(int sec){
        if(sec <0 || sec > 59){
            return;
        }
        this.second = sec;
    }
}

class Point{
    int x;
    int y;
    
    String getLocation(){
        return "x : "+x+", y : " + y;
    }
|

class Point3D extends Point{
    int z;
    
    String getLocation(){
        return "x : "+x+", y : " + y+", z : "+z;
    }
}

class Parent{
    void parentMethod(){};
}

class Chile extends Parent{
    void parentMethod(){} // 오버라이딩;
    void parentMethod(int i){} //오버로딩
    
    void childMethod(){}
    void childMethod(int i){} //오버로딩
    void childMethod(){}// 에러 함수가 중복됨
}

class SuperTest{
    public void static void main(String args[]){
        Child c = new Child();
        c.method();
    }
}

class Parent{
    int x =10;
}

class Child extends Parent{
    int x =20;
    void method(){
        system.out.println("x="+x);  
        system.out.println("this.x="+this.x);
        system.out.println("super.x="+super.x);   
    }
}

x=20
this.x=20;
super.x=10;

class Parent{}
class Child extends Parent{}

class Tv{
    boolean power;
    int channel;
    
    void power(){power = !power;}
    void channelUp(){++chnannel;}
    void channelDown(){--channel;}
}

class CaptionTv extends Tv{
    boolean caption;
    void displayCaption(String text){
        if(caption){
            system.out.println(text);
        }
    }
}

class Circle{
    int x;
    int y;
    int r;
}

class Point{
    int x; 
    int y;
}

class Circle{
    Point point = new Point();
    int r;
}

class car{
    Engine e = new Engine();
    Door[] d = new Door[4];
}

//불가능한 경우
calss TVCR extends TV, VCR{

}

class Tv{
    boolean power;
    int channel;
    
    void power(){power = !power;}
    void channelUp(){++chnannel;}
    void channelDown(){--channel;}
}

class VCR{
    boolean power;
    int counter =0;
    void power(){};
    void play(){};
    void stop(){};
    void rew(){};
    void ff(){};
}

class TVCR extends Tv{
    VCR vcr = new VCR();
    int counter =vcr.counter;
    
    void play(){
        vcr.play();
    };
    void stop(){
        vcr.stop();
    };
    void rew(){
        vcr.rew();
    };
    void ff(){
        vcr.ff();
    };

class Tv{}

class Tv extends Object{}

class Car{
   int door= 4;     //기본형 변수 초기화
   Engine = new Engine();  // 참조형 변수 초기화
}

class InitBlock{
    static{/* 클래스 초기화 블럭*/}
    {/*인스턴스 초기화 블럭 */}
}

Car(){
    System.out.println("Car인스턴스가 생성되었습니다.");
    color= "withe";
    gearType="auto";
}
Car(String color, String gearType){
    System.out.println("Car인스턴스가 생성되었습니다.");
    this.color= color;
    this.gearType=gearType;
}

{ System.out.println("Car인스턴스가 생성되었습니다."); }

Car(){
    color= "withe";
    gearType="auto";
}
Car(String color, String gearType){
    this.color= color;
    this.gearType=gearType;
}

class Product{
    static int count =0; //생성된 인스턴스 수를 저장하기 위한 변수
    int serialNo; //인스턴스 고유 번호
    
    {
        ++count;
        serialNo = count; // Product인스턴스가 생성될 때마다 count 값을 1증가시켜 serialNo에 저장
    }
    
    public product(){}
}