Object 클래스 toSting() 오버라이드

Point.java

package com.javaex.api.objectclass.v1;

//	자바 최상위 클래스는 Object
public class Point {
	private int x;
	private int y;
	
	public Point(int x, int y) {
		this.x = x;
		this.y = y;
	}

	@Override
	public String toString() {
		//	객체 문자열 포맷을 반환
		return String.format("Point(%d, %d)",x,y);
	}
}

LangClassTest.java

package com.javaex.api.objectclass.v1;

public class LangClassTest {

	public static void main(String[] args) {
		Point p = new Point(10,10);
		
		//Object의 메서드를 기본 상속
		System.out.println(p.getClass().getName());	//	클래스 정보 : com.javaex.api.objectclass.v1.Point
		System.out.println(p.hashCode());	//	객체 식별자 : 1521118594
		System.out.println(Integer.toHexString(p.hashCode()));	//	5aaa6d82
		
		System.out.println(p);	//	클래스명@해시코드 16진수 값 : com.javaex.api.objectclass.v1.Point@5aaa6d82
		System.out.println(p.toString());
		
	}

}

결과 

com.javaex.api.objectclass.v1.Point
1521118594
5aaa6d82
Point(10, 10)
Point(10, 10)

 

 

equals( )

package com.javaex.api.objectclass.v2;

public class LangClassTest {

	public static void main(String[] args) {
		Point p1 = new Point(10,10);
		Point p2 = new Point(10,10);
		
		System.out.println("p1 == p2 ? " + (p1 == p2));
		System.out.println("p1.equals(p2) ? " + p1.equals(p2));
	}

}

결과

p1 == p2 ? false
p1.equals(p2) ? false

 

equals 오버라이딩

Point.java

package com.javaex.api.objectclass.v2;

//	자바 최상위 클래스는 Object
public class Point {
	private int x;
	private int y;
	
	public Point(int x, int y) {
		this.x = x;
		this.y = y;
	}

	@Override
	public String toString() {
		//	객체 문자열 포맷을 반환
		return String.format("Point(%d, %d)",x,y);
	}

	@Override
	public boolean equals(Object obj) {
		if(obj instanceof Point) {
			Point other = (Point)obj;	//	변환
			return x == other.x && y == other.y;
		}
		return super.equals(obj);
	}
	
	
}

결과 

p1 == p2 ? false
p1.equals(p2) ? true

 

 

객체 단순 복제

LangClassTest.java

package com.javaex.api.objectclass.v3;

public class LangClassTest {

	public static void main(String[] args) {
		Point p1 = new Point(10,10);
		
		System.out.println("p1 =" + p1);
		
		Point p2 = p1.getClone();	//	복제
		System.out.println("p2 =" + p2);
		
		System.out.println("p1 == p2 ? "+ (p1 == p2));
		
		p1.setX(100);
		p1.setY(200);
		System.out.println("p1 =" + p1);
		System.out.println("p2 =" + p2);
		
	}

}

Point.java

package com.javaex.api.objectclass.v3;

//	v3. 얕은 ㅗㅂ갓

// 	객체 필드데이터를 단순 복제
//	Cloneable 인터ㅔ이스 구현
public class Point implements Cloneable{
	public Point getClone() {
	//복제본
	Point clone = null;
	try {
		clone = (Point) clone();
	}catch(CloneNotSupportedException e) {
		e.printStackTrace();
	}
	return clone;
	}
	
	
	public int getX() {
		return x;
	}

	public void setX(int x) {
		this.x = x;
	}

	public int getY() {
		return y;
	}

	public void setY(int y) {
		this.y = y;
	}

	private int x;
	private int y;
	
	public Point(int x, int y) {
		this.x = x;
		this.y = y;
	}

	@Override
	public String toString() {
		//	객체 문자열 포맷을 반환
		return String.format("Point(%d, %d)",x,y);
	}

	@Override
	public boolean equals(Object obj) {
		if(obj instanceof Point) {
			Point other = (Point)obj;	//	변환
			return x == other.x && y == other.y;
		}
		return super.equals(obj);
	}
	
	
}

 

결과 : 

p1 =Point(10, 10)
p2 =Point(10, 10)
p1 == p2 ? false
p1 =Point(100, 200)
p2 =Point(10, 10)

객체 필드 데이터 단순 복제

 

깊은 복제

LangClassTest.java

package com.javaex.api.objectclass.v4;

public class LangClassTest {

	public static void main(String[] args) {
		ScoreBoard s1 = new ScoreBoard(new int[] { 10,20,30,40});
		System.out.println("s1 = " + s1);
		
		ScoreBoard s2 = s1.getClone();
		System.out.println("s2 = " + s2);
		
		System.out.println("s1 == s2 ? "+ (s1 == s2));
		
		s2.getScores()[2] = 100;
		System.out.println("s1 = " + s1);
		System.out.println("s2 = " + s2);
		System.out.println("s1.scores == s2.scores ? "+ (s1.getScores() == s2.getScores()));
	}

}

ScoreBoard.java

package com.javaex.api.objectclass.v4;

import java.util.Arrays;

//	v4. 깊은 복제
public class ScoreBoard implements Cloneable{
	//참조 타입 필드
	private int[] scores;
	
	//	생성자
	public ScoreBoard(int[] scores) {
		this.scores = scores;
	}
	
	public ScoreBoard getClone() {
		ScoreBoard clone = null;
		try {
			clone = (ScoreBoard)clone();
		}catch(CloneNotSupportedException e) {
			e.printStackTrace();
		}
		
		return clone;
	}

	public int[] getScores() {
		return scores;
	}

	public void setScores(int[] scores) {
		this.scores = scores;
	}

	@Override
	public String toString() {
		return "ScoreBoard [scores=" + Arrays.toString(scores) + "]";
	}
	
	
}

결과 

s1 = ScoreBoard [scores=[10, 20, 30, 40]]
s2 = ScoreBoard [scores=[10, 20, 30, 40]]
s1 == s2 ? false
s1 = ScoreBoard [scores=[10, 20, 100, 40]]
s2 = ScoreBoard [scores=[10, 20, 100, 40]]
s1.scores == s2.scores ? true

객체를 만드는 것

 

깊은 복제를 얕은 복제 시도

LangClassTest.java

package com.javaex.api.objectclass.v4;

public class LangClassTest {

	public static void main(String[] args) {
		ScoreBoard s1 = new ScoreBoard(new int[] { 10,20,30,40});
		System.out.println("s1 = " + s1);
		
		ScoreBoard s2 = s1.getClone();
		System.out.println("s2 = " + s2);
		
		System.out.println("s1 == s2 ? "+ (s1 == s2));
		
		s2.getScores()[2] = 100;
		System.out.println("s1 = " + s1);
		System.out.println("s2 = " + s2);
		System.out.println("s1.scores == s2.scores ? "+ (s1.getScores() == s2.getScores()));

	}

}

ScoreBoard.java

package com.javaex.api.objectclass.v4;

import java.util.Arrays;

//	v4. 깊은 복제
public class ScoreBoard implements Cloneable{
	//참조 타입 필드
	private int[] scores;
	
	//	생성자
	public ScoreBoard(int[] scores) {
		this.scores = scores;
	}
	
	public ScoreBoard getClone() {
		ScoreBoard clone = null;
		try {
			clone = (ScoreBoard)clone();
		}catch(CloneNotSupportedException e) {
			e.printStackTrace();
		}
		
		return clone;
	}

	public int[] getScores() {
		return scores;
	}

	@Override
	protected Object clone() throws CloneNotSupportedException {
		//	1. 얕은 복제 시도
		ScoreBoard clone = (ScoreBoard)super.clone();
		//	2. 내부 참조 객체를 복제
		clone.scores = Arrays.copyOf(scores, scores.length);
		return clone;
	}

	public void setScores(int[] scores) {
		this.scores = scores;
	}

	@Override
	public String toString() {
		return "ScoreBoard [scores=" + Arrays.toString(scores) + "]";
	}
	
	
}

결과

s1 = ScoreBoard [scores=[10, 20, 30, 40]]
s2 = ScoreBoard [scores=[10, 20, 30, 40]]
s1 == s2 ? false
s1 = ScoreBoard [scores=[10, 20, 30, 40]]
s2 = ScoreBoard [scores=[10, 20, 100, 40]]
s1.scores == s2.scores ? false

참조 타입 필드를 같이 참조하다가.

1. 얕은 복제하고

2. 내부 참조 객체를 복사해왔다.

'study > JAVA 전문가' 카테고리의 다른 글

Wrapper Class, 제너릭, ,,  (0) 2021.12.08
arrays 클래스  (0) 2021.12.08
인터페이스  (0) 2021.12.07
예외  (0) 2021.12.07
추상 클래스  (0) 2021.12.07

인터페이스

  • 서로 관계가 없는 물체들이 상호작용 하기 위해
  • 실제 클래스만 상관없이 규약만 맞으면 어디든 저장 상관 X
  • 하나 또는 그 이상 클래스들에서 똑같이구현되어질 법한 메서드 선언할 때
  • 개발 코드를 수정하지 않고, 가용하는 객체를 변경할 수 있도록
  • 부모클래스로 자식 객체 참조 O
  • 인터페이스로 구현한 객체를 참조할 수 있다.
  • 선언 : interfce "인터페이스명"
    • abstract 키워드 지정 안해도 됨 -> 추상메소드만 들어가기 때문
  • 다중 implements할 수 있음

 

추상클래스 인터페이스
- 상속관계
- "확장"
상속관계를 해치지 않음 (상속관계 상관 X)
그냥 비슷한 규약(함수) 적용

 

변수명

  • 윈도 C++ -> "I인터페이스명"
  • java -> "___able"

 

실습

ShapeApp.java

package com.javaex.oop.shape.v2;

public class ShapeApp {

	public static void main(String[] args) {
//		shape  s = shape();	//	에러 -> 추상 클래스는 객체화 할 수 없다.
		Rectangle r = new Rectangle(10, 20, 100, 50);
		r.draw();
		
		Circle c = new Circle(10, 10, 30);
		c.draw();
		
		Point p = new Point(100,100);
		
		
		System.out.println("p는 Drawable을 구현했는가?\n" + (p instanceof Drawable ? "Drawalbe 구현 O":"Drawalbe 구현 X"));
	}
}

Drawable.java (인터페이스)

package com.javaex.oop.shape.v2;

//	내부에 추상 메서드만 가진다 (	abstract 생략)
public interface Drawable {
	public void draw();
}

Rectangle.java

package com.javaex.oop.shape.v2;


public class Rectangle extends Shape implements Drawable{
	//	필드
	protected int width;
	protected int height;
	
	public Rectangle(int x, int y, int width, int height) {
		super(x,y);
		this.width = width;
		this.height = height;
	}
	
	
	//	모두 구현해줘야 한다. 
	//	source -> override/.. 클릭
	@Override
	public void draw() {
		System.out.printf("사각형[x = %d, y = %d, w = %d, h = %d, area = %f]\n",x,y,width, height,area());
	}

	@Override
	public double area() {
		return width * height;
	}	
}

Circle.java

package com.javaex.oop.shape.v2;

public class Circle extends Shape implements Drawable{
	protected double r;
	
	public Circle(int x, int y, int r) {
		super(x, y);
		this.r = r;
	}

	
	@Override
	public void draw() {
		System.out.printf("원[x=%d, y=%d, r=%f, area = %f]을 그렸어요\n", x,y,r,area());
	}

	@Override
	public double area() {
		return Math.PI * Math.pow(r, 2);
	}

}

Point.java

package com.javaex.oop.shape.v2;

public class Point implements Drawable {

	protected int x;
	protected int y;
	
	public Point(int x, int y) {
		this.x = x;
		this.y = y;
	}
	@Override
	public void draw() {
		System.out.printf("점[x=%d, y=%d]을 그렸습니다.\n",x,y);
	}
	

}

shape.java

package com.javaex.oop.shape.v2;

//	추상 클래스
public abstract class Shape {
	protected int x;
	protected int y;
	
	public Shape(int x, int y) {
		this.x = x;
		this.y = y;
	}
	
	//	추상 클래스는 내부에 반드시 하나 이상의 추상메소드가 있어야 
//	public abstract void draw();	//	인터페이스에 위임
	public abstract double area();
}

결과

사각형[x = 10, y = 20, w = 100, h = 50, area = 5000.000000]
원[x=10, y=10, r=30.000000, area = 2827.433388]을 그렸어요
p는 Drawable을 구현했는가?
Drawalbe 구현 O

 

 

  • 공통점만 뽑아서 관리하면 상속관계에 상관없이 관리 가능

ShapeApp.java

package com.javaex.oop.shape.v2;

public class ShapeApp {

	public static void main(String[] args) {
//		shape  s = shape();	//	에러 -> 추상 클래스는 객체화 할 수 없다.
		Rectangle r = new Rectangle(10, 20, 100, 50);
		r.draw();
		
		Circle c = new Circle(10, 10, 30);
		c.draw();
		
		Point p = new Point(100,100);
		
		
		System.out.println("p는 Drawable을 구현했는가?\n" + (p instanceof Drawable ? "Drawalbe 구현 O":"Drawalbe 구현 X"));
		
		//	인터페이스로 구현 객체를 참조할 수 있다.
		Drawable[] objs = new Drawable[] {
				r,c,p
		};
		for(Drawable obj : objs) {
			obj.draw();
		}
	}
}

 

 

'study > JAVA 전문가' 카테고리의 다른 글

arrays 클래스  (0) 2021.12.08
얕은 복제, 깊은 복제  (0) 2021.12.07
예외  (0) 2021.12.07
추상 클래스  (0) 2021.12.07
[모의 필기테스트] 오답노트 & 정리  (0) 2021.12.07

예외가 발생하면 완벽하게 복구를 할 수가 없는 경우가 있다.

예외

  • 프로그램이 실행되는동안 발생할수 있는 비정상적인 상태
  • 컴파일시의 에러말고 실행시의 에러
  • 모든 예외 => Exception을 사용
  • 예외에는 구체적 예외, 일반적 예외가 있슴
    • 처음에 구체적 예외로 거르다가
    • catch문 밑으로 갈 수록 일반적 예외를 사용해라
    • 마지막엔 Excpetion 써라

ArithmeticException 예외 발생 

package com.javaex.exception;
import java.util.*;
public class ExceptionEx {

	public static void main(String[] args) {
		ArithmeticEx();
	}
	//	어떤 수를 0으로 나눌 때
	private static void ArithmeticEx() {
		double result = 0;
		int num;
		
		Scanner scanner = new Scanner(System.in);
		System.out.print("정수 입력:");
		
		//	예외 발생 가능 영역
		num = scanner.nextInt();
		result = 100/num;
		
		System.out.println(result);
		scanner.close();
	}
}

ArithmeticException 예외 처리 ->

package com.javaex.exception;
import java.util.*;
public class ExceptionEx {

	public static void main(String[] args) {
		ArithmeticEx();
	}
	//	어떤 수를 0으로 나눌 때
	private static void ArithmeticEx() {
		double result = 0;
		int num;
		
		Scanner scanner = new Scanner(System.in);
		System.out.print("정수 입력:");
		
		try {
			//	예외 발생 가능 영역
			num = scanner.nextInt();
			result = 100/num;
		}catch(ArithmeticException e) {
			System.err.println("0으로는 나눌 수 없어요");
		}
		catch(Exception e) {
			e.printStackTrace();	
		}
		
		System.out.println(result);
		scanner.close();
	}
}

 

결과 

정수 입력:0
0으로는 나눌 수 없어요
0.0

 

 

예제

package com.javaex.exception;
import java.util.*;
public class ExceptionEx {

	public static void main(String[] args) {
		ArithmeticEx();
	}
	//	어떤 수를 0으로 나눌 때
	private static void ArithmeticEx() {
		double result = 0;
		int num;
		
		Scanner scanner = new Scanner(System.in);
		System.out.print("정수 입력:");
		
		try {
			//	예외 발생 가능 영역
			num = scanner.nextInt();
			result = 100/num;
		}catch(InputMismatchException e) {	//	정수 입력 안 했을 경우
			System.err.println("정수로 해주세요");
		}
		catch(ArithmeticException e) {		//	0으로 나눴을 경우
			System.err.println("0으로는 나눌 수 없어요");
		}
		catch(Exception e) {	//	모든 예외 처리 가능
			e.printStackTrace();	
		}finally {
			System.out.println("예외 처리 종료");
			//	예외 유무 관계 없이 가장 마지막에
			//	자원 정리 작업에 많이 활용
		}
		
		System.out.println(result);
		scanner.close();
	}
}

 

강제 예외 발생

ExceptionEx.java

package com.javaex.exception;
import java.io.IOException;
import java.util.*;
public class ExceptionEx {

	public static void main(String[] args) {
//		ArithmeticEx();
		throwExceptionEx();
	}
	

	private static void throwExceptionEx() {
		ThrowsExcept except = new ThrowsExcept();
		try {
			except.executeException();	//	호출하는 메소드에서 처리 못 하면 
		}catch(IOException e) {
			System.err.println(e.getMessage());
		}
		System.out.println("예외 처리 완료");
	}
 }

호출하는 메서드에서 처리를 못 하면 예외를 그냥 던져주는게 좋음

 

사용자 정의 예외 사용

ExceptionEx.java

package com.javaex.exception;
import java.io.IOException;
import java.util.*;
public class ExceptionEx {

	public static void main(String[] args) {
//		ArithmeticEx();
		throwExceptionEx();
	}
	

	private static void throwExceptionEx() {
		ThrowsExcept except = new ThrowsExcept();
		try {
			except.executeRuntimeException();	//	호출하는 메소드에서 처리 못 하면 던져 주는 게 좋다. 
			except.executeException();
		}catch(RuntimeException e) {
			System.err.println(e.getMessage());
		}catch(IOException e) {
			System.err.println(e.getMessage());
		}
		
		//	사용자 정의 예외 사용
		try {
			System.out.println(except.divide(100, 0));
		}catch(CustomArithException e) {
			System.err.println(e.getMessage());
			//	예외 상황 확인
			System.err.println("나누어지는 수 : " + e.getNum1());
			System.err.println("나누는 수 : " + e.getNum2());
		}
		System.out.println("예외 처리 완료");
	}
 }

ThrowsException.java

package com.javaex.exception;

import java.io.IOException;

//	사용자 정의 예외 정의

class CustomArithException extends ArithmeticException{
	//	예외 상황 필드
	private int num1;
	private int num2;
	
	public CustomArithException(String message, int num1, int num2) {
		super(message);
		//	예외 상황 정보 저장
		this.num1 = num1;
		this.num2 = num2;
	}
	
	public void setNum1(int num1, int num2) {
		this.num1 = num1;
		this.num2 = num2;
	}
	public int getNum1() {
		return this.num1;
	}
	public int getNum2() {
		return this.num2;
	}
}



public class ThrowsExcept {
	//	checked Exception
	public void executeException() throws IOException {
		System.out.println("강제 예외 발생");
		throw new IOException("강제 예외");
	}
	
	//Unchecked Exception
	public void executeRuntimeException() {
		System.out.println("런타임오류");
		throw new RuntimeException("런타임 예외");
	}
	
	//
	public double divide(int num1, int num2) {
		if(num2 == 0) {
			//ArithmeticException
			//	구체적 예외롤 전환하여 throw 하는 것이
			//	1. 가독성을 높이고
			//	2. 예외 상황 정보를 가져올 수 있다.
			throw new CustomArithException("사용자 정의 예외", num1, num2);
		}
		return num1 / num2;
	}
}

결과

런타임오류
런타임 예외
사용자 정의 예외
나누어지는 수 : 100
나누는 수 : 0
예외 처리 완료

'study > JAVA 전문가' 카테고리의 다른 글

얕은 복제, 깊은 복제  (0) 2021.12.07
인터페이스  (0) 2021.12.07
추상 클래스  (0) 2021.12.07
[모의 필기테스트] 오답노트 & 정리  (0) 2021.12.07
java Class  (0) 2021.12.06

추상클래스

  • 코드 만들 때 중요한 정보와 그렇지 않은 정보를 구분해서 설계해야 함
  • 공통 속성을 뽑아냄 (일반화)
  • ex) Animal(추상클래스)은 Dog와 Cat의 공통 속성을 뽑아낸다.

 

추상화 

  • 중요한 것은 남기고 필요 없는 것은 없애는 것
  • 객체들 간의 공통되는 특성을 추출하는 것

 

추상 클래스

  • 실체 클래스를 만들기 위한 부모 클래스로만 사용
    • 스스로 객체가 될 수 X -> 부모 클래스로만 사용
    • 물려주기만 하는 용도 (확장을 위한 용도)
    • 구현이 불가능 -> 선언만 함
  • 하나 이상의 메서드만 가짐
  • 속성(필드)와 기능(메서드)를 정의할 수 있다
  • 추상 클래스를 상속하는 실체 클래스 -> 추상 메소드를 반드시 구현해야함
    • 특정 기능을 구현 강요하는 측면 있음
      • ex) Car라는 추상 클래스를 상속하는 Sport Car가 있으면
      • Car의 가속()이라는 메소드를 Sport Car 클래스에 가속()클래스를 오버라이딩해서 무조건 구현해야한다.
  • 추상 메소드는 추상 클래스에만 존재
    • 추상 클래스는 하나 이상의 추상 메서드를 가짐
      • 오버라이딩 해야함

 

추상 클래스의 선언

  • 클래서 선언에 abstrct 키워드

 

실습

shpae.java

package shape.v1;

//	추상 클래스
public abstract class Shape {
	protected int x;
	protected int y;
	
	public Shape(int x, int y) {
		this.x = x;
		this.y = y;
	}
	
	//	추상 클래스는 내부에 반드시 하나 이상의 추상메소드가 있어야 
	public abstract void draw();
	public abstract double area();
}

Rectangle.java

package shape.v1;

public class Rectangle extends Shape{
	//	필드
	protected int width;
	protected int height;
	
	public Rectangle(int x, int y, int width, int height) {
		super(x,y);
		this.width = width;
		this.height = height;
	}
	
	
	//	모두 구현해줘야 한다. 
	//	source -> override/.. 클릭
	@Override
	public void draw() {
		System.out.printf("사각형[x = %d, y = %d, w = %d, h = %d, area = %f]\n",x,y,width, height,area());
	}

	@Override
	public double area() {
		return width * height;
	}	
}

Circle.java

package shape.v1;

public class Circle extends Shape {
	protected double r;
	
	public Circle(int x, int y, int r) {
		super(x, y);
		this.r = r;
	}

	
	@Override
	public void draw() {
		System.out.printf("원[x=%d, y=%d, r=%f, area = %f]을 그렸어요\n", x,y,r,area());
	}

	@Override
	public double area() {
		return Math.PI * Math.pow(r, 2);
	}

}

ShapeApp.java (메인)

package shape.v1;

public class ShapeApp {

	public static void main(String[] args) {
//		shape  s = shape();	//	에러 -> 추상 클래스는 객체화 할 수 없다.
		Rectangle r = new Rectangle(10, 20, 100, 50);
		r.draw();
		
		Circle c = new Circle(10, 10, 30);
		c.draw();
	}

}

결과

사각형[x = 10, y = 20, w = 100, h = 50, area = 5000.000000]
원[x=10, y=10, r=30.000000, area = 2827.433388]을 그렸어요

 

 

'study > JAVA 전문가' 카테고리의 다른 글

인터페이스  (0) 2021.12.07
예외  (0) 2021.12.07
[모의 필기테스트] 오답노트 & 정리  (0) 2021.12.07
java Class  (0) 2021.12.06
[DAY+2]Java Programming  (0) 2021.12.03

클래스 선언 불가 : protected, private

  • protected 
    • 다른 패키지에 있는 생성자, 메소드, 필트 호출 X
    • 상속 관계에 있는 클래스 : 호출 O
      • 자식클래스에서 protected변수 불러오기 가능
    • protected 메소드는 모든 하위 클래스에서 호출 할 O
  • private
    • 클래스 내부만 사용 가능

try catch문 그 다음 finally가 있음

  • finally는 무조건 실행 되는 친구

String

  1. Strring 변수는 바로 초기화 안 해주면 에러다
    • Stirng a; (X)
    • String a = new String() (O)
    • String a = ""; (O)
  2. String 타입은 객체형이다.

Static

  1. Static변수는 메인 안에 선언X
    1. 지역 변수에 static 못 붙음
  2. Static안에서 static이 안 붙은 클래스 or 객체 생성하지 못 한다. 
    • Static { Person a =  new Person(); (X) }
    • static { class Person(){ ... } (X)

Class

  • 복수의 인터페이스 구현 (implements)할 수 O
  • 복수의 부모 클래스로부터 상속 받을 수 X
  • 모든 클래스는 상속을 통한 확장(extend)이 가능X -> finall클래스 안 됨
    • finall 클래스는 상속 X

인터페이스

  • 인터페이스는 또 다른 인터페이스로부터 상속받을 수 있다.
  • 인터페이스를 구현한 클래스는 인터페이스에 포함된 모든 메소드를 구현하지 않아도 됨

finall

  • finall 클래스는 오버로딩 할 수 X
  • finall 클래스는 상속 X

Garbage Collection

  • 자바 프로그램 실행 중 객체가 garbage collection 되지 않을 수 있다.
  • garbage collection 이 객체의 완전한 소멸을 의미X
  • System.gc() 메소드를 호출하여 강제로 garbage collection 을 실행해도 garbage collection이 보장 X

오류

  • 컴파일 오류 : 빨간줄 뜨는 것
  • 런타임 오류 : 실행 했을 때
  • 논리적 오류 : 프로그램 잘 못 짠 것

추상 클래스

  • 추상 클래스는 추상 메소드를 아무것도 가지지 않아도 된다.
  • 객체를 생성할 수 X

'study > JAVA 전문가' 카테고리의 다른 글

인터페이스  (0) 2021.12.07
예외  (0) 2021.12.07
추상 클래스  (0) 2021.12.07
java Class  (0) 2021.12.06
[DAY+2]Java Programming  (0) 2021.12.03

- 클래스의 구조

  • 필드
    • 객체 데이터, 상태 저장하는 변수
    • 멤버 변수 
    • Goods.java
    •  
    • package com.javaex.oop.goods.v1; public class Goods { // 필드 String name; int price; }​
    • GoodsApp.java
    • package com.javaex.oop.goods.v1;
      
      public class GoodsApp{
      	public static void main(String [] args) {
      		Goods camera = new Goods();
      		camera.name = "nikon";
      		camera.price = 400000;
      		
      		Goods smartphone = new Goods();
      		smartphone.name = "iPhone 13";
      		smartphone.price = 1000000;
      		
      		System.out.println("이름 : " + camera.name + "\n가격 : " + camera.price);
      		System.out.println("이름 : " + smartphone.name + "\n가격 : " + smartphone.price);
      	}
      }
      결과 
      이름 : nikon
      가격 : 400000
      이름 : iPhone 13
      가격 : 1000000
  • 생성자
    • 객체 생성시 수행되는
    • 목적 : 객체 초기화 -> heap 객체 생성 -> 조소값 받기
  • 메소드

 

- 접근 제한자

public > protected > default > private

  • public
  • protected
  • default
    • 아무것도 안 적으면 default
  • private
    • 자신의 클래스 안에만 사용 가능

 

- 메서드

  • 매개변수
    • 메소드 호출에서 들어가는 구체적인 값 : 인자(Argument)
  • 반환타입
    • int일 때, return 비워두면 안 된다.
  • 메서드 이름
    • 메서드 명은 기능을 알기 쉽게 작성해야함 (ex. a, b, c, -> 무슨 기능인지 알 수 없음)
    • package com.javaex.oop.methods;
      
      public class MethodsEx {
      	public static void main(String[] args) {
      		//입력 x, 출력 x
      		printMessage();
      		
      		//입력 o, 출력 o
      		double result = getSum(4,5);
      		System.out.println("4 + 5 = "+ result);
      		
      		//입력 x, 출력 o
      		//입력 o, 출력 x
      		
      		printTotal("합계", 1,2,3,4,5,6,7,8,9);
      	}
      	//고정인수, 가변 인수
      	private static void printTotal(String message, double ... values) {
      		System.out.println(message+ " : " + getTotal(values));
      	}
      	
      	//가변 인수를 이용한 다수 인수 전달
      	private static double getTotalVar(double ... values) {
      		return getTotal(values);
      	}
      	
      	private static double getTotal(double[] values) {
      		double total = 0;
      		
      		for(double value: values) {
      			total += value;
      		}
      		return total;
      	}
      }

 

- 가변 인수

  • 매개 변수의 개수를 알 수 없을 때 사용
  • 고정인수, 가변인수 같이 올 때 -> ① 고정인수, ②가변인수 (순서 중요)
    public class MethodsEx {
    	public static void main(String[] args) {		
    		printTotal("합계", 1,2,3,4,5,6,7,8,9);
    	}
    	//고정인수, 가변 인수
    	private static void printTotal(String message, double ... values) {
    		System.out.println(message+ " : " + getTotal(values));
    	}
    	
    	private static double getTotal(double[] values) {
    		double total = 0;
    		
    		for(double value: values) {
    			total += value;
    		}
    		return total;
    	}
    }​

- Getter, Setter

  • 객체 외부에서 직접적으로 접근하는 것을 막음

Goods.java

  • package v2;
    
    public class Goods {
    	//	필드
    	private String name;
    	private int price;
    	
    	//외부 접근 방식 노출
    	//	getter/setter
    	//	getter : 데이터 참조하기 위함
    	public String getName() {
    		return name;
    	}
    	
    	public void setName(String name) {
    		this.name = name;
    	}
    	
    	public int getPrice() {
    		return price;
    	}
    	
    	public void showInfo() {
    		System.out.println("상품이름 : " + name);
    		System.out.println("가격 : "+ price);
    	}
    }
     Goods.App.java
    package v2;
    
    public class GoodsApp{
    	public static void main(String [] args) {
    		Goods camera = new Goods();
    		camera.setName("nikon");
    		camera.setPrice(400000);
    		
    		Goods smartphone = new Goods();
    		smartphone.setName("iPhone 13");
    		smartphone.setPrice(1000000);
    		
    //		System.out.println("이름 : " + camera.getName() + "\n가격 : " + camera.getPrice());
    		camera.showInfo();
    //		System.out.println("이름 : " + smartphone.getName() + "\n가격 : " + smartphone.getPrice());
    		smartphone.showInfo();
           	}
    }​

생성자

  • 생성자를 실행시키지 않고 클래스로부터 객체 만들 수 없다.
  • void 안 씀
  • setter가 없으면 readOnly

 

this

  • 현재 사용중인 instance 자신
  • this() : 현재 인스턴스에 있는 다른 생성자 호출
    	public Goods(String name) {
    		this.name = name;
    	}
    	
    	//	생성자 2.
    	public Goods(String name, int price) {
    		this(name);	//	다른 생성자 호출
    		this.price = price;
    	}​

 

메소드 오버로딩

  • 하나의 클래스에 같은 이름의 메소드 존재 가능

 

static, instance, local

  • static :
    • 클래스 영역
    • 해당 클래스로 만들어진 인스턴스
    • new 아니라도 접근 가능
    • static내에서는 static 멤버만 접근 가능 
      • static -> instance 접근 (x)
        public class StaticEx {
        	public static int refCount;	//	 클래스(static) 멤버
        	public static String classVar;	//	클래스 멤버
        	public String instanceVar;	//	인스턴스 멤버
        	
        	// 	static 블록으로 static 영역의 초기화
        	static {
        		refCount = 0;
        		classVar = "static Member";
        		//instanceVar = "Instance Member";	-> 에러
        		// 중요 : sataic 영역에서는 static 만 접근 가능
        	}
        
        }​
  • instance
    • 클래스 영역
    • new 키워드로 인스턴스 사용
    • 인스턴스 내에서 사용
    • instance -> static영역 접근 가능
      public class StaticEx {
      	public static int refCount;	//	 클래스(static) 멤버
      	public static String classVar;	//	클래스 멤버
      	public String instanceVar;	//	인스턴스 멤버
      	
      	// 	static 블록으로 static 영역의 초기화
      	static {
      		refCount = 0;
      		classVar = "static Member";
      		//instanceVar = "Instance Member";	-> 에러
      		// 중요 : sataic 영역에서는 static 만 접근 가능
      	}
      	
      	StaticEx(){
      		//	참조 카운트 증가
      		// 	인스턴스 멤버 -> sataic 멤버 접근 가능
      		refCount++;
      		System.out.println("인스턴스 갯수 : " + refCount);
      	}
      
      }​

    • StaticEx.java
      package com.javaex.oop.staticmember;
      
      public class StaticEx {
      	public static int refCount;	//	 클래스(static) 멤버
      	public static String classVar;	//	클래스 멤버
      	public String instanceVar;	//	인스턴스 멤버
      	
      	// 	static 블록으로 static 영역의 초기화
      	static {
      		refCount = 0;
      		classVar = "static Member";
      		//instanceVar = "Instance Member";	-> 에러
      		// 중요 : sataic 영역에서는 static 만 접근 가능
      		System.out.println("static Block");
      	}
      	
      	StaticEx(){
      		//	참조 카운트 증가
      		// 	인스턴스 멤버 -> sataic 멤버 접근 가능
      		refCount++;
      		System.out.println("인스턴스 갯수 : " + refCount);
      		System.out.println("생성자 호출 : 인스턴스 생성");
      	}
      
      }​
      StaticApp.java
    • package com.javaex.oop.staticmember;
      
      public class StaticApp {
      
      	public static void main(String[] args) {
      		StaticEx s1 = new StaticEx();
      		//static 멤버는 new 없이 접근 가능
      		System.out.println("RefCount"+ StaticEx.refCount);
      		
      		StaticEx s2 = new StaticEx();
      		System.out.println("RefCount"+ StaticEx.refCount);
      	}
      }
      • static영역 먼저 실행
      • StaticApp의 생성자 실행
      • StaticApp mian의 프린트 실행
    • 객체 초기화 : null 로 설정해주면 됨 (heap 메모리에 남아있지만, GTC를 통해 없어짐)
      // 소멸자
      	@Override
      	protected void finalize() throws Throwable{
      		refCount--;
      		System.out.println("소멸자 호출");
      		super.finalize();
      	}​
      	// 	주의 : 가비지 컬렉터를 직접 호출하지 않는다. 
      		System.gc();
      		try {
      			Thread.sleep(3000);//3초간  대기
      		}catch(Exception e) {​
      가비지 수집기 : 사용하지 않은 메모리를 자동적으로 회수하는 서비스GC클래스 : 가비지 수집기 제어
  • local 영역
    • 메서드 영역
    • 메소드 내에서 사용
    • 벗어나면 찾을 수 없음

 

singleton (static의 활용)

  • 단 하나의 인스턴스만 유지
    • 함부러 생성자 호출 불가능하게 -> 생성자를 private로
    • 단 한번만 수행 -> static으로 객체 만들기

Singleton.java

package com.javaex.oop.staticmember;

//	목표 : 어떤 상황에서든 단 한개의 인스턴스만 유지
public class Singleton {
	//	생성자
	private Singleton() {
		
	}
}​

SingletonApp.java

 

package com.javaex.oop.staticmember;

public class SingletonApp {

	public static void main(String[] args) {
		Singleton s1 = new Singleton();	//	생성 불가
	}

}

 

  •  
  •  
  • static 블록에서 생성자 호출
    • Singleton.java
package com.javaex.oop.staticmember;

//	목표 : 어떤 상황에서든 단 한개의 인스턴스만 유지
public class Singleton {

	//	static 블록에서 생성자를 호출
	private static Singleton instance  =  new Singleton();
	
	//	생성자
	private Singleton(){
		
	}

	public static Singleton getInstance() {
		return instance;
	}
}​
  • SingletonApp.java
    package com.javaex.oop.staticmember;
    
    public class SingletonApp {
    
    	public static void main(String[] args) {
    //		private static s1 = new Singleton();	//	생성 불가
    		Singleton s1 = Singleton.getInstance();
    		Singleton s2 = Singleton.getInstance();
    		
    		//객체 주소가 같으면 같은 객체다.
    		System.out.println("s1, s2 같은 객체? " + (s1 == s2));
    	}
    
    }​

 

상속 ( Inheritance )

  • 클래스간 계층적 분리 및 관리 가능
  • 중복 상속을 제거한다. (오직 하나만 상속한다.)
    • ex) 엄마, 아빠 클래스 중 뭐 쓸까 고민,,하는거 안 해도 됨
  • 가급적으로는 상속 배제하도록
    • 상속의 깊이이가 길어지면 유지보수가 어려워진다. 
  • 최상위 클래스 : java.lang.Object
  • 자식 생성자에서 특별한 지시가 없으면 부모 클래스의 기본 생성자가 선택됨
    • 부모의 특정 생성자 사용시에는 명시 해줘야한다. -> super(x,y);
  • 부모의 필드나 메서드에 접근시에는 super 키워드 사용

 

메서드 오버라이딩 (Method Overriding)

  • 물려받은 것을 사용하지 않고, 다른 기능 사용하는 것
    • 같은 이름, 같은 리턴타입, 같은 시그너쳐
    • 부모 메서드 무시
  • @Overriding ( 일종의 지시자 )
    • 매서드 앞에 명시 -> 부모에게 메서드가 있는가?
      • 진짜로 오버라이딩 한 건가?
      • 컴파일러에게 맡김 
      • 시그너쳐 위반 했는지 안 했는지 
  • 객체를 참조하고자 할 때
    • 자식 객체를 부모 타입으로 참조할 수 있다. 
    • 부모 참조
      • person p1 = new Student( );
        • 참조 타입(person) 설계도 내의 메서드만 호출 가능
        • p1.getName( ) (O)
        • p1.getSchoolName( ) (X) -> person에 없음
        • p1.showInfo( ) -> 오브라이딩 된 자식 클래스의 메소드
    • 자기자신 타입으로 참조
      • Studnet s1 = new Student( );
        • s1.getName( ) (O)
        • s1.getSchoolName( )
        • s1.showInfo( ) -> 자기자신의 오버라이딩 된 메소드
    • 다형성의 일부
      • ex) 주소록을 만들 때, 
        • Student[] s = new Studnet[3];
        • s[0] = new Student( );
        • s[1] = new Student( );
        • s[2] = new Person( ); -> 안 됨
      • ex2 ) 주소록
        • Person p[] = new Person[3];
        • p[0] = new Student( );
        • p[1] = new Student( );
        • p[2] = new Person( ); (O)
    • 부모 타입으로 자식객체를 참고할 수 있다.
    • override해도 부모의 메소드 사라지지 않는다.
    • point.v4패키지
      • Point.java
        package point.v4;
        
        //	v4. 상속
        public class Point {
        	protected int x;
        	protected int y;
        	
        	//	기본 생성자 : 매개 변수가 없는
        //	public Point() {
        //		
        //	}
        //	
        	//	전체 필드 초기화 생성자
        	public Point(int x, int y) {
        		this.x = x;
        		this.y = y;
        	}
        	
        	public int getX() {
        		return x;
        	}
        	public void setX(int x) {
        		this.x = x;
        	}
        	public int getY() {
        		return y;
        	}
        	public void setY(int y) {
        		this.y = y;
        	}
        	public void draw() {
        		System.out.printf("점[x=%d, y=%d]을 그렸습니다.\n",x,y);
        	}
        	
        	//메서드 오버로딩
        	//매개변수 타입, 갯수, 순서가 같은 이름의 메서드 
        	public void draw(boolean bDraw) {
        		String message = String.format("점[x=%d, y=%d]을 ", x, y);
        		if(bDraw) {	//	true라면
        			message += "그렸습니다.";
        		}else {
        			message += "지웠습니다.";
        		}
        		System.out.println(message);
        	}
        }​
      • ColorPoint.java
        package point.v4;
        
        //	상속
        public class ColorPoint extends Point{
        	private String color;
        	
        	//	생성자
        	public ColorPoint(int x, int y, String color) {
        		super(x,y);
        		this.color = color;
        	}
        	
        	@Override	//	컴파일러에게 이 메서드가 오버라이딩한 메서드인지 확인
        	public void draw(boolean bDraw) {
        		//부모로부터 물려 받은 메서드를 덮어 쓰기
        		String message = String.format("색깔점[x = %d, y = %d, color = %s]을 ",
        				x, y, color);
        		message += bDraw ? "그렸습니다.":"지웠습니다";
        		
        		System.out.println(message);
        		
        		//부모의 메서드 호추하려면
        		super.draw(bDraw);
        	}
        }​
      • PointApp.java
        package point.v4;
        
        public class PointApp {
        	public static void main(String[] args) {
        		Point p = new Point(4,4);
        		
        		p.setX(10);
        		p.setY(20);
        		p.draw();
        		p.draw(true);
        		p.draw(false);
        		
        
        		Point p2 = new Point(60,40);
        		p2.draw();
        		p2.draw(true);
        		p2.draw(false);
        		
        		ColorPoint cp1 = new ColorPoint(10,20,"RED");
        		cp1.draw(true);
        
        		//	다형성 : 부모타입으로 자식객체 참조
        		Point cp2 = new ColorPoint(30, 40,"RED");
        		cp1.draw(true);
        	}
        }​
    • 위의 같은 경우에서 point.java의 매개변수 없는 생성자와, ColorPoint의 매개변수 없는 생성자를 만들고 실행시키면, point 생성자 먼저 실행되고, ColorPoint 생성자가 실행된다. 
    • 그렇지만, Point의 생성자를 만들지 않고 ColorPoint의 생성자를 만들면 오류생긴다. 

 

업캐스팅, 다운 캐스팅

특정 객체 다운 캐스팅 할 때, instanceof로 확인해라.

 

casting 패키지

Animal.java

package com.javaes.oop.casting;

public class Animal {
	protected String name;
	
	//	생성자
	public Animal(String name) {
		this.name = name;
	}
	
	public void eat() {
		System.out.println(name + " is eating");
	}
	
	public void walk() {
		System.out.println(name + " is walking");
	}
}

Dog.java

package com.javaes.oop.casting;

public class Dog extends Animal{
	//생성자 Animal 없어서 오류났음 -> 생성자 ㅏ만들어줘야 함
	public Dog(String name) {
		//부모생성자의 일부 호출해줘야한다. 
		super(name);
	}
	
	public void bark() {
		System.out.println(name + ": 멍멍!");
	}
}

Cat.java

package com.javaes.oop.casting;

public class Cat extends Animal{
	public Cat(String name) {
		super(name);
	}
	
	public void meow() {
		System.out.println(name + ": 야옹!");
	}
}

AnimalApp.java

package com.javaes.oop.casting;

public class AnimalApp {
	public static void main(String[] argv) {
		//	업 캐스팅, 다운 캐스팅
		Dog dog1 = new Dog("스누피");
		dog1.eat();
		dog1.walk();
		dog1.bark();
		
		//	업 캐스팅 : 참조 자료형에 있는 설계된 멤버에만 접근 가능
		Animal dog2 = new Dog("아지");
		dog2.eat();
		dog2.walk();
//		dog.bark();	//오류남
		
		//	다운 캐스팅
		//	animal -> dog로
		((Dog)dog2).bark();	//	일시적으로 변환
		
		
		//	업 캐스팅
		Animal cat1 = new Cat("야옹이");
		cat1.eat();
		cat1.walk();
//		((Dog)cat1).bark();//	오류남,,-> cat과 Dog 서로 캐스팅 안 됨
		
		if(cat1 instanceof Dog) {	//cat1이 Dog의 인스턴스인가?
			((Dog)cat1).bark();
		}else if(cat1 instanceof Cat){	// 	cat1이 Cat의 인스턴스?
			((Cat)cat1).meow();
		}
		
//		Dog[] pets = new Dog[3];
		Animal[] pets = new Animal[3];
		pets[0] = dog1;
		pets[1] = (Dog)dog2;
		pets[2] = new Dog("멍멍이");
//		pets[3] = new Cat("아즈라엘");// 오류남
		
		for(Animal pet : pets) {
			pet.eat();
			pet.walk();
			
			if(pet instanceof Dog) {
				((Dog)pet).bark();
			}else if(pet instanceof Cat)
				((Cat)pet).meow();
			
		}
		
	}
}
  • 다운 캐스팅 : 자료형에 있는 설계된 멤버만 접근 가능 
    • Animal dog2 = new Dog()
    • 이면, Dog에만 있는 dark()는 오류가 난다.
  • 같은 부모를 상속하는 자녀 사이에 캐스팅이 안 된다.
    • Cat과 Dog는 서로 캐스팅이 안 됨
  • Dog[] pets = new Dog[3];을 한 뒤,
  • pets[3] = new Cat() -> 오류난다. 
    • Dog객체에 Cat을 넣었기 때문.

 

 

 

'study > JAVA 전문가' 카테고리의 다른 글

인터페이스  (0) 2021.12.07
예외  (0) 2021.12.07
추상 클래스  (0) 2021.12.07
[모의 필기테스트] 오답노트 & 정리  (0) 2021.12.07
[DAY+2]Java Programming  (0) 2021.12.03

어노테이션?

@기호를 사용해서 음 내 생각인데 음 아마,, 어,, 뭔가 유지 관리가 편함

한번에 설정해서 그런지 뭐라지 내 이해로는 표가 있으면 한 행을 다 한번에 설정해서 좋아보임

public static String[] one(){
	return new String[]{"번호", "이름", "가격"};
}
public Object[] getData(){
	return new Object[]{productNo, productName, price};
}

public static int[] getWidth(){
	return new int[]{100, 400, 200};
}

이게 

public class ProductVo{
	@Grid(name = "번호", width = 100, order = 1)
    private String productNo;
    
    @Grid(name = "이름", width = 400, order = 2)
    private String productName;
    
    @Grid(name = "단가", width = 200, order = 3)
    private String price;
}

이렇게 바뀜

 

 

다시 돌아가서, 

(Desc.java)

package object_1;

import java.lang.annotation.*;
/** 
 * toString()을 위한 @Desc어노테이션
 * */

@Retention(RetentionPolicy.RUNTIME)	//	자바 로딩 된 후에도 어노테이션 사용하겠어
@Target(ElementType.FIELD)	//	해당 어노테이션을  전연변수에만 사용하겠다.
public @interface Desc{
	public String name();	// @Desc(name = "속성명")사용 가능하게 타입 정의
}

 

(DefaultVo.java)

package object_1;

import java.lang.reflect.Field;
public class DefaultVo {
	@Override
	public String toString() {
		
		//StringBuffer 클래스 객체 생성 : 문자열 자료 저장하기 위함
		StringBuffer sb = new StringBuffer();
		
		//문자열에 Class 객체생성, 클래스 정보 저장
		Class<? extends DefaultVo> clazz = this.getClass();
		sb.append(clazz.getName() + "정보");
		
		//Field 목록 객체 생성
		Field[] declaredFields = clazz.getDeclaredFields();
		for(Field f : declaredFields) {
			if(f != null) {
				//변수 조회
				String name = f.getName();
				String desc = "";
				
				//@Desc 어노테이션에 명시된 name()값 조회 : 필드 항목명
				Desc anno = f.getDeclaredAnnotation(Desc.class);
				if(anno != null) {desc = anno.name();}
				
				//전역 변수 값 조회
				String value = "";
				try {
					//접근 권한 부여 -> 전역변수 값 조회 -> 접근 권한 복원
					boolean accessible=f.isAccessible();
					f.setAccessible(true);
					Object obj = f.get(this);
					if(obj != null) { value = obj.toString();}
					f.setAccessible(accessible);
				}catch(IllegalArgumentException e) {e.printStackTrace();
				}catch(IllegalAccessException e) {e.printStackTrace();}
				
				
				//앞 문자열에 name, value, desc의 정보를 갖는 문자열 추가
				sb.append("\r\n\t" + name + " = "+ value + " ["+ desc + "]");
				
			}
		}
		return sb.toString();
	}
}
  • @Override : 부모 클래스가 가지고 있는 함수를 재정의 한다. 
    • 재정의 된 로직이 실행됨
  • toString() : Object 클래스가 가지고 있는 함수
    • System.out.println이 실행될 때, 객체 toString()함수를 호출함 -> 객체를 Stirng 타입으로 반환해줌
  • StringBuffer() : 문자열 정보 관리

음 Desc에 저장되어 있는거 String으로 반환하려고 만든 거.

신기한건, <? extends DefaultVo>인데,, 클래스 정보가 저장이 되나봐

<? extend Object> 는 어떤 자료형의 객체도 매개변수로 받겠다는 의미라고 한다.

 

 

(ProductVo.java)

package object_1;

public class ProductVo extends DefaultVo{
	//전역 변수 정의
	@Desc(name = "품목번호")
	private String productNo;
	
	@Desc(name = "품목명")
	private String productName;
	
	@Desc(name = "단가")
	private int price;
	
	//getter setter 함수의 정의
	public String getProductNo() {return productNo;}
	public void setProductNo(String productNo) {
		this.productNo = productNo;
	}
	
	public String getProductName() {return productName;}
	public void setProductname(String productName) {
		this.productName = productName;
	}
	public int getPrice() {return price;}
	public void setPrice(int price) {this.price =price;}	
}

Desc 정보 저장.

 

(MemberVo.java)

package object_1;

public class MemberVo extends DefaultVo{
	
	//전역 변수 정의
	@Desc(name ="회원아이디")
	private String memberld;
	
	@Desc(name = "회원명")
	private String memberName;
	
	
	//getter sater함수 정의
	public String getMemberld() {return memberld;}
	public void setMemberld(String memberld) {this.memberld = memberld;}
	public String getMemberName() {return memberName;}
	public void setMemberName(String memberName) {
		this.memberName = memberName;
	}
}

 

(TestMain.java)

package object_1;

public class TestMain {
	public static void main(String [] args) {
		//prodectVo 객체 생성 -> 속성 설정 -> 객체정보 조회
		ProductVo v1 = new ProductVo();
		v1.setPrice(1000);
		v1.setProductname("아메리카노");
		v1.setProductNo("a001");
		System.out.println(v1);
		
		//MemberVo 객체 생성 -> 속성 설정 -> 객체 정보 조회
		MemberVo v2 = new MemberVo();
		v2.setMemberld("m001");
		v2.setMemberName("홍길동");
		System.out.println(v2);
	}
}

 

결과

 

음 실습 해보니깐 어노테이션 좀 알 것 같기도 하고,,

근데 막상 짜보라고 하면,, 

한번 실습 해보고싶다. 문제 줘서

ㅎㅎㅎ

get, set도 알겠당

 

근데 패키지가 너무 신기하네,, 패키지 안에만 있으면 import안 해도 다 연결이 되나봐,, 

 

 

출처 : 자바 프로그래밍 100% 실전 가이드 세트(애프터스킬 시리즈)(전2권) | 심상원 | 아이콕스 - 교보문고 (kyobobook.co.kr) -> 391~ 397쪽

 

 

'study > java' 카테고리의 다른 글

Error querying database. Cause: java.lang.UnsupportedOperationException  (0) 2022.02.05
[Tomcat] 설치 및 eclipse 설정  (0) 2022.01.01
JAVA 상속  (0) 2021.12.04
[백준] 2750_수 정렬하기 (java)  (0) 2021.11.13
java Ajax 연습하기  (0) 2020.07.25

상속

Object 클래스

package Object;

import java.lang.reflect.*;
import java.util.*;

public class Practice {
	public static void main(String[] args) {
	
		Class clz = Practice.class;
		
		Class superClass = clz.getSuperclass();
		System.out.println("부모 클래스 : "+ superClass);
		
		Field[] fields = superClass.getDeclaredFields();
		for(Field f: fields) {
			System.out.println("전력변수  = "+ f.getName());
		}
		
		Method[] methods = superClass.getDeclaredMethods();
		for (Method m : methods) {
			String name = m.getName();
			String parameterTypes = Arrays.toString(m.getParameterTypes());
			System.out.println("함수 = "+ name+" : "+parameterTypes);
		}
	}
}

결과 : 

부모 클래스 : class java.lang.Object
함수 = finalize : []
함수 = wait : [long]
함수 = wait : [long, int]
함수 = wait : []
함수 = equals : [class java.lang.Object]
함수 = toString : []
함수 = hashCode : []
함수 = getClass : []
함수 = clone : []
함수 = notify : []
함수 = notifyAll : []
함수 = registerNatives : []

 

  • 부모 클래스 : class java.lang.Object
    • 상속이 없으면 Object클래스가 부모 클래스임
    • Object는 클래스들의 기본, 최상위 타입

 

- hashCode() 함수

  • 객체에 해시코드 값을 반환하는 함수
  • 해시코드란 : 객체를 구별하기 위한 값, 메모리 주소를 바탕으로 정수화된 값
    • 객체의 해시코드 값의 중복이 일어날 가능성이 있음 -> 중복이란 말이 똑같은 곳 가리킨다는 것인가??? 근데 주의라고 적혀있으면 뭐지

- toString()함수

  • 해당 객체의 정보를 문자열로 반환하는 함수
  • 객체 정보 : '클래스명@해시코드(16진수로)' -> 대부분 재정의를 하여 사용함
    package Object;
    
    public class PracticeHash_toString {
    	public static void main(String [] args) {
    		PracticeHash_toString a = new PracticeHash_toString();
    		int hashCode = a.hashCode();
    		
    		// int to 16진수 : Integer.toHexString
    		String hexHashCode = Integer.toHexString(hashCode);
    		String toString = a.toString();
    		
    		System.out.println("클래스정보 : " +toString + "\nHeshcode 값 : " + hexHashCode );
    	}
    }​
     
    • 결과
      클래스정보 : Object.PracticeHash_toString@7d6f77cc
      Heshcode 값 : 7d6f77cc

 

super, protected

  • 부모 클래스 : Practice_Parent
package Object;

public class Practice_Parent {
	
	//전역 변수
	protected String name = "parent";
	public int value = 1;
	private Type type = Type.A;
	
	//enum 타입
	public enum Type {A,B,C,D};
}
  • 자식 클래스 : Practice_child
package Object;

public class Practice_child extends Practice_Parent{
	//전역 변수
	private int value = 2;
	{
		//비교1
		System.out.println("name = " + name);	//	부모 필드
		System.out.println("value = " + value);	//	자식 필드
		
		//비교 2
		System.out.println("super.name = " + super.name);
		System.out.println("super.value = "+ super.value);
		
		//비교 2
		System.out.println("this.name = "+ this.name);	//부모 필드
		System.out.println("this.value = " + this.value);	//자식필드
		
		System.out.println("부모 클래스의 enum 접근" + Type.A);
		
	}
	
	public static void main(String[] args) {
		new Practice_child();
	}
}
  • 결과 
name = parent
value = 2
super.name = parent
super.value = 1
this.name = parent
this.value = 2
부모 클래스의 enum 접근A
  • 자식에 없는 변수를 부모꺼 씀
  • 만약 자식에도 변수가 있고, 부모에도 있다면 자식에서 사용시 자식꺼 먼저 사용함
  • 부모꺼 사용하고 싶을 땐, super이용
  • super없으면 부모보단 자식이 우선순위가 높음 (자식에서 사용할 때)

 

 

출처 : 

자바 프로그래밍 100% 실전 가이드 세트(애프터스킬 시리즈)(전2권) | 심상원 | 아이콕스 - 교보문고 (kyobobook.co.kr)

 

자바 프로그래밍 100% 실전 가이드 세트 - 교보문고

기본은 물론 응용까지 새로운 JAVA 필독서 | 단순히 웹 영역을 넘어 일반 응용 프로그래밍 분야에 이르도록 거의 모든 개발자들에게 필수 언어가 되어가고 있는 자바(Java)는 그 유연한 활용도만큼

www.kyobobook.co.kr

 

'study > java' 카테고리의 다른 글

[Tomcat] 설치 및 eclipse 설정  (0) 2022.01.01
JAVA 상속(2)  (0) 2021.12.04
[백준] 2750_수 정렬하기 (java)  (0) 2021.11.13
java Ajax 연습하기  (0) 2020.07.25
jfreechart bar그래프 두 개 그리기  (0) 2020.07.23

+ Recent posts