1~5chapter 기본타입은 값을가진다(정수 실수)
, 참조타입은 클래스이다,주소를 가진다(string)
, 논리 boolean
-----------------------------------------------------
객체지향
객체란 필드와 메소드(함수뒤에 ()가있다)로 이루어진다
객체를 생성(new)호출하여 출력값을 넣어준다
-------------------------------------------------------
메소드 작성 규칙 형식
1.리턴타입 2.메소드이름 (3.매겨변수선언, ...){
메소드본문;
4.return 리턴값;
}
메소드이름 소문자입력
함수(호출한다,메소드명())
*리턴 (값의결과를 받는다)
*매개변수(값을주고)
메소드 오버로딩
메소드 이름이 같고,
매개변수선언이 다른 메소드가 여러 개 존재할수있다
리턴타입은 상관없다
메소드명 앞에 void 제외 다른 타입이 있다??
=> 반드시 값을 return 해야한다 !
----------------------------------------------------------
생성자(대문자로 형성될수있다)
Car car = new Car(); =Car()생성자
클래스객체를만들기위해 생성자를 통해 만든다
기본생성자 =아무런역할을 하지않는다
풀생성자 = 모든 필드에 대한 값을 매개변수로 받아서 값을 대입하는 생성자
public Ex02_Person() {
} // 풀 생성자 시 발생
public Ex02_Person(int a, String b, double c, char d) {
age = a;
name = b;
height = c;
gender = d;
}
chapter6,7,8
--------------------------------------------------------------------------
chapter9
this
자기 자신을 호출할때
필드 : this.필드명
public class Ex01_Rect {
int width, height;
public Ex01_Rect() {}
public Ex01_Rect(int width, int height) {
this.width = width;
this.height = height;
}
void setWidth(int width) {
this.width = width;
}
void setHeight(int height) {
this.height = height;
}
void output() {
System.out.println("너비 : " + width);
System.out.println("높이 : " + height);
}
}
----------------------------------------------------------------
chapter10
static
정적 : 미리 만듦 new할 필요없이 가져다 쓴다
동정 : 나중에만듦(new) 흐름에 따라서 올라가는것
객체를 생성하지않고 쓸수있다(필드 메소드)
모든객체(인스턴스)가 공유하기 위해서
객체(인스턴스) 생성(new) 없이 클래스를 사용하기 위해서
final
값이 변하지않는 상수const(항상 같은 값)
package org.joonzis.ex;
public class Ex01_StaticSample {
static final double PI = Math.PI;
public static void main(String[] args) {
System.out.println();
System.out.println(Math.PI);
PI = 123; (오류) 값이 상수인것은 바뀌지 않는다
}
}
----------------------------------------------------------------
chapter11참조배열
클래스는 참조타입이다(클래스,메소드)
//크기 3의 참조 배열 people을 선언 후 값 입력
//각 배열 내 데이터 출력
Ex01_Person[] people = new Ex01_Person[3];
people[0] = new Ex01_Person ("김씨", 20 , 130 ,'남'); //people은 클래스 객체이다
people[1] = new Ex01_Person(); //people은 클래스 객체이다
for(int i=0; i<people.length; i++) {
people[i] = new Ex01_Person();
}
people[0].output();
}
}
------------------------------------------------------------------
chapter13
상속(Inheritance)
부모가 자식에게 물려주는 행위를 말한다.
기존 클래스의 재활용
package org.joonzis.ex;
//부모 클래스
class Parent{
int number;
void doParent() {
System.out.println("doParent() 호출");
}
}
//자식 클래스(extends상속받음)
class Child extends Parent{
void doChild() {
System.out.println("doChild() 호출");
}
}
public class Ex01_Inheritance {
public static void main(String[] args) {
Child child = new Child();
child.number = 10;
System.out.println(child.number);
child.doParent();
child.doChild();
}
}
메소드 오버라이드(재정의)
부모 클래스가 가지고 있는 메소드를 지식 클래스가 다시 만드는것을 말한다
부모 클래스가 가지고 있는 메소드와 완전히 동일한 원형으로 다시 만든다
어노테이션("@Override")이 붙는다(함축적으로 표현한것)
class Animal{
String name; //필드
public Animal() {}
public Animal(String name) {
this.name = name;
}
}
class Dog extends Animal{
String personName;
public Dog(String personName) {
super();//부모생성자 호출 함수
this.personName = personName;
}
public Dog(String name,String personName) {
super(name);//자식이 부모의 생성자를받아서 초기화
this.personName = personName;
}
void whoAnI() {
System.out.println("내 이름은 " + name + "이고, 주인은 " + personName + "입니다.");
}
}
public class Ex05_Constructor {
public static void main(String[] args) {
Dog dog = new Dog("김씨");
dog.whoAnI();
System.out.println("-----------------");
Dog dog2 = new Dog("쿠키", "옆집 아주머니");
dog2.whoAnI();
}
}
자식클래스의 super 부모생성자 호출 함수
Override
-개발자로 하여금 상위 클래스의 어떤 메소드를 오버라이드 했는지 개별적 인지가 가능
-상위 클래스 메소드의 시그니처 변경시 자식 클래스의 오버라이드 받은 메소드와
상이함에 따른 문제를 컴파일 단계에서 인지
-------------------------------------------------------------------------------------
chapter15
접근제한자
private
public
getters & setters
set 저장하기 , = 대입
get 가져오기, ○ =get(); 값을 return받는다 setters는 값이 없다
chapter16
다형성
부모클래스의 객체 = 참조변수는 자식클래스의 객체를 저장할 수 있다 (upcasting)
업캐스팅
부모클래스의 참조변수에 자식클래스의 객체를 저장할 수 있다
부모클래스 참조변수 = new 자식클래스(); ->업캐스팅
부모와 자식의 일대일 관계라면 업캐스팅이 필요없지만
자식이 2명이상이라면 업캐스팅이 필요하다(배열안에 넣어서 안에 있는 데이터만 관리하면된다)
다운캐스팅
부모클래스의 참조변수에 저장한 자식클래스의 타입은 부모클래스이다
이와 같은형태의 자식클래스를 자식클래스 타입으로 변경하는 것이 다운캐스팅이다
자식클래스 참조변수2 = (자식클래스)참조변수; ->다운캐스팅
자식에게 있는 데이터만 쓰려고할때 다운캐스팅으로 객체를 생성해서 자원없이 사용 가능하다
public class Ex03_polymorphism {
public static void main(String[] args) {
Animal[] animals = new Animal[3];
// 업캐스팅
animals[0] = new Dog();
animals[1] = new Dolphin();
animals[2] = new Eagle();
for(int i=0; i<animals.length; i++) {
animals[i].move();
}
//animals[2].fly(); // 부모 클래스는 fly() 메소드가 없기 때문에 호출할 수 없다.
//((Eagle)animals[2]).fly();
if(animals[2] instanceof Eagle) {
// 다운 캐스팅
// 1. Eagle 객체 생성
Eagle eagle = (Eagle)animals[2];
eagle.fly();
// 2. Eagle 객체 생성 없이 자원 사용
((Eagle)animals[2]).fly();
}
}
}
-------------------------------------------------------------------------------
chapter17
추상메소드
본문({})이 없는 메소드이다
abstract public void move(); =추상메소드
추상 클래스
추상 클래스는 new를 할 수 없다.(객체생성불가)
부모클래스에 추상메소드를 상속받아 안에 데이터를 넣을 수 있다
abstract class Animal { // 추상 클래스 (일반 메소드 , 추상 메소드를 모두 가질 수 있다)
public void eat(String food) {
System.out.println(food + "먹는다");
}
abstract public void move(); // 추상 메소드 abstract
}
class Dog extends Animal {
@Override
public void move() {
System.out.println("강아지 산책한다.");
}
}
public class Ex01_abstract {
public static void main(String[] args) {
// 추상 클래스는 new 할 수 없다.(객체 생성 불가)
// Animal animal =new Animal();
Animal animal = new Dog();
animal.eat("사료");
animal.move();
}
}
-------------------------------------------------------------------
chapter18
인터페이스
구현클래스와 접점하기위한 역할을 한다
인터페이스는 추상메소드의 모음이다(추상 클래스가 인터페이스로 발전)
상수와 추상메소드만 구성 멤버로 갖는다
생성자를 가질 수 없다(객체생성이 안된다new)
상수는 반드시 선언과 동시에 초기값을 지정해야 한다
강제성이 부여된다
인터페이스는 상속(extends)받지 않고 구현(implements)한다
상속은 한번이지만 구현은 여러개를 가질 수 있다
인터페이스는 생성자가 없다 구현클래스를 통해서 객체를 만든다
구현클래스가 많으면 배열이나 업캐스팅 처리한다
interface Animal {
void move(); // 자동으로 abstract public void move(); 로 처리된다.
void eat(String food);
}
class Dog implements Animal {
@Override
public void move() {
System.out.println("개가 달린다.");
}
@Override
public void eat(String food) {
System.out.println(food + "먹는다");
}
}
public class Ex01_Interface {
public static void main(String[] args) {
// Animal animal = new Animal(); //생성 불가
Animal animal = new Dog();
animal.move();
animal.eat("사료");
}
}
----------------------------------------------------------------------
chapter19
예외(exception)
오류(error)의 일종이며 프로그램이 수행시 또는 컴파일에 불능 상태를 말한다
예외 처리 형식
try{
...예외가 발생 할 가능성이 있는 구역(예외가 발생하면 catch를 탄다)
}catch(예외를 받는 매개변수){
받는 예외를 처리하는 구역
}finally{
예외유무를 떠나 무조건 실행되는 구역
}
500에러 이클립스 콘솔창
404에러url(경로)
instanceof 형변환
throws(예외 떠넘기기)
-메소드를 호출한 곳으로 예외를 떠넘긴다.
-떠넘길 예외 클래스를 쉼표(,)로 구분해서 나열할 수 있다.
-throws 키워드가 붙어있는 메소드는 반드시 try 블록 내에서 호출도어야 한다.
*** 예외가 발생하는 곳에서 직접 try-catch 하지 않는 이유는
동시에 여러 개발자가 같은 메소드를 바라보고 있을 시
공용 처리보다는 throws로 각각 가져와 개별 처리를 하기 위함이다.
public class Ex06_exception {
//divide 메소드가 예외 발생 가능성이 있음
//throws를 사용하면 예외를 호출한 곳(main)으로 던진다.
//메소드를 여러 곳에서 사용하는 경우 꼭 throws를 사용하자.
public static void divide(int num1, int num2) throws ArithmeticException {
System.out.println("몫 : " + (num1 / num2));
System.out.println("나머지 : " + (num1 % num2));
}
public static void main(String[] args) {
try {
divide(5, 2);
divide(5, 0);
} catch (ArithmeticException e) {
System.out.println("0으로 나눌 수 없다.");
e.printStackTrace();
}
}
}
--------------------------------------------------------------------------------------
chapter20
api
chapter string
chapter caleder
chapter date
세가지 chapter만 읽고 써보기
---------------------------------------------------------------------------------------
chapter21
thread(개념만 이해하세요 일단)
동기 , 비동기 방식이 있다(서버단에서)
--------------------------------------------------------------------------------------
chapter22
제네릭
자바에서 코드에<string>꺽새가 들어가면 그것만 쓰겠다는 의미
컬렉션 등에서 널리 사용되므로 확실히 이해해 두어야 한다
클래스나 메소드에서 컴파일 할 때 타입체크를 하는 기능이다
미리 객체의 공통적인 타입을 명시
타입을 미리설정하는거 컬렉션이랑 같이 사용
----------------------------------------------------------------------------------------
chapter23
컬렉션 프레임워크(이클립스 자바 파일 내용 참고)
주요 인터페이스 분류
List(배열) for문사용
순서가 있는 데이터의 집합
중복저장 허용
Set
순서가 없는 데이터의 집합
중복 저장 불가
Map
키(key)와 값(value)의 쌍(pair)으로 이루어진 데이터
순서가 없는 데이터의 집합
키(key)는 중복 저장 불가
값(value)는 중복 저장 허용
반복자(iterator)를 사용 할 수 있다
구현클래스
<List>
ArrayList
객체(인스턴스)를 여러 개 저장 할 수 있는 '배열'을 구현한 컬렉션이다
가장 많이 사용하는 컬렉션이다
데이터의 중간 위치에 추가/제거가 어렵다. (<-> LinkedList : 추가/제거가 쉽다.)
List
LinkedList(앞쪽으로 바라보는 연결성이 중요)
추가/제거 작업이 빠르다.
Set(중복 제거 가능)
HashSet
add 한 순서를 유지하려면 LinkedHashSet클래스를 사용한다.
Map
HashMap
해시코드를 사용하는 Map 이다.(많은 양의 자료에 적합하다.)
키(key)와 값(value)의 조합으로 데이터를 저장한다.
TreeSet
일정기준을 가지고 검색을한다
headSet : 지정된 객체보다 작은 값의 객체들 반환
subSet :범위 내의 검색 결과 반환
tailSet : 지정된 객체보다 큰 값의 객체들 반환
- 메소드 오버로딩(overloading) (어노테이션 X)
: 메소드 이름이 같고, 매개변수 선언이 다른
- 메소드 오버라이딩(overriding) (어노테이션 O)
: 부모 클래스가 가지고 있는 메소드를
자식 클래스가 다시 만드는 것, 동일한 원형 다른 내용
// 상속 관계가 아닌 다른 클래스에서 메소드명이 같으면 그건 그냥 우연
- 첫 글자 대문자 Car : 클래스
- 첫 글자 소문자 car() : 메소드
- 합체 Car() : 생성자(기본 생성자/풀 생성자)
- 객체 : 클래스를 사용하기 위한 요소
- static : 객체를 생성하지 않고 사용(공유)
- final : 상수(값 바꾸지 않을 때)
- static final : 값이 변하지 않는 클래스 상수(초기화 필요)
- setter : 필드에 값을 저장하는 메소드들
- getter : 필드의 값을 읽어오는 메소드들, 무조건 return
c = str.charAt(0)
// charAt() : getter 개념
// c에 값 대입 : setter 개념
Person p = new Student( ) // 업캐스팅((부모 것만 사용 가능)
Student s = (Student)p // 다운캐스팅(자식 것만 사용 가능)
- 1 : 1 관계일 때
Student s = new Student() // 이것만 써도 괜찮음(자식이 부모 다 포함해서)
// Person p = new Person() 이거 안 써도 괜찮음
- 1 : N 관계일 때 (자식 여러개)
1) 배열 안에 넣어서 한번에 관리
// 하나씩 선언해서 관리
Person p1 = new Student();
Person p2 = new Worker();
Person p3 = new beaksu();
// 반복문으로 관리
Person[] parr;
for(int i = 0; i<parr.length; i++){
parr[i].eat();
if(parr[i] instanceof Student){ // 클래스가 Student에서 업캐스팅 했으면 if문 돌기
}
}
2) 부모와 자식의 일대일 관계라면 업캐스팅이 필요없지만 자식이 2명이상이라면 업캐스팅이 필요하다(배열안에 넣어서 안에 있는 데이터만 관리하면된다)
- 추상 메소드: 자식들한테 물려주기 위해 형태만 갖고 있음(자식이 구현)
- 추상 클래스 : 추상 메소드 존재
- 인터페이스
1) 생성자가 없어서 객체 생성 X (new 사용 X)
2) 상수는 반드시 선언과 동시에 초기값을 지정
3) 추상 메소드라 실행 블록(중괄호) 없음
4) 상속은 클래스 1개만 가능하지만 구현은 여러개 구현 가능
5) 구현도 상속의 일종이라 업캐스팅 가능
- 500 에러 : 자바(이클립스) 콘솔 확인
- 404 에러 : URL 확인
- 제네릭 : 미리 타입 정해둠(데이터를 넣기 전에 타입 체크해서 문제 사전 방지), 참조 타입 들어감(Integer, Double, String ...)
- 비제네릭 코드
List list = new ArrayList();
list.add("hello");
String str = (String)list.get(0); // 타입 변환을 해야 한다.
- 제네릭 코드
List<String> list = new ArrayList<String>(); // 이 List에는 String만 넣겠다고 선언
list.add("hello");
String str = list.get(0); // 타입 변환을 하지 않는다.
- List : 순서가 있는 데이터의 집합, 중복 O
- Set : 순서가 없는 데이터의 집합, 중복 X(알아서 중복 제거)
- Map : key, value 형식으로 사용, 순서가 없는 데이터의 집합, key는 중복 X, value는 중복 O
- 반복자 (Interator) 메소드
1) hasNext() : 다음 요소에 읽어 올 요소가 있는지 확인하는 메소드 있으면 true 없으면 false 반환.
2) next() : 다음 요소를 가져온다.
3) remove() : next()로 읽어온 요소 삭제한다.
- ArrayList : 비순차적 접근이 느리다.
- LinkedList : 중간 데이터 삭제에 유리하다.
- HashSet : add 한 순서를 유지하려면 LinkedHashSet 클래스 사용
- TreeSet : 트리 모양, 검색의 효율성 높임
- HashMap : key, value 구조(자바스크립트에서 객체도 동일), key들로만 저장되어 있어서 순서가 없다.
