import java.util.Arrays;

public class ex100_1 {
    public static void main(String[] args) {
        //[1]: 배열 선언 --> 성적 배열
        int[] scores = {88,55,39,100,90,100,98,67};

        // [2]: 성적 배열 --> 오름차순 정렬 --> Arrays.sort(배열명);-->오름차순이 기본정렬 --> import 필요
        // 클래스 메소드로써 Arrays 클래스의 인스턴스 생성없이 바로 사용 가능
        System.out.print("화장실(정렬) 들어가기 전= ");
        for(int i=0; i<scores.length;i++)
            System.out.print(scores[i]+" ");System.out.println();

        Arrays.sort(scores);

        System.out.print("화장실(정렬) 들어가기 후= ");
        for(int i=0;i<scores.length;i++)
            System.out.print(scores[i]+" ");System.out.println();

        // [3]: 향상된 for문 사용
        System.out.print("화장실(정렬) 들어가기 후= ");
        for(int i: scores)
            //System.out.print(scores[i]); //Err
            System.out.print(i+" "); System.out.println();
    }
}

public class ex100_1 {
    public static void main(String[] args) {

        // [1]: 정수 배열 선언
        int[] ar = new int[10];

        // [2]: 반복문을 돌면서 랜덤으로 10개 정수 값을 셋팅 -> Math.random()
        for(int i=0; i<ar.length; i++) {
            ar[i] = (int)(Math.random() * 100); // --- 무작위로 숫자(double type)를 반환--;
            System.out.print(ar[i]+" ");
            // System.out.println((int)(Math.random()*10));
        }
        System.out.println();

        // [3]: 최댓값, 최솟값 변수 초기화
        int max = ar[0], min = ar[0];

        // [4]: 반복문을 돌면서 최댓값, 최솟값 비교
        for(int i=0; i<ar.length; i++) {
            if(max < ar[i]) max = ar[i];
            if(min > ar[i]) min = ar[i];
        }
        // [5]: 출력
        System.out.println("------------------------------");
        System.out.println("ar 배열내 최댓값:"+max);
        System.out.println("ar 배열내 최솟값:"+min);
        System.out.println("------------------------------");
    }
}

현재 배열내 가장 작은 값은: -4 현재 배열내 가장 작은 값은: -2

public class ex100_1 {
    public static void main(String[] args) {

        //[1]: 배열 선언
        int[] ar = {4, 13, 150, 17, -2};

        //[2]: max, min 함수
        System.out.println(Math.max(10, 4));
        System.out.println(Math.min(10, 4));

        //[3]: 일단 배열내 첫번째 원소의 값이 제일 적다고 가정하고 초기화
        //int min = Integer.MAX_VALUE;
        int min = ar[0];

        //[4]: 반복문 돌면서 비교하여 출력 --> 이때, 비교는 2번째 부터 비교하면 되니깐 int=1로 시작.
        System.out.println("현재 배열내 가장 작은 값은:"+min);

        for(int i=1; i<ar.length; i++)
            if(min>ar[i])
                min=ar[i];
        System.out.println("현재 배열내 가장 작 값은:"+min);
    }
}

현재 배열 내 가장 큰 값은: 4 현재 배열 내 가장 큰 값은: 150

public class ex100_1 {
    public static void main(String[] args) {
       int[] ar = {4, 13, 150, 17, -2};

       int max = ar[0];

       System.out.println("현재 배열 내 가장 큰 값은:"+max);

       for(int i=1; i<ar.length; i++) 
           if(max<ar[i]) 
               max=ar[i];

           System.out.println("현재 배열 내 가장 큰 값은:"+max);
       }
}

abstract class Car {
    abstract void run();
}
class Ambulance extends Car {
    void run() {System.out.println("앰블런스 지나가요~ 삐뽀삐뽀~");}
}
class Cultivate extends Car {
    void run() {System.out.println("경운기 지나가요~ 덜컹덜컹~");}
}
class Sportscar extends Car {
    void run() {System.out.println("스포츠카 지나가요~ 씽~");}
}

public class ex100_1 {
    public static void main(String[] args) {
        Car[] cars = {new Ambulance(), new Cultivate(), new Sportscar()};
        for(int i=0;i<cars.length;i++) {
            cars[i].run(); 
            }
        System.out.println("--------------------------------");
    for(Car obj: cars)
        obj.run();

    }
}

• 부모 클래스 Person이 있고, 이를 상속받은 자식 클래스 Student가 있다.
• 정리하면, 그 하위 클래스의 인스턴스(객체)는 보다 위인 상위 클래스의 인스턴스(객체)로도 사용될 수 있다.
• 그런데, 그 반대는 안된다.
• 따라서, 상위(부모) 클래스의 인스턴스(객체)는 하위(자식) 클래스의 인스턴스(객체)로 사용될 수 없다.

class Person {}
class Student extends Person {}

public class Java100_oop_Polymorphism2 {
    public static void main(String[] args) {
        //[1]: 객체 생성
        Student s1 = new Student(); //지극히 정상 ➡️ 에러날 이유가 하나도 없다.

        //[2]: 객체 생성 ➡️  타입은 부모 타입으로 생성
         Person s2 = new Student(); // 이것도 상위 타입 클래스 사용 가능 ➡️ 다형성

       //[3]: 객체 생성
           Person p1 = new Person(); // 지극히 정상

       //[4]: 객체 생성 ➡️ 상위(부모) 클래스로 객체를 생성하면서 타입은 하위 타입을 쓰는 경우 ➡️ Err
        Student s2 = new Person();
    }
}

• 다형성이란 다양한 형태 또는 특성을 가진다는 의미.
• 자바와 같은 객체 지향 언어에서의 의미는 부모 클래스를 상속받은 자식 클래스의 인스턴스가 부모의 객체로도 사용되고, 뿐만 아니라 자식 클래스의 객체로도 사용될 수 있는 다양한 상황을 의미한다.

2. 예시

• 부모 클래스 Bird가 있고, 이를 상속받은 자식 클래스 Parrot이 있다고 가정하자.
• 이때, "앵무새가 말을 하네...허허~"사람들이 이렇게 말할 수 있다.
• 그런데, 앵무새는 새이기 때문에 "새가 말을 하네...허허~" ⬅️ 이렇게 말할 수 있다.

3. 결론

• 정리하면, 하위 클래스의 인스턴스(객체)는 보다 위인 상위 클래스의 인스턴스(객체)로도 사용될 수 있다.
• 그런데 그 반대는 안된다.
• 왜냐하면, "앵무새"는 분명 그 상위인 "새"라고 말할 수 있지만, 새는 종류가 많기 때문에 모든 새가 앵무새는 아니기 때문이다.
• 따라서, 상위(부모)클래스의 인스턴스(객체)는 하위(자식)클래스의 인스턴스(객체)로 사용될 수 없다.

1. 사전적 의미 ➡️ 결합부, 접속기 ➡️ 사용자간 또는 컴퓨터간 통신이 가능하도록 해주는 디바이스나 프로그램.
2. 큰 틀에서 본다면 자바에서의 인터페이스 개념도 사전적 의미와 비슷하다.
3. 상호간 통신을 위해서는 "규격"이 중요하다. ➡️ 일본이 110v 가전제품을 한국으로 가지고 와도 "규격"이 맞지 않으므로 사용할 수 없다.
4. 일본의 가전기업들이 한국에서 전자제품을 팔고 싶다면 한국내 220v "규격"을 지켜서 만들어야만 팔 수 있다.
5. 이러한 "규격"을 인터페이스라 할 수 있고, 인터페이스는 하나의 "표준화"를 제공하는 것이라 할 수 있다.

추상 클래스 vs 인터페이스?

1. 추상 클래스와 거의 비슷하다. ➡️ 그러나 추상화 정도가 더 높다(더 엄격하다.) ➡️ 따라서, 일반 메소드 멤버 필드(변수)를 가질 수 없다.
2. 이러한 점들이 추상 클래스와 인터페이스간 가장 큰 차이점중 하나이다. ➡️ 차이점이 더 있다...?!

자바에서의 인터페이스 문법?

1. 표준화 및 규격을 인터페이스로 제공.
2. 따라서 어떤 클래스가 해당 인터페이스를 사용(상속)한다면 인터페이스에 선언되어져 있는 메소드를 구현해야 한다.
3. class ➡️ extends(O) / interface ➡️ extends(X), implements(O)
4. 추상 클래스와 같이 메소드의 구체적인 내용은 기술되어져 있지 않으므로 인터페이스를 상속받은 클래스에서 재정의(오버라이딩)하여 사용해야 한다.
5. 인터페이스는 interface 키워드를 사용.

상속 vs 구현

1. 클래스와 인터페이스 이 둘의 가장 큰 차이점 중 하나는 "상속"이다. ➡️ a,b
2. 자바에서 클래스는 "단일 상속"만 가능하지만, 인터페이스는 "다중 상속"이 가능하다.
3. 그러나 인터페이스에서는 extends 표현을 쓰지 않고 "구현"의 의미를 강조하는 implements 키워드를 사용하여 다중 상속을 구현한다.
4. 상속을 받는 extends 키워드와 구현을 하는 implements 키워드가 동시에 쓰일 때 ➡️ extends 키워드가 항상 먼저 쓰인다.

장점

1. 인터페이스를 이용하면 메소드의 추상적인 "선언"과 그 메소드들을 구체적인 "구현"부분을 분리시킬 수 있다. ➡️ 매우 큰 장점.
2. 하청을 주는 대기업(갑)은 하청업체(을)에 인터페이스만 제공 ➡️ 각 하청업체(을)들이 이를 준수하여(=상속 받아) 개발.
3. 분업화된 시스템을 구축하여 "갑"과 "을"이 독립적으로 프로젝트 개발을 해나갈 수 있다. ➡️ 매우 큰 장점

public class Java100_oop_Interface2 {
    public static void main(String[] args) {

        //[1]: 객체 생성

    }
}

// Person 클래스 (부모)

// A 인터페이스 (부모)

// B 인터페이스 (부모)

// Student 클래스 (자식)

// 메인 클래스 (메인 메소드가 포함)

1.추상(부모) 클래스는 다른(자식) 클래스들의 공통적인 특징을 변수나 메소드로 정의만 해 놓은 것을 말한다. ➡️ 추상 메소드 2. abstract를 앞에 붙이고 클래스 안에 추상 메소드를 포함하고 있다는 것을 제외하면 사실 일반 클래스와 별반 차이가 없다. 3. Field, Constructor, Method(추상 메소드 말고 일반 메소드)도 포함할 수 있다. 4. 메소드 선언만 있고 구체적인 내용은 없으므로 객체를 생성할 수 없다. 5. 따라서, 부모 클래스로서의 역할은 하지만, 구체적인 사용은 상속받은 자식 클래스에서 재정의(오버라이딩)하여 사용해야 한다. ➡️ 강제성 6. 추상 클래스에서 선언만 해놓음으로써 이후 새로운(자식) 클래스들이 이를 상속 받아 구현하므로 새로운 클래스를 작성할 때 하나의 틀이 된다.

와이 쓰지?

1. 우선 강제하기 위함이다.
2. 부모(추상) 클래스가 선언해놓은 메소드를 상속받은 자식 클래스들이 이름 그대로 재정의해서 구현하라고 강제하는 것이다.
3. 상속받은 자식 클래스 입장에서는 자칫 상속만 받고 재정의해서 사용을 안 할 수 있기 때문이다.
4. 즉, 알반 메소드로 구현하면 누군가는 해당 메소드를 구현 안 할 수도 있다.
5. 무조건 상속받은 자식 클래스 입장에서는 추상 메소드를 재정의해서 구현하도록 강제하기 위함이다.

꼭 재정의(override)해야만 하는 가?

1. 일단 그렇다.
2. 자식 클래스는 일단은 무조건 부모(추상) 클래스로 부터 상속받은 추상 메소드는 오버라이딩해서 재정의를 해야 한다.
3. 추상 메소드를 포함하고 있다면 곧 추상 클래스여야 한다.

만약, 재정의를 하고 싶지 않다면?

1. 자식 클래스에서 상속 받은 추상 메소드를 구현하지 않는다면 자식 클래스도 abstract를 붙여서 추상으로 만들어준다.
2. class 앞에다가 abstract를 붙인다.

결론

1. 부모(추상) 클래스에서 구현을 하지 않는 이유는 해당 메소드의 구현이 상속받는 클래스에 따라서 달라질 수 있기 때문에 선언만 해둔 것이다.
2. 이러한 추상 클래스는 여러면의 개발자가 작업할 때 코드의 확장과 분업을 효율적으로 처리할 수 있게 해준다.
3. 분업화된 시스템에서 공통의 프로젝트를 진행할 때 많이 사용되어지는 중요한 문법이다.

• 추상 메소드를 하나라도 가지고 있다면 그 클래스는 abstract를 붙여줘야 한다.

abstract class Animal {
    // 구체적인 내용은 작성하지 않고 공통적인 특징을 추상적으로 선언 --> 리턴값 조차도 없이 메소드명만 선언
   abstract void cry();
}

class Dog extends Animal {
    void cry() {System.out.println("멍멍~");}
}

class Cat extends Animal {
    void cry() {System.out.println("야옹야옹~");}
}

class Cow extends Animal {
    void cry() {System.out.println("음메~");}
}

Public class Java100_oop_AbstractClassMethod {
    public static void main(String[] args) {

        //[1]: 추상 클래스는 구체적인 내용이 없기 때문에 객체를 생성할 수 없다.

        // [2]: 추상 클래스 사용은? --> 상속을 받아서 사용.
        // 즉, 추상 (부모)클래스를 상속받은 자식 클래스에서 해당 메소드를 오버라이딩하여 재정의한 후 사용한다.
        Dog dog = new Dog();
        dog.cry(); // -- 멍멍

        Cat cat = new Cat();
        cat.cry; // --야옹야옹

        Cow cow = new Cow();
        cow.cry(); // -- 음메~
   }
} 

class Person {
    String name;
    int age;

Person() {}
Person(String name, int age) {
    this.name = name;
    this.age = age;
}
public String getName() {return name;}
public void setName(String name) {this.name = name;}

public int getAge() {return age;}
public void setName(int age) {this.age = age;}
}

public class ex100_1 {
    public static void main(String[] args) {

        //[1]: 객체 생성
        Person[] pa;            // Person 타입의 객체 배열 변수 pa 선언.
        pa = new Person[5];        // Person 객체의 참조값을 원소로 가지는 배열 공간을 5개 생성 --> 5명 객체 생성할테니 주소 저장해라.


        //[2]: 반복문(for)을 돌면서 Person() 객체 생성
        for(int i=0; i<pa.length;i++) {
            pa[i] = new Person(i+"번 후보자", i+20); // i만 입력하면 안되나요? --> 문자열을 붙이면 문자열로 전달..
        // [2-2]: 배열 인덱스 사용해서 출력 --> 단, 이렇게 쓰려면 private 선언을 삭제하고 써야함.
        System.out.println(pa[i].name+"의 나이는 "+pa[i].age+"살 입니다.");
        }
    }
}

class Person {
    String name;
    int age;

Person() {}
Person(String name, int age) {
    this.name = name;
    this.age = age;
}
public String getName() {return name;}
public void setName(String name) {this.name = name;}

public int getAge() {return age;}
public void setName(int age) {this.age = age;}
}

public class ex100_1 {
    public static void main(String[] args) {

        //[1]: 객체 생성
        Person[] pa;            // Person 타입의 객체 배열 변수 pa 선언.
        pa = new Person[5];        // Person 객체의 참조값을 원소로 가지는 배열 공간을 5개 생성 --> 5명 객체 생성할테니 주소 저장해라.


        //[2]: 반복문(for)을 돌면서 Person() 객체 생성
        for(int i=0; i<pa.length;i++) {
            pa[i] = new Person(i+"번 후보자", i+20); // i만 입력하면 안되나요? --> 문자열을 붙이면 문자열로 전달..

        // [2-3]: printf()    
        System.out.printf("%s의 나이는 %d살 입니다.%n",pa[i].name,pa[i].age);
        }
    }
}

class Person {
    private String name;
    private int age;

Person() {}
Person(String name, int age) {
    this.name = name;
    this.age = age;
}
public String getName() {return name;}
public void setName(String name) {this.name = name;}

public int getAge() {return age;}
public void setName(int age) {this.age = age;}
}

public class ex100_1 {
    public static void main(String[] args) {

        //[1]: 객체 생성
        Person[] pa;            // Person 타입의 객체 배열 변수 pa 선언.
        pa = new Person[5];        // Person 객체의 참조값을 원소로 가지는 배열 공간을 5개 생성 --> 5명 객체 생성할테니 주소 저장해라.


        //[2]: 반복문(for)을 돌면서 Person() 객체 생성
        for(int i=0; i<pa.length;i++) {
            pa[i] = new Person(i+"번 후보자", i+20); // i만 입력하면 안되나요? --> 문자열을 붙이면 문자열로 전달..

        // [2-3]: printf()    
        System.out.printf("%s의 나이는 %d살 입니다.%n",pa[i].getName(),pa[i].getAge());
        }
    }
}

사전적 의미: 과적하다.

• 자바에서는 하나의 메소드 이름으로 여러 기능을 구현하기 때문에 '과적하다.'라는 뜻의 이름을 붙여준 것으로 보인다.

오버로딩의 정의

• 자바의 한 클래스 내에 이미 사용하려는 이름과 같은 이름을 가진 메소드가 있더라도 매개변수의 개수 또는 타입이 다르면, 같은 이름을 사용해서 메소드를 정의할 수 있다.

  오버로딩의 조건

• 메소드의 이름이 같고, 매개변수의 개수나 타입이 달라야 한다. 주의할 점은 '리턴 값만' 다른 것은 오버로딩을 할 수 없다는 것이다.

오버라이딩

오버라이딩의 정의

• 부모 클래스로부터 상속받은 메소드를 자식 클래스에서 재정의하는 것을 오버라이딩이라고 한다. 상속받은 메소드를 그대로 사용할 수도 있지만, 자식 클래스에서 상황에 맞게 변경해야하는 경우 오버라이딩할 필요가 생긴다.

  오버로딩의 조건

• 오버라이딩은 부모 클래스의 메소드를 재정의하는 것이므로, 자식 클래스에서는 오버라이딩하고자 하는 메소드의 이름, 매개변수, 리턴 값이 모두 같아야 한다.

• 말 그대로 부모 클래스가 가지고 있는 속성(변수)들과 동작/기능(메소드)들을 그대로 물려받아 새로운 클래스를 만드는 것.
• 상속을 활용하면 물려받은 것들을 그대로 쓰면 되고, 거기에 덧붙여 새로운 것만 만들면 되므로 그만큼 노력과 시간이 세이브됨.
• 이때, 물려받게 되는 원본 클래스를 부모 클래스(Parent class)또는 슈퍼 클래스(Super class)라고 부른다.
• 상속받아 새롭게 만들어진 클래스는 말 그대로 자식 클래스(Child class)또는 서브/하위 클래스(Sub class)라고 부른다.
• 또 다른 표현으로는 기초/기반 클래스(Base class), 파생 클래스(Derived class)라고도 부른다. ➡️ derived: (a)유래된, 파생된

2. 상속의 장점

• 가장 큰 장점 ➡️ 재활용성~!
• 완전히 새로운 것을 만드는 것이 아니라 기존 부모로부터 상속을 받아 필요한 것만 추가로 더해서 만드는 것.
• 부모 클래스에 정의되어져 있는 멤버 필드(변수)나 메소드들을 그대로 상속받아 사용하면 된다.
• 상속받은 메소드라고 해도 필요에 따라서 자식 클래스에서 용도를 변경해서 사용하는 것도 가능.

3. 상속의 장점

• 기존 부모 클래스를 확장한다는 개념 ➡️ extends 키워드 사용.
• 부모 클래스의 멤버 필드, 메소드는 상속이 가능하나 생성자는 상속이 안된다.
• 부모 클래스의 접근 제한자 private인 경우에는 아무리 자식 클래스가 상속을 받았다 하더라도 접근 불가능.