[day12]
1. 상속과 생성자
1) 서브와 수퍼클래스의 생성자 호출 및 실행
서브클래스가 생성될때, 서브클래의 생성자와 수퍼클래스 생성자 둘다 생성
-> 생성자의 목적은 객체의 초기화, 완성된 객체를 만들기 위해서 둘다 필요.
생성자 실행 순서 : 수퍼 -> 서브
2) 서브클래스에서 수퍼 클래스 생성자 선택
부모 클래스의 생성자가 여러개 있는 경우,
개발자가 부모생성자를 명시적으로 지정하지 않는 경우
컴파일러가 부모의 기본 생성자를 호출하도록 실행시킴.
#1. 부모클래스의 기본생성자가 자동으로 선택되는 경우
자식 클래스에서 부모 생성자를 명시적으로 부르지 않은 경우
이때, 부모에 기본 생성자가 없고, 매개변수있는 생성자만 명시되어있는 경우
에러발생
#2. 부모 생성자를 명시적으로 부르는 방법
super()를 이용하여 부모의 생성자를 명시적으로 선택해야함.
자식 생성자 안에서 super() 명령이 첫번째 명령이 되어야함
소괄호 안에 매게변수 넣어서 부모 생성자 선택가능
2. **오버라이드** override (**중요함 **)
1) 상속관계에서 성립
2) 재작성, 덮어씌우기, 재정의 한다~~
: 부모로부터 물려받은 메서드의 기능이 마음에 안들어
내용물만 변경해서 사용하는 것.
3) 메서드 선언부는 똑같이, 중괄호 영역 안의 내용물만 바꾸는 것.
void int ~~~~(){
4) 오버로딩과는 완전히 다름
오버로딩 : 같은 이름의 여러개의 메서드를 만드는 것.
오버라이딩: 안에 내용물만 수정 (재정의)
(Object 클래스로부터 물려받은 equals(), toString() 같은 메서드는 실제로
오버라이딩해서 주로 사용함)
5) 동적바인딩 : 자식 클래스에 오버라딩된 메서드가 있으면,
부모가 만든 형태는 무시하고, 자식이 오버라이딩한 메서드가 무조건 실행된다.
6) @Override : 어노테이션(annotation)이라 부르며,
메서드 바로 위에 붙혀서 컴파일러에게
오버라이딩이 정확한지 확인하도록 지시하는 것.
가독성 Up/ 개발자가 실수로 잘못작성하거나 오타를 방지할 수 있다.
7) 부모메서드의 접근 지정자보다 접근의 범위를 좁혀서 오버라이딩 불가
public > protected > default > private
부모 protected -> 자식 오버라이딩 protected / public
부모 public -> 자식 오버라이딩 public
8) super : = 부모클래스. 부모 클래스의 레퍼런스를 가르킴.
자식클래스에서 메서드 오버라이딩시,
동적바인딩으로 오버라이딩된 메서드가 무조건 실행되는데,
부모의 맴버를 호출하고자 할때 사용하는 키워드
#this. super. this(). super()
this : 현재 객체 (내가 가진~)
super : 부모 객체
this() : 보무 생성자에서 내 클래스의 다른 생성자 호출
super() : 자식 생성자에서 부모 생성자 호출
3. **** 다형성 **** polymorphism [****자바의 화룡점정****]
여러가지 형태를 가질 수 있는 능력
상속관계에서 성립가능.
참조형의 형변환
4. instanceof 연산자
참조하는 변수가 다르키는 실제 객체의 타입을 체크하는데 사용
참조변수 instanceof 클래스명 ---> true/ false 로 결과 돌려줌
5. 추상클래스
1) 설계와 구현을 분리한다면, 설계부분에 해당
2) 키워드 : abstract
3) 추상메서드 : abstract 키워드를 붙혀 메서드의 선언분(원형)만 있고
구현은 되어있지 않은 형태 (중괄호 부분 없음)
public String getNAme(){} 이지만
->로 표현 public abstract String getName();
4) 추상클래스 : 일반 맴버 (변수, 메서드)들과 함께 추상 메서드를 포함하는 클래스
추상 메서드가 하나라도 있으면 무조건 추상 클래스
추상 클래스가에는 abstract 키워드를 붙혀야 한다.
abstract class Sharpe{ // 추상클래스
int a ;
abstract void draw(); //추상 메서드
}
5) 추상 클래스로는 객체 생성 불가!! 불완전한 / 미완성인 클래스이므로 메모리에 올릴 수 없다
Shape s = new Shape (); -----> (X)
Shape s; ----> (O) 변수 선언만은 괜찮다.
6) 상속에서 수퍼클래스로 사용된다. 부모 클래스 될 수 있음. extends 키워드로 상속시킬수 있다.
7) 추상클래스를 물려받은 자식클래스를 완성시키려면 추상메서드를 오버라이딩(내용물 구현)해야한다.
추상클래스를 단순히 상속만 받은 자식클래스는 그 또한 추상클래스가 된다.
# 추상 클래스 단순 상속 : 상속받은 추상 메서드 구현 안하면,
abstract class Rect extends Shape {
int width
}
# 추상 클래스를 상속 + 구현
class Rect extends Shape {
int width;
@override
void draw(){....
}
}
8) 추상클래스를 상속받은 자식클래스는 개발자들이 추상메서드를 모두 구현해야함.
-> 추상 클래스를 가이드라인,
자식 클래스는 가이드를 따른 구현된 사용가능한 실제 클래스
6. 인터페이스 interface : 규격 / 골격제작
1) 키워드 : interface //클래스 대신 사용
키워드 사용해서 클래스를 선언하듯이 인터페이스를 선언
2) 인터페이스 멤버는 추상메서드와 상수만으로 구성된다.
interface Phone {
public static final 타입 변수명; //상수
public abstract 리턴타입 메서드명(); //추상 메서드
}
interface Phone {
public static final int BUTTONS = 20; int BUTTONS = 20;
public abstract void sendCall(); void senCall();
public abstrcat void receiveCall(); receiveCall();
}
* 인터페이스 멤버는 어디서라도 접근 가능하게 모두 public으로 만듬
3) 모든 메서드는 public abstract 이며 생략 가능하다.
4) 상수는 public static final 타입이며 생략 가능하다.
5) 인터페이스는 객체 생성 불가!
메서드는 모두 구현안된 추상메서드이므로 미완성/불완전해 객체 생성 불가능
Phone p = new Phone(); ----> X
6) 인터페이스 타입의 변수 선안만은 가능
Phone p; ---> O
7) 인터페이스 상속
인터페이스는 다른 인터페이스를 상속 받을 수 있다.
인터페이스는 규격과 같은 것으로, 상속을 통해
기존 인터페이스에 새로운 규격을 추가한 새로운 인터페이스를 만들 수 있다.
extends 키워드 사용
interface Mobile extends Phone {
void sendSMS(); // 상수, 추상메서드
void receiveSMS(); 규격추가
}
### 인터페이스는 다중 상속 허용 ### (구현이 안되니 충돌날일이 없으니깐)
interface DualcameraPhone extends Mobile, Camera {
void makeVideo();
}
8) 인터페이스 구현
인터페이스의 추상 메서드를 모두 구현한 클래스를 작성하는 것
키워드 : implements
class Iphone Implementes Mobile{
// 추상메서드 모두 구현
public void senCall(){.....}
public void receiveCall(){.....}
public void sendSMS(){...}
public voiud receiveSMS(){...}
//추가적으로 일반 메서드 , 변수선언
public int doubleFingerTouch(){...}
}
* 추상메서드중 하나라도 구현안하면 에러!!
키워드 implements는 객체생성가능
Mobile m = new Iphone();
9) 인터페이스의 목적
10) 인터페이스의 다중 구현
클래스는 하나 이상의 인터페이스 구현 가능.,
class Iphone Implementes Mobile, Camera,
package day12;
class Car{
public void drive() {
}
}
class Supercar extends Car{
public void burst() {
System.out.println("뿌아앙");
}
}
public class Class2222222 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Supercar s = new Supercar();
s.burst();
}
}package day12;
class A{
A(){
System.out.println("생성자 A");
}
}
class B extends A{
B(){
System.out.println("생성자 B");
}
}
class C extends B {
C(){
System.out.println("생성자 C");
}
}
public class ClassEx04 {
public static void main(String[] args) {
// TODO Auto-generated method stub
C c = new C();
}
}package day12;
class Person{
private int weight;
public void setWeight(int weight) {this.weight=weight;}
public int getWeight() {return weight;}
int age;
protected int height;
public String name;
}
class Student extends Person{
void set() {
age = 30;
name= "홍길동";
height = 170;
//weight = 50; // private 부모 클래스안에서만 사용가능
setWeight(100); // 물려받았기 때문에 바로 사용가능
System.out.println(getWeight());
}
}
public class ClassEx05 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Student s = new Student();
s.set();
}
}
package day12;
class A1{
A1(){
System.out.println("생성자 A");}
A1(int x){
System.out.println("생성자 A-param :" + x);
}
}
class B1 extends A1{
B1(){
super(100);
System.out.println("생성자 B");
}
B1(int x){
super(x); // 첫번째 자리에있어야함
// 부모의 매개변수있는 생성자 호출
System.out.println("생성자 B-param :"+ x);
}
}
public class ClassEx06 {
public static void main(String[] args) {
// TODO Auto-generated method stub
B1 b = new B1();
}
}
package day12;
class Super {
void add() {
System.out.println("Super");
}
}
class Sub extends Super{ //add()
// 오버라이딩!!
@Override
void add() {
System.out.println("Sub");
System.out.println("Sub");
System.out.println("Sub");
super.add(); // 부모가 가진 add 기능을 호출해서 사용가능
add(); // 내가 오버라이딩한거
}
}
public class ClassEx07 {
public static void main(String[] args) {
// TODO Auto-generated method stub
//부모객체
Super sup = new Super();
sup.add();
//자식객체
Sub s = new Sub();
s.add();
}
}package day12;
class AClass{
int x;
}
class BClass extends AClass{ //x, y
int y;
}
public class ClassEx08 {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 기존 객체 생성하던 방식
// AClass a = new AClass();
// BClass b = new BClass();
// 다형성 : 조상의 참조변수로 자식의 실 객체를 담아주는것.
AClass a = new BClass();
//부모 변수 자식 객체
//BClass b = new AClass //(X) 부모객체가 자식변수에 들어갈 수는 없다.
System.out.println(a.x);
// System.out.println(a.y)
BClass bbbb= (BClass)a;
System.out.println(bbbb.x);
System.out.println(bbbb.y);
/*
int a = 10; //정수 10
double d = 3.14;// 정수 10 + 실수부 0.14
a = (int)d
*/
}
}package day12;
class AClass2{
int x;
void add() {
System.out.println("AAA");
}
}
class BClass2 extends AClass2{ // x, @add() , y , func()
int y;
void add() { //override
System.out.println("BBB");
}
void func() {
System.out.println("subsub");
}
}
public class ClassEx09 {
public static void main(String[] args) {
// TODO Auto-generated method stub
// AClass2 a = new AClass2(); //기본적으로 만들던 객체생성
// AClass2 a2 = new BClass2(); //다형성으로 객체생성
/*
a.add();
System.out.println("ㅡㅡㅡㅡㅡ");
a2.add();
//a [x, add("AAA")
//a2 [x,y,@add("BBB"), func()]
// A B A@B B
*/
AClass2 a = null;
BClass2 b = new BClass2();
a = (AClass2)b; // AClass2 a = new BClass2();
a.add();
//a.func(); b에 있는 기능이라 a에서는 사용 불가
/*
AClass2 a = new AClass2();
BClass2 b = null
b = (BClass2)a ; // 컴파일은 되지만 실행할때 런타임 에러
BClass2 b = new AClass2(); // 부모객체는 자식변수가 담을 수 없다.
*/
AClass2 x = null;
BClass2 y = new BClass2();
BClass2 y2 = null;
x= (AClass2)y; // 다향성 upcasting : 형변환 생략가능
y2= (BClass2)x; //다향성 downcasting : 형변환 필수
if(x instanceof BClass2) {
System.out.println("형변환");
y2=(BClass2)x;
}
}
}package day12;
class Product{
int price; // 제품가격
int bonusPoint; // 제품 구매시 제공하는 보너스 포인트
Product(int price){
this.price = price;
bonusPoint = (int)(price / 10.0);
}
}
class Tv extends Product{
Tv(){
super(100);// 생성자로 들어감
}
@Override
public String toString() {
return "Tv";
}
}
class Computer extends Product{
Computer(){
super(200);
}
@Override
public String toString() {
return "Computer";
}
}
class Buyer { // 고객님
int money = 1000;//지갑
int bonusPoint = 0; //고객 소유의 보너스 포인트
void buy(Product p) {// 제품 산다. 매개변수의 다형성
money -= p.price;
bonusPoint += p.bonusPoint;
System.out.println(p + "를 구매하셨습니다.");
}
}
public class ClassEx11 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Buyer b = new Buyer();
Tv tv = new Tv();
Computer com = new Computer();
// System.out.println(tv);
// 참조변수 출력하면 참조변수의 toString() 메서드가 호출되어
// 메서드가 돌려주는 값을 출력하게 된다.
// 출력하는 형태가 마음에 안들면 Object로 부터 물려받은
// toString()메서드를 오버라이딩해서 원하는 문자열을 리던하주게 변경하면 된다
// 나 또는 부모가 오버라이딩을 안했으면 Object 클래스가 만들어 놓은 형태로 사용
// Object가 만들어 놓은 형태는 "패키지명.클래스명@레퍼런스16진수"이와 같다
// System.out.println(tv.toString());
b.buy(tv);
System.out.println(" 현재 남은돈은 " + b.money+ "만원입니다");
System.out.println(" 현재 포인트는 " + b.bonusPoint+ "점입니다");
b.buy(com);
System.out.println(" 현재 남은돈은 " + b.money+ "만원입니다");
System.out.println(" 현재 포인트는 " + b.bonusPoint+ "점입니다");
}
}package day12;
class Shape{
void draw() {
System.out.println("Shape");
}
}
class Line extends Shape{
@Override
void draw() {
System.out.println("Line");
}
}
class Rect extends Shape{
@Override
void draw() {
System.out.println("Rect");
}
}
class Circle extends Shape{
@Override
void draw() {
System.out.println("Circle");
}
}
public class ClassEx12 {
static void paint(Shape s) { // 매개변수의 다형성
s.draw(); //오버라이딩 다형성
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Line line = new Line();
paint(line);
paint(new Shape());
paint(new Line());
paint(new Rect());
paint(new Circle());
}
}
package day12;
class ShapeClass{
void draw() {
System.out.println("Shape");
}
}
class LineClass extends ShapeClass{
@Override
void draw() {
System.out.println("Line");
}
}
class Rect extends Shape{
@Override
void draw() {
System.out.println("Rect");
}
}
class Circle extends Shape{
@Override
void draw() {
System.out.println("Circle");
}
}
public class ClassEx122 {
static void paint(Shape s) { // 매개변수의 다형성
s.draw(); //오버라이딩 다형성
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Line line = new Line();
paint(line);
paint(new Shape());
paint(new Line());
paint(new Rect());
paint(new Circle());
}
}
package day12;
// 추상 클래스
abstract class SuperClass{
// 추상 메서드 : 구현부가 없는 메서드를 말함
abstract void add(); // 선언부, 헤드
// void add() {
// 구현부, 바디
// }
// 일반 멤버들도 같이 포함 가능
int a = 10;
void aaa() {
// ......
}
}
class SubClass extends SuperClass{
@Override
void add() {
}
}
public class ClassEx14 {
public static void main(String[] args) {
// SuperClass s = new SuperClass(); // 추상클래스는 객체생성 불가능
// SuperClass s; // 추상클래스는 선언은 가능
SubClass sub = new SubClass();
}
}
package day12;
// 아래 추상클래스 Calculator를 상속받아 MyCalc클래스를 구현하세요.
abstract class Calculator{
public abstract int add(int a, int b); // 두정수의 합을 리턴
public abstract int substract(int a, int b); // 두 정수의 차를 리턴
public abstract double average(int[] a); // 배열에 저장된 정수의 평균값
}
class MyCalc extends Calculator{
@Override
public int add(int a, int b) {
return a+b;
}
@Override
public int substract(int a, int b) {
return a-b;
}
@Override
public double average(int[] a) {
int sum = 0;
for(int i=0; i<a.length;i++) {
sum += a[i] ;
}
return sum/(a.length);
}
}
public class ClassEx15 {
public static void main(String[] args) {
// TODO Auto-generated method stub
MyCalc my = new MyCalc();
System.out.println(my.add(10,20));
System.out.println(my.substract(10,20));
System.out.println(my.average(new int[] {1,2,3,4,5}));
}
}package day12;
// 인터페이스!!!!
interface Test{
public static final int NUM = 1; // 상수
public abstract void add(); // 추상메서드
int x = 100; //interface에서는 상수가 됨 (public static final) 생략
//void sub(); // 추상메서드(public abstract) 생략가능
}
interface Test2{
void func();
}
class Hello{
int xxx=10;
}
// 인터페이스를 구현한 클 ! 래 ! 스
class Inter extends Hello implements Test, Test2{
@Override
public void add() {
// TODO Auto-generated method stub
}
@Override
public void func() {
// TODO Auto-generated method stub
}
}
public class ClassEx16 {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 구현한 클래스로 객체 생성
Inter i = new Inter();
i.add();
i.func();
// 다형성 : 인터페이스가 부모 격
Test t = new Inter();
t.add();
Test2 tt = new Inter();
tt.func();
Hello h = new Inter();
h.xxx= 200;
}
}'P-Language > [Java]' 카테고리의 다른 글
| [Java] 14 - 싱글턴 (0) | 2022.06.03 |
|---|---|
| [Java] 13 - 12의 문제풀이 (0) | 2022.06.03 |
| [Java] 11 - 상속과 접근자, final (0) | 2022.06.03 |
| [Java] 10 - this와 객체배열, 캡슐화(getter setter) (0) | 2022.06.03 |
| [Java] 9 - 오버로딩, 생성자와 기본 생성자 (0) | 2022.06.03 |