코마리와 함께하는 개발여행

추상 클래스는 동일한 메서드로 접근 가능한 서브 클래스들을 설계하도록 하기 위해서이다.

추상 클래스는 객체를 생성할 수 없다.
정의
abstract class 클래스명 {
  abstract void 메서드명();
}
추상 메서드를 하나라도 가지면 추상 클래스로 설계해야 한다.
추상 메서드는 추상 클래스의 상속을 받는 서브 클래스에서 어떻게 동작할지 반드시 구현 되어야 한다.
===================================================================================
package training;
// 추상클래스 : 한개 이상의 추상메소드를 갖는 객체 생성을 못함
abstract class AbstractClass {
// 몸체가 없는 메소드 : 추상 메소드
 abstract void Method01();
}
// 서브클래스 : 슈퍼클래스로 추상클래스가 사용됨
// 추상 클래스를 슈퍼클래스로 갖는 서브클래스에서는
// 추상메소드를 오버라이딩 해야 한다는 강제성을 부여 받게 된다.
class SubClass extends AbstractClass{
 void Method01(){
  System.out.println("Method01");
 }
}
public class Ex01 {
 public static void main(String[] args) {
  AbstractClass ac=null; // 레퍼런스 변수 선언은 가능
  // ac=new AbstractClass(); // 객체 생성을 못함
  ac=new SubClass(); // 업캐스팅
  ac.Method01(); // 업캐스팅 후에는 서브클래스에서 오버라이딩된 메소드가 호출 됨
 }
}
===================================================================================
// 추상 클래스를 이용한 다형성 : 구체적인 동작은 다르더라도 접근방식은 동일하게
package training;
abstract class Shape{
 public abstract void draw(); // 동일해야하는 접근 방식을 추상메소드로
}
class Circ extends Shape{
 public void draw(){
  System.out.println("원을 그리다");
 }
}
class Rect extends Shape{
 public void draw(){
  System.out.println("사각형을 그리다");
 }
}
class Tri extends Shape{
 public void draw(){
  System.out.println("삼각형을 그리다");
 }
}
public class Ex02 {
 public static void poly(Shape s){
  s.draw();
  // 3 객체 모두에 적용될 공통적인 로직을 기술한다. (길면 길수록 유용)
 }
 public static void main(String[] args) {
  poly(new Circ());
  poly(new Rect());
  poly(new Tri());
  /*Shape s=null; // 객체는 생성하지 못하더라도 레퍼런스 변수 선언은 가능하다.
  s=new Circ();
  s.draw();
  s=new Rect();
  s.draw();
  s=new Tri()
  s.draw();*/
 }
}
===================================================================================
final
사용 범위 : 변수, 메서드, 클래스
final 변수 : 변수를 상수화 시켜서 저장된 값이 변하지 않는다.
final 메서드 : 서브클래스에서 오버라이딩을 허용하지 않는다.
final 클래스 : 상속이 허용되지 않는다.

===================================================================================
package training;
class FinalTest{
 final int A=10; // 이름이 있는 상수
 // int a=10; // a는 변수
 final public int getA(){
  return A;
 }
}
final class SubTest extends FinalTest{
 // FinalTest 클래스의 final getA() 메소드는 오버라이딩이 불가능
 /*public int getA(){
  return A;
 }*/
}
/*class SubEx extends Subtest{ // final SubTest는 서브클래스를 만들 수 없다.
 
}*/
public class Ex04 {
 
 public static void main(String[] args) {
  FinalTest ft=new FinalTest();
  // ft.a=20; // final로 선언된 변수는 상수화되어 값을 변경할 수 없기에 대입연산자 왼쪽에 못옴
  // 10=20; // 상수는 값이 변할수 없기에 대입연산자 왼쪽에 못옴
  System.out.println(ft.A);
 }
}
===================================================================================

상속은 코드의 재활용에 유용하며, 자식 클래스(서브클래스)는 부모 클래스(슈퍼클래스)로부터 파생된 객체로서 부모 클래스가 가지고 있는 모든 속성들을 상속받아 사용할 수 있다.

정의 형식
class Animal {   // 부모 클래스
}
class Cat extends Animals {
}

접근지정자의 종류와 성격

메서드 오버라이딩이란
서브클래스에서 슈퍼클래스와 동일한 이름의 메서드를 새롭게 정의해서 슈퍼클래스의 메서드를 더 이상 사용하지 않고(은닉하고) 서브클래스에서 새롭게 정의한 메서드를 사용하는 것

메서드 오버라이딩을 할때는 슈퍼클래스 메서드의 이름, 전달인자의 자료형과 전달인자의 개수를 동일하게 정의해야 한다.

은닉된 슈퍼클래스의 메서드의 기능을 불러오기 위해서는 레퍼런스 변수 super를 사용해서 처리한다. super.메서드();

========================== 다른 패키지의 클래스를 호출하는 형식 ===================
package training;
import ex.phone.Mp3;                           // ex.phone 패키지의 Mp3 클래스를 호출
public class Ex07 {
 public static void main(String[] args) {
  Mp3 mp=new Mp3("ever", 256);
  mp.print();
 }
}
=================================================================================

========================== 상속 및 메소드 오버라이딩 ===================
package training;
class MyPoint2D {
 int x=10;
 int y=20;
 // JVM 디폴트 생성자를 제공 : 전달인자 없는 형태
 // 프로그래머가 전달인자 없는 생성자를 만들어주면 없어진다.
 public MyPoint2D(int x, int y){
  System.out.println("MyPoint2D");
 }
 public MyPoint2D(){
 
 }
}
class MyPoint3D extends MyPoint2D { // 슈퍼클래스의 전달인자 없는 생성자 호출
 int x=40;
 int y=50;
 int z=30;
 void show(){
  System.out.println(this.x+","+this.y+","+z);
 }
 void supershow(){
  System.out.println(super.x+","+super.y+","+z);
  //System.out.println(super.x+","+super.y+","+super.z); // z는 부모에 없는 필드
 }
}
public class Ex12 {
 public static void main(String[] args) {
  MyPoint3D pt=new MyPoint3D();
  pt.show();
  pt.supershow();
 }
}
=================================================================================

========================== 접근 지정자 사용예 ===================
package training;
class Point2D{
 // 서브 클래스에서 멤버를 접근허용하기 위한 접근 지정자는 protected
 //  기본(디폴트) 접근지정자
 int x;
 int y;
 //private int x;
 //private int 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;
 }
}
class Point3D extends Point2D{
 private int z;

 public int getZ() {
  return z;
 }

 public void setZ(int z) {
  this.z = z;
 }
 public void show(){
  System.out.println(x + "," + y + "," + z);
 }
}
public class Ex10 {
 public static void main(String[] args) {
  // Point3D pt=new Point3D(1,2,3);
  Point3D pt=new Point3D(); //
  pt.setX(10);
  pt.setY(20);
  pt.setZ(30);
  // System.out.println( pt.getX() +" : pt.getX() , " + pt.getY() + " : pt.getY() ," + pt.getZ() + " : pt.getZ()");
  System.out.println( pt.x +" : pt.getX() , " + pt.getY() + " : pt.getY() ," + pt.getZ() + " : pt.getZ()");
 }
}
=================================================================================

1. 생성자
생성자란 객체 생성 시, 초기화를 위한 메서드로 생성자가 제공된다.
객체가 생성될 때 멤버변수를 초기화하는 일은 생성자가 한다.

생성자는 메서드의 일종이지만 이름은 반드시 클래스명과 동일해야 한다.
메서드의 앞에 리턴형을 기술하지 않고 자료형도 없다.
ex : 접근_지정자 클래스_명 (인수1, 인수2, ...) {
}

package training;
class MyDate {
 int year, month, day;
 // 객체가 생성되자마자 오늘 날짜로 초기화 -> 생성자
 public MyDate() {
  year=2008;
  month=8;
  day=7;
 }
 // 형식매개변수가 3개 있는 생성자가 d2로 호출 된다.
 public MyDate(int new_year, int new_month, int new_day) {
  year=new_year;
  month=new_month;
  day=new_day; // day : 필드, new_day : 전달인자
  System.out.println("전달인자 3개짜리 생성자");
 }
 public MyDate(int new_year, int new_month) {
  // 생성자 this() : 생성자 내애서 첫문장에 위치 하여야 한다.
  this(new_year,new_month,1);
  System.out.println("전달인자 2개짜리 생성자");
 }
 public void print(){
  System.out.println(year+"/"+month+"/"+day);
 }
 public void setDay(int day){
  // 필드에 형식매개변수 값을 저장해야 한다.
  this.day=day;
  print();
 }
 
}
public class Ex02 {
 public static void main(String[] args) {
  MyDate d=new MyDate(); // 객체 생성 시 자동으로 생성자 호출
  d.print();
  // 객체 생성하는 형식
  // new 클래스명 (생성자에 전달해줄 실매개변수 리스트);
  MyDate d2=new MyDate(2008,9,1);
  d2.print();
  d2.setDay(13);
  d2.print();
  MyDate d3=new MyDate(2008,9);
 }
}

디폴트 생성자 : 컴파일러에서 기본적으로 제공되는 되는 생성자
사용자가 생성자를 하나라도 만들게 되면 디폴트 생성자를 사용할 수 없는 점을 유의

2. 레퍼런스 this
this를 사용하는 경우
메소드의 전달인자가 객체 속성과 이름이 동일할 때,

3. 생성자 this()
같은 클래스 내의 다른 생성자를 호출할때 사용

1. 메소드 오버로딩이란?
한 메소드에 대해 여러번 정의할 수 있는데 이름이 같아도 메소드의 자료형과 전달인자의 개수로 구분이 가능하다.

package training;
class YourMath {
 static double max=0;
 public static int max(int a,int b) {
  if(a>b)
   max=a;
  else
   max=b;
  return (int)max;
 }
 public static long max(long a,long b) {
  if(a>b)
   max=a;
  else
   max=b;
  return (long)max;
 }
 public static float max(float a,float b) {
  if(a>b)
   max=a;
  else
   max=b;
  return (float) max;
 }
 public static double max(double a,double b) {
  if(a>b)
   max=a;
  else
   max=b;
  return max;
 }
}
public class Ex02 {
 public static void main(String[] args) {
  System.out.println(YourMath.max(10, 20));
  System.out.println(YourMath.max(4L, 2L));
  System.out.println(YourMath.max(4.2f, 2.3f));
  System.out.println(YourMath.max(4.24, 2.35f));
 }

}

2. Varargs
메소드 내의 기능이 같더라도 전달인자의 개수에 따라 다양하게 호출하기 위해서는 메소드를 여러번 정의해야 하지만 아래처럼 Varargs를 쓰면 한방에 끝난다.

// Varargs를 이용한 출력
package training;
public class Ex04 {
 public static void prn(int ... a){
  for(int i=0;i<a.length;i++)
   System.out.print(a[i] + " ");
  System.out.println();
 }
 public static void main(String[] args) {
  prn(10);
  prn(10,20);
  prn(10,20,30);
 }
}

3. 레퍼런스와 지역변수의 변화를 확인하는 소스
package pack03;
class MyDate {
 int year; int month; int day; // int 형은 초기값이 0 이다.
}
public class Ex01 {
 static void changeInt(int y){
  y+=5;
 }
 static void changeRef(MyDate ref){
  ref.day+=5;
 }
 static MyDate createObject(MyDate ref) {
  ref=new MyDate();
  return ref;
 }
 public static void main(String[] args) {
  int x=10;
  MyDate d=new MyDate();
  for(int i=0;i<5;i++){
   changeInt(x); // main 지역 변수 x를 changInt 메소드에 입력 시켜서 y 값이 증가하지만
        // 출력 되는 값은 지역변수 설정값에 적용 시키지 못한다.
   changeRef(d); // MyDate형의 ref 변수에 레퍼런스 d의 초기값 0/0/0을 대입하고
        // day에 5를 더하여 그 값을 간직하고 있다. <- 이 말이 맞는 말인가???
   System.out.println(x);
   System.out.println(d.year + " : " + d.month + " : " + d.day );
  }
  System.out.println("=====================================");
 
  MyDate t; // 새로운 레퍼런스 t를 만든다
  t=createObject(d); // createObject메소드에 d의 값을 입력하여 t 값을 생성하지만
         // t는 기존의 실매개변수 0/0/0 을 받아서 ref에 저장하고 t로 리턴한다.
  System.out.println("1 " + d.year + " : " + d.month + " : " + d.day );
  System.out.println("2 "  + t.year + " : " + t.month + " : " + t.day );
 
  d.year=2007; d.month=7; d.day=19;
  System.out.println("3 " + d.year + " : " + d.month + " : " + d.day );
  System.out.println("4 "  + t.year + " : " + t.month + " : " + t.day );
 
  t.year=2008; t.month=8; t.day=6;
  System.out.println("5 " + d.year + " : " + d.month + " : " + d.day );
  System.out.println("6 "  + t.year + " : " + t.month + " : " + t.day );
 
  t=createObject(d);
  System.out.println("7 " + d.year + " : " + d.month + " : " + d.day );
  System.out.println("8 "  + t.year + " : " + t.month + " : " + t.day );
 }
}

자바 클래스 선언하기

class 클래스 이름 {
  접근 지정자, 자료형, 변수;
  접근 지정자, 생성자() {
  ...
  }
  접근 지정자, 자료형, 메서드 이름() {
  ...
  }

// 절대값 구하기
package training;
public class Ex01 {
 static int compare(int a){
  //int abs;
  if(a<0){
   a=-a;
  }
   return a;
   // 함수를 호출해 준 곳으로 결과값으로 구한 절대값을 되돌려준다.
   //System.out.println(a);
 }
 public static void main(String[] args) {
  int a=-5; // 지역변수
  System.out.println("compare(a) : " + compare(a));
 }
}

// 1부터 입력 받은 수 까지의 자연수의 합을 구하시오.
// 입력 받은 수의 팩토리알을 구하시오.
package training;
public class Ex03 {
 static int sum(int n){
  int total=0;
  for(int i=1;i<=n;i++){
   total+=i;
  }
  return total;
 }
 static int fac(int m){
  int total=1;
  for(int i=1;i<=m;i++){
   total*=i;
  }
  return total;
 }
 public static void main(String[] args) {
  int n=Integer.parseInt(args[0]);
  System.out.println(" total =" + sum(n));
  System.out.println(" fac =" + fac(5));
 }
}

접근 지정자 :

// 객체 설명
package training;
// 새로운 자료형을 설계 -> 객체(인스턴스변수를 찍어 내기위한 틀)
class Animal{  // 클래스 내부에 멤버를 정의
    // 변수 형태의 속성 : 단순히 값을 저장하는 용도로 사용된다.
 private String name;
 // 캡슐화는 속성에 합당한 값만 저장할 수 있도록 하기 위해서 속성을
 // 외부에서 접근 못하도록 하고 대신 메소드로 접근하도록 한다.
 private int age;  // 접근 지정자 private은 해당 멤버를
                       // 자신의 클래스내의 메소드에서만 사용가능
 public String getName(){ // 속성값을 얻어옴(getter)
  return name;
 }
 public void setName(String new_name){ // 속성을 새로운 값으로 설정(setter)
  name=new_name;
 }
 public int getAge(){ // 속성값을 얻어옴(getter)
  return age;
 }
 public void setAge(int new_age){ // 속성을 새로운 값으로 설정(setter)
  if(new_age>=0)
  age=new_age;
 }
}
public class Ex04 {
 public static void main(String[] args) {
  // 클래스로 선언된 변수는 레퍼런스 변수로 실질적으로
  // 값을 저장할 공간을 마련하지 못한다. -> 실체를 참조하는 용도로 쓰인다.
  Animal a; // a는 선언 시, 기술한 자료형에 의해 형태가 결정된다.
  // 클래스로 실질적인 값을 저장할 공간을 마련하기 위해서는
  // new 연산자를 사용한다.
  // 힙영역에 생성된 실체는 이름이 없지만
  // new 연산자가 메모리 할당 후, 그 메모리의 위치정보를 되돌려 주면
  // 그 위치정보를 레퍼런스변수에 저장해야만 이 실체에 접근할 수 있다.
  a=new Animal();
  // 객체를 멤버 단위로 접근해서 사용함 : 멤버 참조 닷 연산자
  a.setName("사자"); //="원숭이"; // Animal 객체의 이름을 설정한다.
  a.setAge(26);
  // a.age=-26; // Animal 객체의 나이를 설정한다. // 속성을 새로운 값으로 설정
  // 이름하고 나이를 출력
  System.out.println(a.getName() + " , " + a.getAge()); // 속성값을 얻어옴
  // Animal 객체를 하나더 생성하여
  // 레퍼런스 변수 b로 접근하도록 하고
  // 이름은 "펭귄" 나이는 12로 저장하고 출력
  /*Animal b = new Animal();
  b.name="펭귄";
  b.age=12;
  System.out.println(b.name + "," + b.age);*/
 }
}

// int x를 private로 바꿨을 때 출력하기 위한 작업을 하시오.
package training;
class Thing{
 private int x;

 public int getX() {
  return x;
 }

 public void setX(int x) {
  this.x = x;
 }
}
public class Ex05 {
 public static void main(String[] args) {
  Thing thing = new Thing();
  thing.setX(10); //=10;
  System.out.println("x : " + thing.getX());
 }
}

// 속성으로 자판기에서 취급하는 제품의 정보를 저장하는 변수와 이를 다루기 위한 메소드를 갖는 자판기 클래스를 선언하고
// 다음과 같은 결과가 나오도록 객체 생성 후 메소드를 호출하시오.
// 복습할 때 모듈화를 시키시오.
// name, price를 private로 지정하고 출력할 수 있는 작업을 하시오.
package training;
class Product{
 private String name;
 private int price;
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public int getPrice() {
  return price;
 }
 public void setPrice(int price) {
  this.price = price;
 }
 
}
public class Ex06 {
 public static void main(String[] args) {
  /* Product a = new Product();
  a.name="커피";
  a.price=500;
  Product b = new Product();
  b.name="웰치스";
  b.price=700;
  Product c = new Product();
  c.name="포카리";
  c.price=500;
  Product d = new Product();
  d.name="비타500";
  d.price=500;
  for(int i=1;i<=4;i++)
  // System.out.println(a[i].name + ":" + a[i].price + "원");
  System.out.println(a.name + ":" + a.price + "원");
  System.out.println(b.name + ":" + b.price + "원");
  System.out.println(c.name + ":" + c.price + "원");
  System.out.println(d.name + ":" + d.price + "원"); */
 
  // 레퍼런스 변수가 4개 필요
  Product [] a= new Product[4]; // 레퍼런스 값 4개 저장되는 배열
  // 인스턴스 4개 생성해서 레퍼런스 변수가 가리키도록 해야 함
  for(int i=0;i<a.length;i++){
   a[i] = new Product();
  }
   a[0].setName("커피") ; a[0].setPrice(150);
   a[0].setName("웰치스") ; a[0].setPrice(700);
   a[0].setName("포카리") ; a[0].setPrice(500);
   a[0].setName("비타500") ; a[0].setPrice(500);
   for(int i=0;i<a.length;i++){
    System.out.println(a[i].getName() + " , " + a[i].getPrice());
   }
 
 }
}

score[0][0]=10; score[0][1]=90; score[0][2]=70;

score[1][0]=60; score[1][1]=80; score[1][2]=65;

score[2][0]=55; score[2][1]=60; score[2][2]=85;

score[3][0]=90; score[3][1]=75; score[3][2]=95;

score[4][0]=60; score[4][1]=30; score[4][2]=80;

예제 2.
int [][]score = { { 85, 60, 70}, //0 행

                        { 90, 95, 80}, //1 행

                        { 75, 80, 100}, //2 행

                        { 80, 70, 95}, //3 행

                        {100, 65, 80} //4 행

                     };

010: int [] subject = new int[3]; //각 과목별 총점을 저장할 변수 선언

011: int [] student = new int[5]; //각 학생별 총점을 저장할 변수 선언

10. 메서드와 자바 프로그램
모듈화 프로그래밍이란?
프로그래머가 한번에 생각할 수 있는 단위로 모듈화하여 프로그래밍을 할 경우, 프로그램을 작성하기가 쉬워지고 디버깅이 용이하므로 프로그램을 기능별로 모듈화하기 위해서 메서드가 사용되는데 이를 사용자 정의 메서드라고 하며 적절한 곳에서 호출해서 사용할 수 있다.

사용자 정의 메서드 만들기
자료형 메서드이름 (전달인자리스트) {
  변수 선언 ;
  문장 ;
  return (결과 값); // 메서드의 자료형과 리턴값의 자료형은 일치해야 한다.
}

void형 메서드
메서드의 몸체에서 기술한 명령을 실행할 뿐 메서드의 리턴값을 받지 않는 경우 void라는 자료형을 사용한다.

질의 사항
지역 변수와 전역 변수의 차이는???
아래는 main 메서드의 지역변수를 prn메서드에서 불러와서 쓰는 경우인데
지역변수는 정의한 메서드에서만 사용할 수 있다고 했는데
왜 prn 메서드에서 정상적인 호출이 가능한 것인지.
그리고 전역변수로 어떻게 지정하는지...
prn 메서드 내부에서 정의 내리면 왜 컴파일 에러가 나는지...

// char ch = '#'
// int n=5;
// ch에 저장된 문자를 n 개수만큼 반복 출력
package training;
public class Ex14 {
 // char ch='#';
 static void prn(char ch, int n){
  // char ch='#';
  for(int i=0;i<n;i++)
  System.out.print(ch+" ");  
 }
 public static void main(String[] args) {
  char ch='#';
  prn(ch,10);
  prn('@',5);
 
 }

}