package com.test;

public class Class39 {

public int add() { //메소드 원본

int result = 0;

return result;

}

// private int add() { //접근 지정자를 바꾼 경우 -> 오버로딩 상태가 아님

// int result = 0;

// return result;

// }

// public void add() { //반환 자료형을 바꾼 경우 -> 오버로딩 상태가 아님

// int result = 0;

// return result;

// }

public int add(int a) { //매개변수 리스트를 변경한 경우 -> 오버로딩 상태임. 

int result = 0;

return result;

}

public int add(int a, double b) { //매개변수 리스트를 변경한 경우 -> 오버로딩 상태임. 

int result = 0;

return result;

}

public int add(double a, int b) { //매개변수 리스트를 변경한 경우 -> 오버로딩 상태임. 

int result = 0;

return result;

}

//main() 메소드는 유일하게 존재해야 하는 메소드임.

public static void main(String[] args) {

//println()메소드의 오버로딩 상태 확인

System.out.println();

System.out.println("");

//add() 메소드의 오버로딩 상태 확인

Class39 obj = new Class39();

obj.add();

obj.add(10);

obj.add(10.0, 20);

}

}

package com.test;

public class Calc {

public int add() { //1부터 10까지의 합을 출력  

int result = 0;

for (int a=1; a<=10; a++) {

result += a;

}

return result;

}

public int add(int n) {//1부터 n까지의 합을 출력 

int result = 0;

for (int a=1; a<=n ; a++) {

result += a;

}

return result;

}

public int add(int n, int m) {//n부터 m까지의 합을 출력

int result = 0;

for (int a=n; a<=m ; a++) {

result += a;

}

return result;

}

public int add(int n, int m, int x) {//n부터 m까지의 합을 출력하되, x의 배수만 계산 

int result = 0;

for (int a=n; a<=m ; a++) {

if (a%x == 0) {

result += a;

}

}

return result;

}

public int add(int[] arr) {//임의의 수를 여러개 입력 받아서 합을 출력 

int result = 0;

for(int a=0; a<arr.length; a++){

result += arr[a];

}

return result;

}

}

package com.test;

import java.util.Scanner;

public class Process {

public void menu1() {

Calc obj = new Calc();

System.out.printf("결과 : %d %n", obj.add());

}

public void menu2() {

Calc obj = new Calc();

Scanner sc = new Scanner(System.in);

System.out.print("숫자(n)?");

int n = sc.nextInt();

System.out.printf("1부터 %d까지의 합 : %d %n", n, obj.add(n));

}

public void menu3() {

Calc obj = new Calc();

Scanner sc = new Scanner(System.in);

System.out.print("숫자(n)?");

int n = sc.nextInt();

System.out.print("숫자(m)?");

int m = sc.nextInt();

System.out.printf("%d부터 %d까지의 합 : %d %n", n, m, obj.add(n, m));

}

public void menu4() {

Calc obj = new Calc();

Scanner sc = new Scanner(System.in);

System.out.print("숫자(n)?");

int n = sc.nextInt();

System.out.print("숫자(m)?");

int m = sc.nextInt();

System.out.print("배수(x)?");

int x = sc.nextInt();

System.out.printf("%d부터 %d까지의 숫자 중 %d의 배수들의 합 : %d %n", n, m, x, obj.add(n, m, x));

}

public void menu5() {

Scanner sc = new Scanner(System.in);

System.out.print("갯수 입력(2~10)?");

int size = sc.nextInt();

int[] arr = new int[size];

for (int a=0; a<arr.length; a++) {

System.out.printf("숫자%d?", (a+1));

arr[a] = sc.nextInt();

}

Calc obj = new Calc();

int result = obj.add(arr);

System.out.print("입력 받은 숫자 : ");

for (int a=0; a<arr.length; a++) {

System.out.printf("%d ", arr[a]);

}

System.out.println();

System.out.printf("입력 받은 숫자들의 합 : %d %n", result);

}

}

package com.test;

import java.util.*;

public class Class40 {

public static void main(String[] args) {

//메뉴구성(무한반복)

Scanner sc = new Scanner (System.in);

Process obj = new Process();

do{

System.out.println();

System.out.println();

System.out.println("덧셈 결과를 출력하는 메소드 만들기");

System.out.println("1. 1부터 10까지의 합을 출력");

System.out.println("2. 1부터 n까지의 합을 출력");

System.out.println("3. n부터 m까지의 합을 출력");

System.out.println("4. n부터 m까지의 합을 출력하되, x의 배수만 계산"); 

System.out.println("5. 임의의 수를 여러개 입력 받아서 합을 출력");

System.out.print("선택(1~5, -1:종료)?");

int menu = sc.nextInt();

if (menu == -1) {

System.out.println("프로그램을 종료합니다.");

break;

}

switch (menu) {

case 1: obj.menu1(); break;

case 2: obj.menu2(); break;

case 3: obj.menu3(); break;

case 4: obj.menu4(); break;

case 5: obj.menu5(); break;

}

}while(true);

}

}

package com.test;

//모든 클래스는 자동으로 Object 클래스를 상속받는다.

public class Class41 {

public static void main(String[] args){

Class41 obj = new Class41();

//Object 클래스에서 구현된 멤버인 toString() 메소드를 Class41 클래스의 멤버인 것처럼 호출 가능

String result1 = obj.toString(); //-> 객체명(자료형@해시코드) 리턴

System.out.println(result1);

//객체가 생성될 때마다 고유하게 생성되므로 독립적인 상태가 된다.

Class41 test = new Class41();

String result2 = test.toString();

System.out.println(result2);

}

}

//원본 클래스

public class 프린터 {

public void 인쇄(String 출력대상) {

System.out.println(출력대상);

}

}

//파생0 클래스

public class 프린터종이추가 extends 프린터 {

public void 종이추가(int 종이) {

if (종이 == 0){

종이 = 100;

}

}

}

//파생1 클래스

public class 프린터잉크교체 extends 프린터종이추가 {

public void 잉크교체() {

새로운잉크카트리지;

if (잉크 == 0) {

잉크 = 새로운잉크카트리지;

}

}

}

//파생2 클래스

public class 복합기프린터_스캐너 extends 프린터잉크교체 {

public void 스캐너(String 스캔대상) {

Scanner sc = new Scanner(System.in);

String bmp = sc.next();

}

}

//파생3 클래스

public class 복합기프린터_팩스 extends 복합기프린터_스캐너 {

public void 팩스(전송서류) {

팩스 = 전송서류;

}

}

//파생4 클래스

public class 복합기프린터_이메일 extends 복합기프린터_팩스 {

public void 복합기(String 이메일) {

이메일 전송 처리클래스 obj = new 이메일 전송 처리클래스();

obj.이메일전송(이메일);

}

}

package com.test;

//물리적인 java 파일 한 개에 논리적인 class가 여러개인 경우는

//파일명과 동일한 클래스를 제외하고 나머지 클래스는 public 지정 불가

/*

class Super1 {

}

class Super2 {

}

//다중 상속 불가 -> 인터페이스를 가지고 다중 상속을 시켜야 한다.

class Sub1 extends Super1, Super2 {

}*/

interface Super1 {

}

interface Super2 {

}

class Sub1 implements Super1, Super2 {

}

public class Class43 {

public static void main (String[] args){

}

}

package com.test;

public class Super3 {

//private 멤버

private void method1(){

}

//public 멤버

public void method2(){

}

//protected 멤버

protected void method3(){

}

}

package com.test;

public class Sub3 extends Super3 {

//Super3 클래스의 멤버들 중에서 특정 멤버는 상속을 받게된다.

//-> method2(), method3()

//private 멤버

private void method4(){

}

//public 멤버

public void method5(){

}

//protected 멤버 -> 같은 패키지 및 상속 관계에서 서브 클래스에서만 접근 가능.

protected void method6(){

}

}

package com.test;

public class Class44 {

public static void main(String[] args) {

Super3 obj1 = new Super3();

//Super3 클래스의 객체인 obj1은 하위 멤버를 ..... 가질 수 있다.

//method2 , method3

// obj1.method1(); //접근 불가 접근지정자가 private이므로 ㅇㅇ

obj1.method2();

obj1.method3();

Sub3 obj2 = new Sub3();

//Sub3 클래스의 객체인 obj2는 하위멤버 ()를 접근할 수 있다.

//method2, method3, method5 method6

//obj2.method1(); //X. Super3 클래스의 멤버. private 이므로..

obj2.method2(); //O Super3 클래스의 멤버. 상속받은 멤버

obj2.method3(); //O Super3 클래스의 멤버. 상속받은 멤버

//obj2.method4(); //X private 멤버는 접근 불가.

obj2.method5(); //O 

obj2.method6(); //O

}

}

--------------------------- 다른 패키지 ---------------------------------

//Sub4.java

package com.sample;

import com.test.Super3;

public class Sub4 extends Super3 {

public void method7() {

//다른 패키지의 수퍼 클래스에 있는 protected 멤버는 서브 클래스에서 접근 가능.

//method3() 호출

this.method3();

}

}

//Class45.java

package com.sample;

import com.test.Sub3;

public class Class45 {

public static void main(String[] args) {

Sub3 obj2 = new Sub3();

//Sub3 클래스의 객체인 obj2는 하위멤버 ()를 접근할 수 있다.

//method2, method3, method5 method6

//obj2.method1(); //X. 

obj2.method2(); //O 

//obj2.method3(); //X. protected 접근 지정자. 다른 패키지에서 접근 불가

//obj2.method4(); //X 

obj2.method5(); //O 

//obj2.method6(); //x protected 접근 지정자. 다른 패키지에서 접근 불가

Sub4 obj3 = new Sub4();

//Sub4 클래스의 객체인 obj3는 하위멤버 ()를 접근할 수 있다.

//method2, method3, method5 method6

obj3.method2();

//obj3.method3();// X. 실제 호출하는 위치가 다른 패키지이기 때문에 안됨.

obj3.method7();

}

}

package com.test;

import java.util.*;

final class FinalSuper { //파이널(상속 불가) 클래스

}

//class Sub extends FinalSuper { //X. 상속 불가

//

//}

class Sub extends Random {

}

public class Class46 {

public static void main(String[] args) {

FinalSuper obj = new FinalSuper(); // 객체 생성가능

//파이널클래스

System.out.println();

Scanner sc = new Scanner(System.in);

//일반클래스

Random rd = new Random();

int[] arr = new int[10];

Arrays.sort(arr);

}

}

package com.test;

class Super4 {

public int add() {

//1 부터 10까지의 합을 계산해서 리턴

int result = 0;

for (int a=1 ; a<= 10; a++) {

result += a;

}

return result;

}

}

class Sub4 extends Super4 {

@Override

public int add() { //메소드 오버라이딩

//1 부터 100까지의 합을 계산해서 리턴

int result = 0;

for (int a=1 ; a<= 100; a++) {

result += a;

}

return result;

}

}

public class Class47 {

public static void main(String[] args) {

Super4 obj1 = new Super4();

System.out.printf("1부터 10까지의 합 : %d %n", obj1.add());

Sub4 obj2 = new Sub4();

System.out.printf("1부터 100까지의 합 : %d %n", obj2.add());

}

}

package com.test;

public class Member {

private String name, tel;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getTel() {

return tel;

}

public void setTel(String tel) {

this.tel = tel;

}

//toString() 메소드 오버라이딩 구현

//이클립스에서 오버라이딩 구현 기능 사용

//Source -> Override/Implement Methods...

@Override

public String toString() {

String result = "";

result = String.format("%4s  %9s", this.getName(), this.getTel());

return result;

}

}

package com.test;

import java.util.*;

public class Class48 {

public static void main(String[] args) {

//입력

Scanner sc = new Scanner(System.in);

System.out.print("회원수 입력(1~10)?");

String num = sc.next();

int count = Integer.parseInt(num);

//이름및 전화번호 자료형 클래스 활성화 및 저장용 배열 생성

Member[] members = new Member[count]; // 사용자 정의 클래스 자료형인 배열을 생성

//처리

for (int a=0; a<members.length; a++) {

System.out.printf("이름:전화번호(%d)?", (a+1));

String name = sc.next(); //이름

String tel = sc.next(); //전화번호

Member member = new Member(); // Member 객체 생성 과정

member.setName(name); //Member 객체에 이름 저장

member.setTel(tel); //Member 객체에 전화번호 저장

members[a] = member; //Member 객체를 배열에 저장하는 과정

}

//출력

System.out.println("----------------");

System.out.printf("전체 회원수: %d명%n", count);

System.out.println("----------------");

System.out.println("이름   전화번호");

for (int a=0; a<members.length; a++) {

//System.out.printf("%4s  %8s %n", ((Member)members[a]).getName(), ((Member)members[a]).getTel()); //캐스트 연산자 Member는 클래스 자료형이니까 ㅇㅇ

//오버라이딩 하기 전 상태 -> 해시코드 출력.

//오버라이딩 후 -> 재정의된 내용으로 출력.

System.out.println(members[a].toString());

}

System.out.println("----------------");

}

}

package com.test;

public class Calc2 {

private int n, m, sum;

private String x = "";

//기본생성자

public Calc2() {

this(1, 10, 1); //this 생성자

}

//생성자 오버로딩

public Calc2(int n) {

this(1, n, 1);

}

//생성자 오버로딩

public Calc2(int n, int m) {

this(n, m, 1);

}

//생성자 오버로딩

public Calc2(int n, int m, int x) {

this.n = n;

this.m = m;

if (x > 1) {

this.x = String.format("(%d의 배수만 계산)", x);

}

for (int a=n; a<=m; a++) {

if(a%x == 0) {

this.sum += a;

}

}

}

@Override // 상위상속클래스인 Object 클래스의 멤버인 toString()의 오버라이딩 (메소드 재정의)

public String toString() {

String result =  "";

result = String.format("%d부터 %d까지의 합 %s : %d", this.n, this.m, this.x, this.sum);

return result;

}

}

package com.test;

public class Class49 {

public static void main(String[] args) {

Calc2 obj1 = new Calc2();

System.out.println(obj1.toString());

Calc2 obj2 = new Calc2(10);

System.out.println(obj2.toString());

Calc2 obj3 = new Calc2(10, 20);

System.out.println(obj3.toString());

Calc2 obj4 = new Calc2(1, 100, 5);

System.out.println(obj4.toString());

}

}

1부터 10까지의 합  : 55

1부터 10까지의 합  : 55

10부터 20까지의 합  : 165

1부터 100까지의 합 (5의 배수만 계산) : 1050