02 - JAVA 기초&기본 개념 공부

**상속

-  특정 클래스의 기능을 재사용 및 확장하는 것
    부모 클래스 - 기능 1, 2
            ↑
             |
             |
    자식 클래스 - 기능 1,2,3
    : 부모 클래스의 기능을 재사용(1,2) + 3(자식에서 새로운 기능을 구현 축가.)

 

*상속 구조
class 자식 클래스명 extends(상속할) 부모 클래스명{
  } 
ex)
class Student extends Person{
        String school;
}

 

**메소드 오버라이딩

 - 부모 클래스의 메소드를 재정의 하는 것(부모클래스 메소드를 덮어서 사용)

 

*메소드 오버라이딩 구조
class Person{
       // 부모 클래스의 메소드.

       public void introduce(){
               sout("사람입니다.");
        }
}

// 부모 클래스(Person)를 상속한 자식 클랙스(Student)
class Student extends Person{
         // 부모 클래스에 정의 되어있던 메소드를 자식 클래스에서 재정의

         public void introduce(){
                sout("학생입니다"); 
          }
}


**다형성

 - 여러 형태로 동작할 수 있는 성질 

 

*다형성 구조

// 부모클래스

class Person{
         public void introduce(){
               sout("사람입니다.");
          }
}

// 부모클랙스를 상속한 자식 클래스
class Student extends Person{
           public void introduce(){
                sout("학생입니다"); 
            }
}

// 다형성 ex)
 public static void main(String[] args) throws Exception {
        Person person = new Person(); // 부모클래스 객체 생성

       // Person 부모 클래스를 참조(상속) 해서 사용가능 이런 부분이 다형성이다.
        Person student = new Student();  
        person.introduce();
        student.introduce();
    }    


**Super

 - 부모 클래스에 접근하기 위해 사용
super.부모클래스 변수
super.부모클래스 메소드();
super(); 생성자

ex)
class Person{
       int age;
        Person(int age){
             this.age = age;
        }
}
class Student extends Person{
          String school;
          Student(int age, String school){
                   //this.age = age; --> super(age);

                    super(age);  // 이렇게 사용.
                    this.school = school;
          }
}

**참조(Reference)

 - 객체의 메모리 주소를 가리킴
기본 자료형은 변수에 담는다 a=b b의값을 a로 옮긴다.
참조 자료형은  가리키는 값을 이동

**Final

 - 변경할 수 없게 하는 키워드이다.
class Person{
          final String name = "철수"; 초기값 설정 필수! 변수는 어디서든 쓸 수 있지만 값은 바꿀 수 없다
          public final  void introduce(){
                   sout("사람입니다.");
          }
}
class Student extends Person{
         public void introduce(){ // final이 아닐 땐 오버라이딩해서 사용하면되는데 final 부모클래스에서 생성자를 선언했을 경우 오버라이딩이 불가이다.
               sout("학생입니다"); 
           }
}

**열거형

 - 상수들의 묶음.
enum 열거형명{
     상수명1
     상수명2
      ....
}
enum Gender{
     MALE,
     FEMALE
}
class Person{
      Gender gender;
       public void setGender(Gender gender){
                    this.gender = gender;
        }
}
public static void main(String[] args){
          Person person = new Person();
          person.setGender(Gender.MALE);
     switch(person.gender){
         case MALE : sout("남자") break;
         case FEMALE : sout("여자") break;
     }
}


**추상 클래스

 - 아직 완성되지 않은 클래스.
abstract class 클래스명{
}
ex) 
abstract class Shape{
       abstract double calculateArea();
}
class Square extends Shape{
        private double s;
        public Square(double s){
              this.s = s;
         }
       double calculateArea(){ // 자식클래스에서 완성되지 않은 메서드를 완성시킴으로 사용이 가능하다.
       return s*s;
      }
}

**인터페이스

 - 클래스를 작성할 때 기본이 되는 뼈대이다.
interface 인터페이스명{
}
interface Shape{
double calculateArea();
}
class Square implements Shape{
private double s;
public Square(double s){
this.s = s;
}
double calculateArea(){ // 자식클래스에서 완성되지 않은 메서드를 완성시킴으로 사용이 가능하다.
return s*s;
}
}


**제네릭스

 - 다양한 형태의 데이터를 다룰 수 있게 해준다.
T 변수명
public static void main(String[] args){
     int intValue = 3;
    double doubleValue = 3.14;
     String stringValue = "안녕";

printValue(intValue);
printValue(doubleValue);
printValue(stringValue);
}

메서드 자료형빼곤 동일.
public static void printValue(int value){
sout(value);
}
public static void printValue(double value){
sout(value);
}
public static void printValue(String value){
sout(value);
}

**제네릭스 활용(T : 어떠한 데이터가 들어와도 똑같은 계산을 해준다.)
ex)
pulbic static  void printValue(T value){
sout(value);
}

제네릭 클래스 : 제네릭 기반 클래스
class 클래스명 {
}
ex)
class BoxInteger{ // 정수를 담을 수 있는 Box 클래스
int data;
public void setData(int data){
this.data = data;
}
}
class BoxString{ // 문자열을 담을 수 있는 Box 클래스
String data;
public void setData(String data){
this.data = data;
}
}
public static void main(String[] args){
BoxInteger iBox = new BoxInteger();
iBox.setData(3) //정수 담기

BoxString sBox = new BoxString();
sBox.setData("안녕") //문자열 담기
}
제네릭 클래스 활용
class Box{ //모두 담을 수 있는 Box 클래스
T data;
public void setData(T data){
this.data = data;
}
}
public static void main(String[] args){
Box iBox = new Box<>();
iBox.setData(3) //정수 담기

Box sBox = new Box<>();
sBox.setData("안녕") //문자열 담기
}

**ArrayList

 - 배열 기반 리스트이며, 데이터에 빠른 접근과 순차적으로 데이터를 저장한다.
ArrayList
ex)
public static void main(String[] args){
            ArrayList list = new ArrayList<>(); // 정의
           list.add("철수");
           list.add("영희");
           리스트 데이터를 순회하기 위해서
           for(String s : list){
                  sout(s);
             }
}
**ArrayList list = new ArrayList<>();
기능  | 설명   |  예시 |  결과
add |   추가 |   list.add("철수"); --> {"철수"}
get   |   가져오기 |   list.get(0); --> "철수"
size |  크기   | list.size();   --> 1
set   |  수정  | list.set(0,"영희"); --> {"영희"}
contains |  포함여부 | list.contains("영희"); --> true
remove |   삭제 | list.remove("영희"); --> {}
clear |  전체 삭제 | list.clear(); --> {}


**LinkedList 

 - 연결리스트, 데이터의 빠른 삽입 + 삭제 가능
LinkedList <어떤 데이터들이 들어올지 정의>
public static void main(String[] args){
      LinkedList list = new LinkedList<>(); // 문자열을 담을 수있는 정의
      list.add("철수");
      list.add("영희");

      리스트 데이터를 순회하기 위해서
      for(String s : list){
            sout(s);
      }
}

**LinkedList list = new LinkedList<>();
기능  | 설명   |  예시 |  결과
add |   추가 |   list.add("철수"); --> {"철수"}
get   |   가져오기 |   list.get(0); --> "철수"
getFirst |  처음요소가져오기 | list.getFirst();   --> "철수"
getLast |  마지막요소가져오기 | list.getLast(); --> "철수"
addFirst |  맨앞에추가 | list.addFirst("영희"); --> {"영희","철수"}
addLast |   맨뒤에추가 | list.addLast("영철"); --> {"영희","철수","영철"}
clear |  전체 삭제 | list.clear(); --> {}

**HashSet

 - 순서, 중복을 허용하지 않는 데이터 집합이다.
HashSet
public static void main(String[] args){
       HashSet set = new HashSet<>(); // 문자열을 담을 수있는 정의
       set.add("철수"); 1. {"철수"}
       set.add("영희"); 2. {"철수","영희"}
       set.add("철수"); 3. {"철수","영희"}
}
add,contains,size,remove,clear


**HashMap

- (key,value) 쌍으로 저장하는 자료구조, 중복 X, 순서 X
HashMap<k,v></k,v>
public static void main(String[] args){
// 이름, 점수
HashMap<string,integer> map = new HashMap<>(); // 문자열을 담을 수있는 정의</string,integer>
map.put("철수",100); key(이름) | Value(점수)
map.put("영희",90); 철수 |  100 영희 |  90
}
put : 추가 -> map.put("철수",100) : {"철수":100}
size
get : 가져오기 -> map.get("철수") : 100
containsKey : Key 포함 여부 -> map.containsKey("영철"); false
remove
clear

**Iterator

 - 컬렉션의 모든 데이터 하나씩 차례대로 접근하기 위한 순회
Iterator : T -> 순회대상 데이터 타입 작성
public static void main(String[] args){
ArrayList list = new ArrayList<>(); // 정의
list.add("철수");
list.add("영희");

리스트 데이터를 순회하기 위해서
for(String s : list){
sout(s);
}
for문을 Iterator로 변경
Iterator it = list.Iterator();
while(it.hasNext()){
sout(it.next());
}
}
hasNext -> 다음 요소 확인 -> it.hasNext() -> true
next -> 다음 요소 가져오기 -> it.next() -> "철수"
remove -> 삭제 -> it.remove() -> { }

**스트림

- 배열, 컬렉션 데이터를 효과적으로 처리한다.
public static void main(String[] args){
List numbers = Arrays.asList(1,2,3,4,5);
numbers.stream()
.filter(n->n%2==0)
.map(n->n*2)
.forEach(system.out::println)
}


예외처리 : 발생 가능한 문제상황처리
try{
명령문
}catch(변수){
예외 처리
}

public static void main(String[] args){
int[] numbers = {1,2,3}; // 0 1 2 
int index = 5; // 존재하지 않는 인덱스
try{
int result = numbers[index];
sout("결과 : " + result);
}cathc(Exception e){
sout("문제발생");
}
}