8.Java-Basic3

• call-by reference. 메소드.int.값변화x
• 생성자. 리턴없는메소드 . 필드값 초기화
• interface .다중상속 .생성자x
• 다형성 - 객체1개가 여러타입
• abstract. 메소드,필드강제 - 생성자o
• 오버로딩 - new 메소드 생성
• 오버라이딩 - 상속 메소드 내용 변경
• enum - 클래스같은 상수.
• 람다 - first class citizen (전저리)
• 스트림 - 배열(collection) 탐색도구
• implement 인터페이스 , extend 상속

1. 상속

public class Dog extends Animal {

    Animal dog = new Dog(); // 자식클래스로 만든 객체는 부모클래스의 자료형으로 사용o
   // Dog dog = new Animal(); 부모클래스로 만든 객체는 자식클래스의 자료형으로 사용x
    // 부모 = new 자식 -o
    // 자식 = new 부모 -x
    

    public void sleep(){
        System.out.println(this.name + " zzz");
    }


    public static void main(String[] args){
        Dog dog = new Dog();
        dog.setName("puppy");
        System.out.println(dog.name);
        dog.sleep();
    }

}

2. Overriding

public class Dog extends Animal {

    // 오버라이딩 - 변경될 부분 
    public void sleep(){
        System.out.println(this.name + " zzz");
    }

}



public class HouseDog extends Dog {

    // 오버라이딩 - 변경한 부분 
    public void sleep(){
        System.out.println(this.name + "zzz in house ");
    }

    public static void main(String[] args){
        HouseDog houseDog = new HouseDog();
        houseDog.setName("happy");
        houseDog.sleep();
    }


}

3.Overriding , Overloading

public class HouseDog extends Dog {

    // 오버라이딩 - 변경
    public void sleep(){
        System.out.println(this.name + "zzz in house ");
    }

    // 오버로딩 - 추가한 부분 
    public void sleep(int hour) {
        System.out.println(this.name+" zzz in house for " + hour + " hours");
    }

    public static void main(String[] args){
        HouseDog houseDog = new HouseDog();
        houseDog.setName("happy");
        houseDog.sleep();
        houseDog.sleep(3); // 오버로딩 
    }


}

4. Constructor

public class HouseDog extends Dog {

    // 오버라이딩 - 변경
    public void sleep(){
        System.out.println(this.name + "zzz in house ");
    }

    // 오버로딩 - 추가한 부분
    public void sleep(int hour) {
        System.out.println(this.name+" zzz in house for " + hour + " hours");
    }

    // 생성자 - 리턴없는 메소드 , 클래스명과 동일 , new 키워드 사용시 호출
    public HouseDog(String name){
        this.setName(name);
    }

    // 생성자 오버로딩
    public HouseDog(int type) {
        if (type == 1) {
            this.setName("yorkshire");
       } else if (type == 2) {
            this.setName("bulldog");
        }
    }

    public static void main(String[] args){

        // 생성자의 규칙과 다를경우 오류
        HouseDog dog = new HouseDog("happy"); // 오버로딩한 생성자1.
        System.out.println(dog.name);
        
        HouseDog york = new HouseDog(1); // 오버로딩한 생성자2.
        System.out.println(york.name);
    }


}

5. Intercace

public class ZooKeeper {

//    // interface 구현전
//    public void feed(Tiger tiger){
//        System.out.println("feed apple");
//    }
//    public void feed(Lion lion){
//        System.out.println("feed banana");
//    }

    // interface 구현후
    public void feed(Predator pre){
        System.out.println("feed " + pre.getFood() );
    }

    public static void main(String[] args){
        ZooKeeper zooKeeper = new ZooKeeper();
        Tiger tiger = new Tiger();
        Lion lion = new Lion();
        zooKeeper.feed(tiger);
        zooKeeper.feed(lion);


    }

}

6. Abstract class

public interface Barkable {
    public void bark();
}



public class Animal {
    String name;

    public void setName(String name){
        this.name = name;
    }
}




public abstract class Predator extends Animal {

    public abstract String getFood();

    public boolean isPredator(){
        return true;
    }
}



public void feed(Predator pre){
    System.out.println("feed " + pre.getFood() );
    System.out.println("type:" + pre.isPredator());
}

7 . exception

public class Test {
    public void shouldBeRun() {
        System.out.println("ok thanks.");
    }

    public static void main(String[] args) {
        Test test = new Test();
        int c;
        try {
            c = 4 / 0;
        } catch (ArithmeticException e) {
            c = -1;
        } finally {
            test.shouldBeRun();
        }
    }
}












    public void sayNick(String nick) {
        try {
            if("fool".equals(nick)) {
                throw new FoolException();
            }
            System.out.println("당신의 별명은 "+nick+" 입니다.");
        } catch(FoolException e) {
            System.err.println("FoolException이 발생했습니다.");
        }
    }

    public static void main(String[] args) {
        Test test = new Test();
        test.sayNick("fool");
        test.sayNick("genious");

    }



//
//    public void sayNick(String nick) throws FoolException {
//        if("fool".equals(nick)) {
//            throw new FoolException();
//        }
//        System.out.println("당신의 별명은 "+nick+" 입니다.");
//
//    }
//
//    public static void main(String[] args) {
//        Test test = new Test();
//
//        try {
//            test.sayNick("fool");
//            test.sayNick("genious");
//
//        } catch (FoolException e ) {
//            System.err.println("FoolException이 발생");
//        }
//    }

8. Thread

public class Test extends Thread {
    int seq;
    public Test(int seq){
        this.seq = seq;
    }

    public void run() {
        System.out.println(this.seq + "threed run");
        try {
            Thread.sleep(1000);
        } catch (Exception e) {

        }
        System.out.println(this.seq +"  thread end ");
    }
//
//    public static void main(String[] args){
//        for(int i =0; i<10; i++){
//            Thread t = new Test(i);
//            t.start();
//        }
//        System.out.println("main end");
//    }
//
    public static void main(String[] args) {
        ArrayList<Thread> threads = new ArrayList<Thread>();
        for(int i = 0 ; i<10; i++){
            Thread t = new Test(i);
            t.start();
            threads.add(t);
        }

        for(int i = 0 ; i < threads.size();i++){
            Thread t = threads.get(i);
            try {
                t.join(); // 쓰레드가 종료후 다음로직을 실행하는 메소드
            } catch (Exception e) {

            }
        }
        System.out.println("main end.");
    }




}




public class Test implements Runnable {
    int seq;
    public Test(int seq){
        this.seq = seq;
    }

    public void run() { // Runnable 인터페이스는 run 메소드 강제 
        System.out.println(this.seq + "threed run");
        try {
            Thread.sleep(1000);
        } catch (Exception e) {

        }
        System.out.println(this.seq +"  thread end ");
    }

    public static void main(String[] args) {
        ArrayList<Thread> threads = new ArrayList<Thread>();
        for(int i = 0 ; i<10; i++){
            Thread t = new Thread(new Test(i)); // Thread의 생성자로 Runnable 객체 사용 
                                                // 상속에 좀더 유연 
            t.start();
            threads.add(t);
        }

        for(int i = 0 ; i < threads.size();i++){
            Thread t = threads.get(i);
            try {
                t.join(); 
            } catch (Exception e) {

            }
        }
        System.out.println("main end.");
    }




}

9. Nested Class

class Outer {
    private static int num = 0;
    static class Nested1 { // 네스티드 클래스
        void add(int n){ num += n;}
    }
    static class Nested2 { // 네스티드 클래스
        int get() {return num; }
    } // 맴버 클래스

    void method(){
        class LocalInner{ }
    } // 로컬 클래스
}


public class StaticNested {
    public static void main(String[] args){
        Outer.Nested1 nst1 = new Outer.Nested1();
        nst1.add(5);

        Outer.Nested2 nst2 = new Outer.Nested2();
        System.out.println(nst2.get());
    }
}

10. Lambda

interface Printable {
    void print(String s);
}
//
//class Printer implements Printable {
//    public void print(String s){
//        System.out.println(s);
//    }
//}



public class Rambda {
    public static void main(String[] args){
//        
//        Printable prn = new Printable() { // 익명클래스 - 인터페이스를 바로 가져오는 
//            @Override
//            public void print(String s) {
//                System.out.println(s);
//            }
//        };
//
//        prn.print("What is lambda");
        
        // 람다식 
        // 인터페이스 = 매개변수 -> { 식 ; };
        Printable prn = (s) -> {System.out.println(s);}; // 람다식
        prn.print("What is lambda"); 
    }
}

예제 1

int max(int a, int b) {
    return a > b ? a : b;
}

(a, b) -> a > b ? a : b

예제 2

void printVar(String name, int i) {
	System.out.println(name + " = " + i);
}

(name, i) -> System.out.println(name + " = " + i)

예제 3

int sumArr(int[] arr) {
	int sum = 0;
    for(int i: arr) {
    	sum += i;
    }
    return sum;
}

(int[] arr) -> {
	int sum = 0;
    for(int i: arr) {
    	sum += i;
    return sum;
}