기본
- 다른 package 에 있어도 가져와서 사용 가능하다.
- 기존 제시된 class 의 변수들을 가져와 내가 원하는 몇가지를 추가하여 사용 가능하다.
- super 에서 변수가 3개 였다면 sub 에서 3개를 그대로 받아 내가 2개 추가하면 총 5개가 된다.
- 즉 super 보다 sub 가 더 큰 개념이 된다.
1. super(부모 class)
package Day06291;
/*
부모 클래스가 다른 패키지에 있을 경우 protected,public 변수는 접근이 가능하다.
같은 패키지인 경우에는 private만 빼고 모두 접근이 가능하다.
*/
public class SuperObj {
protected String name;
protected int age;
public SuperObj(String name,int age, String name2) {
this.name=name;
this.age=age;
this.name2=name2;
}
}2. super(자식 class)
package Day0629.Day0629;
import Day06291.SuperObj;
// extends : 상속받겠다 라는 코드
// extends 뒤에는 하나밖에 못받는다.
// extends 뒤에 상속받을 super의 class명을 기입한다.
public class SubObj_03 extends SuperObj {
String addr;
public SubObj_03(String name, int age, String name2, String addr) {
super(name, age, name2); // 상속받은게 우선이 되어야 하기에 무조건 super는 첫줄에 와야한다.(반드시 첫줄, 부모생성자 호출)
this.addr=addr;
}
public void write() {
System.out.println("이름: "+this.name);
System.out.println("나이: "+this.age);
System.out.println("주소: "+this.addr);
}
}3. super(main class)
package Day0629.Day0629;
public class TestObj_03 {
public static void main(String[] args) {
// write 메서드 호출
// 생성
SubObj_03 sub=new SubObj_03("임형준",24,"서울시");
// 호출
sub.write();
}
}결과
이름: 임형준
나이: 24
주소: 서울시override
- 오버라이딩은 super(부모)의 메서드를 가져와 항목을 추가하여 메서드를 재정립 한다.
- 오버라이딩을 통해 msg를 추가하여 결과창에 메세지: 가 나온다.
- 명시적생성자와 디폴트 생성자 구분해놓았으니 주의해가며 확인하자.
- override시에 해당 이름 write를 치면 자동완성이 소환되니 이를 이용하자.
package Day0629.Day0629;
class Point{
int x;
int y;
// 명시적 생성자
public Point(int x,int y) {
System.out.println("super_인자있는 생성자(명시적 생성자)");
this.x=x;
this.y=y;
}
// 디폴트 생성자
public Point() {
System.out.println("super_디폴트 생성자");
}
// 메서드
public void write(){
System.out.println("x좌표= "+x+", y좌표= "+y);
}
}
////////////////////////////////////////////////////////////
class SubPoint extends Point {
String msg;
// 명시적 생성자
public SubPoint(int x, int y, String msg) {
super(x, y);
this.msg=msg;
System.out.println("sub_명시적 생성자");
}
// 디폴트 생성자
public SubPoint(){
// super(); // 생략되어 있음
System.out.println("sub_디폴트 생성자");
}
// 오버라이딩... 부모의 메서드 재구현할 목적(미완의 메서드를 완성할 목적)
// 하위클래스에서 부모클래스의 메서드를 수정해서 사용하는 것: 오버라이딩
// 1. 상속이 전제, 2. 메서드 이름은 부모나 나나 동일하다. 3. 리턴타입도 동일하다. 4.
// override 상속받았을때 부모의 미완의 메서드를 받아서 추가해주는 것.
@Override
public void write() {
super.write();
System.out.println("메세지: "+msg);
}
}
////////////////////////////////////////////////////////////
public class ExObTest_05 {
public static void main(String[] args) {
SubPoint sp=new SubPoint(); // 디폴트 생성자용
sp.write(); // set메서드 안하고 값도 지정 안해서 0과 null로 나온다.
// print 해보면 super 먼저 나오고, sub 나오고, 나머지 나온다.
System.out.println("--------------------------------");
SubPoint sp1=new SubPoint(2,3,"가즈아!!"); // 명시적 생성자용
sp1.write(); // 명시적으로 값 입력해줘서 모두 출력됨.
}
}결과
super_디폴트 생성자
sub_디폴트 생성자
x좌표= 0, y좌표= 0
메세지: null
—-—-—-—-—-—-—-—-—-—-—-—-—-—-—-—-—-—-
super_인자있는 생성자(명시적 생성자)
sub_명시적 생성자
x좌표= 2, y좌표= 3
메세지: 가즈아!!package Day0629.Day0629;
class Person{
String name;
String buseo;
public void getPerson(){ // 디폴트 생성자
System.out.println("** 부모변수출력 **");
System.out.println("이름: "+this.name); // 자식이 부모꺼를 받으면 this. 사용 가능
System.out.println("부서: "+this.buseo);
}
}
//////////////////////////////////////////////////
class My extends Person {
int age;
public My(String name, String buseo, int age){
this.name=name;
this.buseo=buseo;
this.age=age;
}
public void write(){
System.out.println("**내가 만든 것**");
System.out.println("사원명: "+this.name);
System.out.println("부서: "+this.buseo);
System.out.println("나이: "+this.age);
}
// 오버라이드 메서드
@Override
public void getPerson() {
super.getPerson();
System.out.println("나이 :"+this.age);
}
}
//////////////////////////////////////////////////
public class Inheri_07 {
public static void main(String[] args) {
My my1=new My("임형준","승인도",29);
my1.write();
System.out.println("**오버라이드 통한 메서드 출력**");
my1.getPerson();
}
}결과
내가 만든 것
사원명: 임형준
부서: 승인도
나이: 29
오버라이드 통한 메서드 출력
** 부모변수출력 **
이름: 임형준
부서: 승인도
나이 :29일반적 생성 출력 & 다형성 생성 출력 with 추상메서드
- 다형성 출력은 변수를 하나만 사용할 수 있다는 장점이 있다.
- 실무에서 종종 사용할 때가 있다고 하니 익혀놓자.
package Day0629.Day0629;
// 추상클래스는 new로 생성을 못한다.
/*
추상클래스는 new로 생성을 못한다.
추상메서드가 하나라도 존재하는 클래스를 추상클래스 라고 한다.
추상클래스: 일반메서드, 추상메서드 둘다 존재 가능하다.
변수는 못쓴다. 상수정도는 가능하다.
*/
abstract class Fruit{ // 상수는 들어갈 수 있다.
//class Fruit{ // 추상메서드가 1개라도 있으면 추상 클래스로 앞에 abstract 가 들어가야 한다.
static final String MESSAGE="오늘은 비가 많이오네요.";
// 일반메서드
public void getTitle(){
System.out.println("우리는 추상클래스 공부중!!!");
}
// 추상메서드(미완의 메서드.. 선언문만 있고 구현부인 몸통이 없다.)
// public void showMessage();
abstract public void showMessage(); // 추상메서드 : 오버라이딩을 하기 위한 목적!! 앞에 abstract를 기입해줘야 한다
// 추상메서드: 블락괄호가 없다==구현할것이 없다.
// 인터페이스 : 추상의 메서드만 모아놓은 곳.
}
//////////////////////////////////////////////////
class Apple extends Fruit{ // 위에가 추상이긴 하나 어쨌든 클래스이다.
@Override
public void showMessage() {
System.out.println("Apple_Message");
System.out.println(Fruit.MESSAGE);
}
}
//////////////////////////////////////////////////
class Banana extends Fruit{
@Override
public void showMessage() {
System.out.println("Banana_Message");
}
}
//////////////////////////////////////////////////
class Orange extends Fruit{
@Override
public void showMessage() {
System.out.println("Orange_Message");
}
}
//////////////////////////////////////////////////
public class ExAbstract_08 {
public static void main(String[] args) {
// 일반적인 생성 (변수 3개... 변수 여러개)
Apple apple=new Apple();
Banana banana=new Banana();
Orange orange=new Orange();
apple.showMessage();
banana.showMessage();
orange.showMessage();
// 다형성 (변수 1개)
// 다형성은 하나의 변수로 여러가지 일을 처리할때 이용한다.
// 다형성은 하위클래스로 생성한다.
// 부모클래스명 변수명=new 자식클래스명();
System.out.println("----------------------------");
Fruit fruit;
fruit=new Apple();
fruit.showMessage();
fruit=new Banana();
fruit.showMessage();
fruit=new Orange();
fruit.showMessage();
fruit.getTitle();
}
}결과
Apple_Message
오늘은 비가 많이오네요.
Banana_Message
Orange_Message
----------------------------
Apple_Message
오늘은 비가 많이오네요.
Banana_Message
Orange_Message
우리는 추상클래스 공부중!!!interface, 추상메서드
- 다형성 : 부모클래스명 변수명=new 자식클래스명(); 으로 진행한다. 여기서 부모클래스명은 처음 추상메서드를 작성한 인터페이스클래스이다. 그래서 ‘다형성 : 인터페이스클래스명 변수명=new 자식클래스명’ 으로 진행한다.
1. interface
package Day0629.Day0629;
public interface FoodShop_10 {
// java class가 아닌 interface로 생성한다.
// 인터페이스는 상수와 추상메서드만 선언이 가능합니다.
// abstract 생략 가능.
String SHOPNAME="보슬보슬"; // 상수
// 인터페이스에서 담는 상수는 앞에 final이 생략되어있다고 생각하면 편하다... final 생략
public void order();
public void delivery();
// 인터페이스에서는 추상메서드가 전제라서 abstract 생략 가능.
}2. sub class
package Day0629.Day0629;
// class가 class를 받을 때 : extends
// clase가 interface를 받을 때 : implements
// interface가 interface를 받을 때 : extends
// implements는 다중구현 가능하다.
public class Food_10 implements FoodShop_10{
@Override
public void order() {
System.out.println(SHOPNAME);
// SHOPNAME="돈까스집"; // Interface에서 상수는 final 개념이기에 수정이 불가능하다.
System.out.println("음식을 주문합니다.");
}
@Override
public void delivery() {
System.out.println(SHOPNAME);
System.out.println("음식을 배달합니다.");
}
}3. main class
package Day0629.Day0629;
public class FoodDeliveryMain_10 {
public static void main(String[] args) {
// 일반적인 생성
Food_10 fds=new Food_10();
fds.order();
fds.delivery();
System.out.println("--------------");
// 다형성
FoodShop_10 fds1=new Food_10();
fds1.order();
fds1.delivery();
// 부모클래스명 변수명=new 자식클래스명();
// 추상클래스명 변수명=new 자식클래스명();
}
} 결과
보슬보슬
음식을 주문합니다.
보슬보슬
음식을 배달합니다.
--------------
보슬보슬
음식을 주문합니다.
보슬보슬
음식을 배달합니다.배열활용 (Array)
배열의 경우 배열 수식을 위해 출력 시 다형성으로 출력해야한다.
package Day0630;
/*
성현이가 게임을 합니다.
순영이가 게임을 합니다.
선범이가 게임을 합니다.
-----------------
선범이가 게임을 종료 합니다.
순영이가 게임을 종료 합니다.
성현이가 게임을 종료 합니다.
*/
abstract class Game{
abstract void play();
abstract void stop();
}
////////////////////////////////////////////////////////////////////////
class SungHyeon extends Game{
@Override
void play() {
System.out.println("성현이가 게임을 합니다");
}
@Override
void stop() {
System.out.println("성현이가 게임을 종료합니다");
}
}
////////////////////////////////////////////////////////////////////////
class SoonYeong extends Game{
@Override
void play() {
System.out.println("순영이가 게임을 합니다");
}
@Override
void stop() {
System.out.println("순영이가 게임을 종료합니다");
}
}
////////////////////////////////////////////////////////////////////////
class Sunbum extends Game{
@Override
void play() {
System.out.println("선범이가 게임을 합니다");
}
@Override
void stop() {
System.out.println("선범이가 게임을 종료합니다");
}
}
////////////////////////////////////////////////////////////////////////
public class ArrConst_04 {
public static void main(String[] args) {
// 배열선언
Game[] game=new Game[3];
// 각각의 sub로 생성
game[0]=new SungHyeon();
game[1]=new SoonYeong();
game[2]=new Sunbum();
//for(증가)
for (int i=0;i< game.length;i++) {
game[i].play();
}
System.out.println("==================");
//for(감소)
for (int i=game.length-1;i>=0;i--) {
game[i].stop();
}
}
}결과
성현이가 게임을 합니다
순영이가 게임을 합니다
선범이가 게임을 합니다
—————————————————————
선범이가 게임을 종료합니다
순영이가 게임을 종료합니다
성현이가 게임을 종료합니다CRUD
- switch를 이용하여 진행한다.
- 종료는 loop를 이용하는 방법과, System.exit(입력값); 을 이용해야 한다. 단순 break;를 쓰면 switch문만 빠져나오고 while문을 빠져 나오진 못한다.
package Day0630;
import java.util.Scanner;
interface Board{
public void process();
}
/////////////////////////////////////////////////////////////
class Insert implements Board{
@Override
public void process() {
System.out.println("게시판에 게시물을 추가합니다.");
}
}
/////////////////////////////////////////////////////////////
class Select implements Board{
@Override
public void process() {
System.out.println("게시판에 게시물을 조회합니다.");
}
}
/////////////////////////////////////////////////////////////
class Update implements Board{
@Override
public void process() {
System.out.println("게시판에 게시물을 수정합니다.");
}
}
/////////////////////////////////////////////////////////////
class Delete implements Board{
@Override
public void process() {
System.out.println("게시판에 게시물을 삭제합니다.");
}
}
/////////////////////////////////////////////////////////////
public class BordCRUD_05 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
Board board=null;
int n; // 입력할 숫자
exit:while(true){
// while(true){
System.out.println("1.추가 2.조회 3.수정 4.삭제 0.종료");
System.out.println("================================");
n=sc.nextInt();
switch(n) {
case 1:
board=new Insert();
break;
case 2:
board=new Select();
break;
case 3:
board=new Update();
break;
case 4:
board=new Delete();
break;
case 0:
System.out.println("종료합니다.");
break exit;
// case 0:
// System.out.println("종료합니다.");
// System.exit(0);
default:
System.out.println("**잘못입력했어요**");
break;
}
if(n<=4)
board.process();
}
}
}결과
1.추가 2.조회 3.수정 4.삭제 0.종료
============================
1 // 입력값
게시판에 게시물을 추가합니다.
1.추가 2.조회 3.수정 4.삭제 0.종료
============================
2 // 입력값
게시판에 게시물을 조회합니다. 1
.추가 2.조회 3.수정 4.삭제 0.종료
============================
3 // 입력값
게시판에 게시물을 수정합니다.
1.추가 2.조회 3.수정 4.삭제 0.종료
============================
4 // 입력값
게시판에 게시물을 삭제합니다.
1.추가 2.조회 3.수정 4.삭제 0.종료
============================
5 // 입력값
잘못입력했어요
1.추가 2.조회 3.수정 4.삭제 0.종료
============================
0 // 입력값
종료합니다.
java를 잡아...... 하... 이게 맞나...