D-PLAT

안녕하세요 입니다. 
오늘은 상속부터 import 를 설명해드리겠습니다. 
부족한점은 말씀해주시면 고치겠습니다. 



1. 상속  
 - 상속이란 기존의 클래스를 재사용하여 새로운 클래스를 작성하는 것이다. 
상속을 통해서 클래스를 작성하면 보다 적은 양의 코드로 새로운 클래스를 작성할 수 있고 코드를 공통적으로 관리할 수 있기에 코드의 추가 및 변경이 매우 용이하다. 

- 상속은 어떻게하느냐 ?  
아주간단하다 작성하고자하는 클래스 이름뒤에 상속받고자 하는 클래스 이름을 키워드 
extends 와 함께 서주기만 하면된다. 

~~~~ 
class Child extends Parest{ 

내용 

} 
~~~~ 

예를들어 보았습니다. 간단하죠 ?? 
그럼다음으로 ~ 

이두클래스는 서로 상속 관계에 있다고 하며, 상속해주는 '클래스를 조상 '클래스라고하며 
상속 받는 클래스를 '자손 클래스' 라고한다. 

- 조상클래스 : 부모클래스, 상위 클래스, 기반클래스  라고 불린다. 
- 자손 클래스 : 자식클래스, 하위 클래스, 파생된 클래스 라고 불린다. 

---- 
- 생성자와 초기화 블럭은 상속되지 않는다. 맴버만 상속된다. 
- 자손 클래스의 맴버 개수는 조상 클래스보다 항상 같거나 많다. 
---- 

ex) 
~~~~ 
package 삼월이십육일; 

class Tv { 
boolean power ; //전원상태(on/off) 
int channel; 

void power() { power = !power;} 
void channelUp() { ++channel;} 
void channelDown() {-- channel;} 
} 

class CaptionTv extends Tv{ 
boolean caption; 
void displayCaption(String text) { 
if(caption){ 
System.out.println(text); 
} 
} 
} 
class CaptionTvTest { 
public static void main(String args[]) { 
CaptionTv ctv = new CaptionTv(); 
ctv.channel = 10; 
ctv.channelUp(); 
System.out.println(ctv.channel); 
ctv.displayCaption("Hello world1"); 
ctv.caption = true; 
ctv.displayCaption("Hello world1"); 
} 
} 



~~~~ 
TV 클래로부터 상속받고 기능을 추가하여 CaptionTv 클래스를 작성하였다. 
맴버변수 caption은 캡션 기능의 상태를 저장하기위한  boolean 형 변수이고,  
displayCaption(String text) 은 매개변수로넘겨받은 문자열을 캡션이 켜져 있는경우 에만  
화면에 출력한다. 

1.2 클래스간의 관계 - 포함관계 
- 지금까지 상속을 통해 클래스 간에 관계를 맺어주고 클래스를 재사용하는 방법에 대해서 
알아보았습니다.  
상속 이외에도 클래스를 재사용하는 또다른 방법이 있는데 그것은 클래스 간에  
 포함 관계를 맺어주는 것입니다. 클래스 간의 포함관계를 맺어주는 것은  
한 클래스의 맴버변수로다른 클래스 타입의 참조변수를 선언하는 것을 뜻한다. 

ex) 
~~~~ 

class Point { 
int x; 
int y; 
} 


class Cicle{ -------> class Cicle{ 
int x;              -------> Point c = new Point();         
int y;              -------> int r; 
int r;               -------> } 
} 
~~~~ 
이런식으로 변경할수 있습니다. 

1.3 클래스 간의 관계 결정하기 

- 클래스를 작성하는데 있어서 상속관계를 맺어줄 것인지 포함관계를 맺어줄  
것인지 결정하는 것은 때때로 혼돈스러울수 있다. 
~~~~ 
class Cicle { 
Point c = new Point(); 
int r; 
} 
| 
| 
| 
class Cicle extends Point { 
int r; 
} 
~~~~ 
두경우를 비교해 보면 cicle클래스를 작성하는데 있어서 Point클래스를 포함시키거나 
상속받도록 하는 것은 결과적으로 별 차이가 없어 보인다. 
 그럴때는 이렇게 해보자 


- 상속관계 : ~은 ~이다 (is ~a) 
- 포함관계 : ~은 ~ 을 가지고 있다.(jas~ a) 

몇가지를 더 예르 들면, Car 클래스와 SportsCar 클래스는 SportsCar는 Car 이다 
와같이 문장을 만드는것이 더 옳기 때문에 두클래스는 Car 클래스를 조상으로  
하는 상속 관계를 맺어 주어야 한다. 

Card 클래스와 Deck 클래스는 Deck는 Card 를 가지고 있다. 
와같이 문장을 만드는 것이 더 옳기 때문에 Deck 클래스에 Card클래스를  
포함시켜야한다. 

1.4 단일상속 
- 다른 객체지향언어인 c++ 에서는 여러 조상클래스로부터 상속받는 것이 가능한 
'다중상속' 을 허용하지만 자바에서는 단일 상속만을허용한다. 
그래서 하나 이상의 클래스로부터 상속을 받을 수 없다. 
예를들면 TV 클래스와 VCR 클래스가 있을때 이 두클래스로부터 상속을 받는 
TVCR 클래스는 작성할 수 없다. 
그래서 TVCR 클래스는 조상클래스로 TV 클래스와 VCR 클래스 중 
하난만 선택해야 한다. 

~~~~ 
/*package 삼월이십육일; 



class Tv { 
boolean power ; 
int channel; 

void power() { power = !power;} 
void channelUp() { ++channel;} 
void channelDown() { --channel;} 
} 

class VCR{ 
boolean power; 
int counter = 0; 
void power() { power = !power} 
void play()  { 내용생략}  
void play(){ 내용생략} 
void stop(){ 내용생략} 
void rew(){ 내용생략} 
void ff(){ 내용생략} 

} 
class TVCR extends Tv { 
VCR vcr = new VCR(); 
int counter = vcr.counter; 

void play() { 
vcr.play(); 
} 
void stop(){ 
vcr.stop(); 
} 
void rew() { 
vcr.rew(); 
} 
void ff() { 
vcr.ff(); 
} 
} 

~~~~ 
이런식으로 단일 상속을 하실수 있습니다. 

1.5 Object 클래스 - 모든 클래스의 조상 

-  Object 클래스는 모든 클래스 상속계층도의 최상위에있는조상클래스이다. 
다른 클래스로 부터 상속 받지 않는 모든 클래스 들은 자동적으로  
Object 클래스로부터 상속받게 함으로써 이것을 가능하게한다. 

여기는 간단하게 하고 넘어가겠습니다.~ 


2.1 오버라이딩  
 조상 클래스로부터 상속받은 메서드의 내용을 변경하는 것을 오버라이딩이라고한다. 
상속받은 메서드를 그래도 사용하기도 하지만, 자손 클래스를 자신에 맞게 
변경해야하는 경우 가 많다. 이럴 때 조상의 메서드를 오버라이딩한다. 

- 오버라이딩 조건 
----  
자손클래스에서 오버라이딩하는 메서드는 조상클래스 메서드와  
     -  이름이 같아야한다. 
     -  매개변수가 같아야 한다. 
     -  반환타입이 같아야 한다. 
---- 

- 오버로딩 VS 오버라이딩 

오버로딩과 오버라이딩은 서로 호동하기 쉽지만 사실 그 차이는 명백하다. 
오버로딩은 기존에 없는 새로운메서드를 추가하는 것이고, 
오버라이딩은 조상으로부터 상속받은 메서드의 내용을 변경하는 것이다. 

2.2 super 

super 은 자손 클래스에서 조상 클래스로부터 상속받은 맴버를 참조하는 데 사용되는 
참조변수이다.  

~~~~ 
package 삼월이십육일; 

public class SuperTest { 
public static void main(String args[]) { 
Child c = new Child(); 
c.method(); 
} 
} 

class Parent{ 
int x= 10; 
} 
class Child extends Parent { 
void method() { 
System.out.println("x :" +x); 
System.out.println("this.x :" + this.x); 
System.out.println("super.x:" + super.x); 
} 
} 
//이 경우 x, this.x , super.x 모두 같은 변수를 의미하므로모두 같은 값이 출력되었다. 
~~~~ 

ps - Object클래스를 제외한 모든 클래스의 생성자 첫 줄에는 생성자,this() 또는 
super(), 를 호출해야한다. 그렇지 않으면 컴파일러가 자동적으로  
super().;를 생성자의 첫 줄에 삽입한다. 

2.3 import 선언 

일반적인 소스파일 의 구성은 다음 순서로 되어있다. 

1. package문  
2. import 문 
3. 클래스 선언 

~~~~ 
package 삼월이십육일; 

import java.util.Date; 
import java.text.SimpleDateFormat; 

public class ImportTest { 
public static void main(String args[]) { 
Date today = new Date(); 

SimpleDateFormat date = new SimpleDateFormat("yyyy/MM/dd"); 
SimpleDateFormat time = new SimpleDateFormat("hh:mm:ss a"); 

System.out.println("오늘 날짜는 "+date.format(today)); 
System.out.println("오늘시간은 " +time.format(today)); 
} 
} 

~~~~ 


이상으로 길고 길었던 10번째 개발일지를 마치겠습니다 
긴글인데 봐주신분들  진심으로 감사드립니다.

안녕하세요 오늘은 9번째 개발일지  
생성자 부터 변수까지 알아보겠습니다. 

1.생성자란? 
- 
- 생선자는 인스턴스가 생성될 때 호출되는 '인스턴스 초기화 메서드' 이다. 
따라서 인스턴스변수의 초기화 작업에 주로 사용되며 , 인스턴스 생성 시에  
실행되어야 할 작업을 위해서도 사용된다. 


-생성자의 이름은 클래스의 이름과 같아야한다 
-생성자는 리턴 값이 없다. 

 연산자 new 가 인스턴스를 생성하는거지 생성자가 인스턴스를생성하는 것이 아니다. 

1-1. 기본생성자 

- 생성자를 모르고도 프로그래밍을 해 왔지만 , 사실은 모든 클래스에는 반드시 하나 이상의 
생성자가 정의 되어있어야한다. 
하지만 클래스에 생성자 정의를 하지않고도 인스턴스를 생성할 수 있었던 이유는 
 기본생성자 덕분이다. 

- 컴파일러가 자동적으로 기본 생성자를 추가해주는 경우는 클래스 내에 생성자가  
하나도 없을때 이다. 만약 하나라도 있을시에는 생성 되지 않는다. 

1-2. 생성자에서 다른 생성자 호출하기 -this(), this 

-같은 클래스의 맴버들 간에 서로 호출할 수 있는 것처럼 생성자 간에도서로 호출이 가능하다. 
하지만 밑에 두가지 조건을 충족 시켜야한다. 

-  생성자의 이름으로 클래스이름 대신 this 를 사용한다. 
-  한 생성자에서 다른생성자를  호출할 대는 반드시 첫 줄에서만 호출이 가능하다. 

~~~~ 
package 삼월이십이일; 

class Car{ 
String color; 
String gearType ; 
int door; 

Car(){ 
this("white", "auto", 4); 
} 
Car(String color) { 
this(color,"auto", 4); 
} 
Car(String color, String gearType, int door){ 
this.color = color; 
this.gearType = gearType; 
this.door = door; 
} 

} 
class CarTest2{ 
public static void main(String args[]){ 
Car c1 = new Car(); 
Car c2 = new Car("blue"); 

System.out.println("c1의 color =" + c1.color +", gear Type=" + c1.gearType +"door="+c1.door); 
System.out.println("c2의 color =" + c2.color +", gear Type=" + c2.gearType +"door="+c2.door); 
} 
} 
~~~~ 

생성자 Car() 에서 또다른 생성자 Car(String color, String gearType, int door)를 호출하였다.  
이처럼 생성자간의 호출에서는  생성자의이름대신 'this ' 를 사용해야만 하므로 
'Car' eotls 'this'를 사용했다. 그리고 Car() 의 첫째 줄에서 호출하였다는점을 
눈여겨 보세요. 

this -  인스턴스 자신을 가르키는 참조변수, 인스턴스의 주소가 저장되어 있다. 
모든 인스턴스 메서드에 지역변수로 숨겨진 채로 존재한다. 

this(), this(매개변수) -  생성자, 같은 클래스의 다른 생성자를 호출할 때 사용한다 


2.변수의 초기화 
- 
-  변수를 선언하고 처음으로 값을 저장하는 것을 '변수의 초기화' 라고한다.  
변수의 초기화는 경우에 따라서  필수적 이기도 하고 선택적이기도 하지만 , 
가능하면 선언과 동시에 적절히 한값으로 초기화하는것이 바람직하다. 

2-1. 명시적 초기화 
-  변수를 선언과 동시에 초기화 하는것을 명시적 초기화라고 한다.  
-  명시적 초기화가 간단하고 명료하긴 하지만 , 보다 복잡한 초기화 작업이  
필요할 때는 '초기화 블럭' 또는 생성자를 사용해야 한다. 

2-2. 초기화 블럭 
-  초기화 블럭에는 '클래스 초기화 블럭' 과 '인스턴스 초기화 블럭' 두가지 
종류가 있다. 클래스 초기화 블럭은 클래스변수의 초기화에 사용되고 ,  
인스턴스 초기화 블럭은 인스턴스 변수의 초기화에 사용된다. 

-  클래스 초기화 블럭 = 클래스변수의 복잡한 초기화에 사용된다. 
-  인스턴스 초기화 블럭 = 인스턴스변수의 복잡한 초기화에 사용된다. 


-  초기화 블럭을 작성하려면, 인스턴스 초기화 블럭은 단순히 클래스 내에 
블럭 {} 을 만들고 그안에 코드를 작성하기만 하면된다. 
그리고 클래스 초기화 블럭은 인스턴스 초기화 블럭앞에 단순히 static를 
덧붙이기만 하면된다. 

~~~~ 
class InitBlock { 
         static { /* 클래스 초기화 블럭입니다. */} 

{/* 인스턴스 초기화 블럭입니다 */} 
} 
~~~~ 

-  클래스 초기화 블럭은 클래스가 메모리에 처음 로딩될때 한번만 수행되며, 
인스턴스 초기화 블럭은 생성자와 같이 인스턴스를 생성할 때마다 수행한다. 

-   생성자보다인스턴스 초기화 블럭이 먼저 수행된다. 

2-3. 맴버변수의 초기화 시기와 순수 


클래스 변수의 초기화 시점  
-  클래스가 처음 로딩될 때 단 한번 초기화 된다. 

인스턴스변수의 초기화 시점  
-  인스턴스가 생성될 때마다 각 인스턴스별로 초기화가 이루어진다. 

클래스 변수의 초기화 순서 
-  기본값 >>> 명시적초기화 >>> 클래스 초기화 블럭 

인스턴스변수의 초기화 순서  
-  기본값 >>> 명시적초기화 >>> 인스턴스 초기화 블럭 >>> 생성자 

안녕하세요  
오늘은 객체지향프로그래밍 2번째 를 간단하게 설명 드리겠습니다. 

3-1 JVM 메모리 구조 

1. 메서드 영역 
- 프로그램 실행 중 어떤 클래스가 사용되면 , JVM 은 해당클래스의 클래스파일을 읽어서  
분석하여 클래스에 대한 정보를 이곳에 저장한다.  
이때 , 그 클래스의 클래스 변수도 이영역에 함께생성된다. 


  2  .힙 

- 인스턴스가 생성되는공간, 프로그램 실행 중 생성되는 인스턴스는 모두 이곳에 생성된다. 
즉, 인스턴수 들이 생성되는 공간이다. 

3.호출스택 

 - 호출스택은 메서드의 작업에 필요한 메모리 공간을 제공한다. 메서드가 호출되면, 
 호출스택에 호출된 메서드를 위한 메모리가 할당되며 , 이 메모리는 메서드가 작업을 
 수행하는 동안 지역변수들과 연산 중간결과 등을 저장하는데 사용한다. 
그리고 그 메서드가 작업을 마치면  할당되었던 메모리공간은  
반환되어 비워진다. 


3-1. 기본형 매개변수와 참조형 매개변수 

기본형 매개변수 - 변수값을 읽기만 할 수 있다.(read only) 
참조형 매개변수 - 변수값을 읽고 변경할 수 있다.(read & write) 

4-1. 재귀호출 
 1. 메서드의 내부에서 메서드 자신을 다시 호출하는 것을 '재귀호출' 이라고 하고, 
재귀호출을 하는 메서드를 '재귀 메서드' 라고한다 
~~~~ 
package 삼월이십일일; 

public class FactorialTest { 
public static void main(String args[]) { 
int result = factorial(4); 

System.out.println(result); 
} 
static int factorial(int n){ 
int result =0; 

if(n ==1) { 
result =1; 
}else { 
result = n * factorial(n-1); // 다시 메서드 자신을 호출한다 
} 
return result; 
} 

} 
~~~~ 

~~~~ 
package 삼월이십일일; 

public class FactorialTest2 { 
static long factorial(int n) { 
if(n<=0 || n>20) return -1;  
if(n<=1) return 1; 

return n* factorial(n-1); 

} 
public static void main(String args[]) { 
int n =21; 
long result = 0; 

for(int i =1; i<n; i++){ 
result = factorial(i); 

if(result == -1){ 
System.out.printf("유효하지 않은 값 입니다. +(0<n<=20) :%d%n" ,n); 
break; 
} 
System.out.printf("%2d!=%20d%n",i,result); 
} 
} 
} 
~~~~ 


~~~~ 

package 삼월이십일일; 

public class PowerTest { 
public static void main(String args []) { 
int x= 2; 
int n= 5; 
long result =0; 

for(int i =1; i<=n; i++) { 
result += power(x,i);  
} 
System.out.println(result); 
} 
static long power(int x, int n) { 
if(n==1) return x; 
return x*power(x, n-1); 
} 
} 
//제귀메서드 
~~~~ 
4-1 오버로딩이란 ? 
-한클래스 내에 같은 이름의 메서드를 여러 개 정의하는것을 '메서드 오버로딩'  or '오버로딩' 
 이라고 한다. 

- 오버로딩의 조건? 
1. 메서드 이름이 같아야한다. 
2. 매개변수의 개수 또는 타입이 달라야 한다. 

이상으로 여덞번째 개발일지를 마치겠습니다. 

ackage 삼월이십일; 

public class CardTest { 
public static void main(String args[]) { 
System.out.println("Card.width =" + Card.width); 
System.out.println("Card.height=" + Card.height); 

Card c1 = new Card(); 
c1.kind = "Heart"; 
c1.number = 7; 

Card c2 = new Card(); 
c2.kind = "Space"; 
c2.number = 4; 

System.out.println("c1 은 " + c1.kind + "," + c1.number 
+"이며, 크기는 ("+ c1.width +"," +c1.height +")"); 
System.out.println("c2 은 " + c2.kind + "," + c2.number 
+"이며, 크기는 ("+ c2.width +"," +c2.height +")"); 

System.out.println("c1의  width와 height 를 각각 50, 80으로 변경합니다"); 
c1.width = 50; 
c1.height = 80; 

System.out.println("c1 은 " + c1.kind + "," + c1.number 
+"이며, 크기는 ("+ c2.width +"," +c2.height +")"); 
System.out.println("c2 은 " + c2.kind + "," + c2.number 
+"이며, 크기는 ("+ c2.width +"," +c2.height +")"); 


} 
} 

class Card { 
String kind; 
int number; 
static int width = 100; 
static int height = 250; 
} 





package 삼월이십일; 

public class ReferenceParamEx2 { 
public static void main(String args[]) { 

int [] x = {10}; 
System.out.println("main () : x =" + x[0]); 

change(x); 
System.out.println("After change(x)"); 
System.out.println("main() : x ="  + x[0]); 

} 
static void change(int[] x){ 
x[0] = 1000; 
System.out.println("change(): x=" + x[0]); 
} 
} 

안녕하세요  오늘은 객체지향단원에 들어갔는데 ! 이론이 중요한것들이 보여 이론은 핵심만 찝어서 올리도록 하겠습니다 잘부탁드립니다. 

1-1.객체지향언어 의 특징  
1.코드의 재사용성이 높다  
(새로운 코드를 작성할 때 기존의 코드를 이용하여 쉽게 작성할 수 있다.) 

2.코드의 관리가 용이하다 
(코드간의 관계를 이용해서 적은 노력으로 쉽게 코드를 변경할 수 있다.) 

3. 신뢰성이 높은 프로그래밍을 가능하게 한다 
(제어자와 메서드를 이용해서 데이터를 보호하고 올바른 값을 유지하도록 하며 , 

코드의 중복을 제거하여 코드의 불일치로 인한 오동작을 방지 할 수 있다) 
객체지향언어의 가장 큰 장점은 '코드의 재사용성이 높고 유지;보수가 용이하다' 는 것이다. 






1-2.클래스와 객체의 정의와 용도 
클래스란 ?  

(객체를 정의해 놓은것, 또는 클래스는 객체의 설계도 또는 틀이라고 정의할 수 있다. 
클래스는 객체를 생성하는데 사용되며, 객체는 클래스에 정의된 대로 생성된다.) 

클래스의 정의 - 클래스란 객체를 정의해 놓은 것이다. 
클래스의 용도 - 클래스는 객체를 생성하는데 사용된다. 

객체란? 
(실제로 존재하는 것 이다. 우리가 주변에서 볼 수 있는 책상, 의자, 자동차와 같은 사물들이 곧 객체이다 .) 

객체의 정의 - 실제로 존재하는것 ,사물 또는 개념 
객체의 용도 - 객체가 가지고 있는 기능과속성에 따라 다름 





2-1.객체와 인스턴스 
클래스로부터 객체를 만드는 과정을 클래스의 인스턴스화 라고하면,  어떤 클래스로부터 만들어진 객체를 그 클래스의 인스턴스 라고한다. 

예를들면 Tv 클래스로부터 만들어진 객체를 Tv 클래스의 인스턴스 라고 한다. 
 결국 인스턴스는 객체와 같은 의미이지만 ,  

객체는 모든 인스턴스를 대표한느 포괄적인 의미를 갖고 있으며  
인스턴스는 어떤 클래스로부터 만들어진  것인지를 강조하는 보다 구체적인 의미를 갖고 있다. 








2-2 객체의 구성요소 - 속성과 기능 

객체는 속성과 기능, 두 종류의 구성요소로 이루어져 있으며, 일반적으로 객체는 다수의 속성과 다수의 기능 갖는다. 즉, 객체는 속성과 기능의 집합이라고 할 수 있다.  
그리고 객체가 가지고 있는 속성과 기능을  그 객체의 맴버 라 한다 

속성 = 맴버변수, 특성, 필드. 상태 
기능 = 메서드. 함수, 행위 


보다 쉽게 이해할 수 있도록  TV 를 예를 들어보면 

속성 - 크기, 길이, 높이 , 생삭 ,불륨 ,채널 등  

기능 - 켜기, 끄기 , 볼륨 높이기 , 볼륨 낮추기, 채널 변경하기 등 



2-3 .인스턴스의 생성과 사용 

Tv 클래스를 선언한 것은 Tv 설계도를 작성한 것에 불과하므로 Tv 인스턴스를 생성해야 제품 을 사용할 수 있다. 
클래스로부터인스턴스를생성하는 방법은 여러가지가 있지만 일반적으로는 다음과 같다. 

클래스명 변수명 //  클래스의 객체를 참조하기 위한 참조변수를 선언 
변수명 = new 클래스면 ();  // 클래스의 객체를 생성 후, 객체의 주소를 참조변수에 저장 
 Tv t;                   // Tv 클래스 타입의 참조변수 t 선언  
 t = new Tv();  // Tv 인스턴스를 생성한 후, 생성된 TV 인스턴스의 주소를 T에 저장 
이상으로 간단하면서  상세한 이론을 마치겠습니다. 




package 삼월십구일; 

class Tv{ 
String color; 
boolean power; 
int channel; 

void power() { power = !power ;} 
void channelUp() { ++channel;} 
void channelDown() { --channel;} 


} 

public class TvTest2 { 
public static void main(String args[]) { 

Tv t1 = new Tv(); 
Tv t2 = new Tv(); 
System.out.println("t1 의 channel 값은 :" + t1.channel + "입니다"); 
System.out.println("t2 의 channel 값은 :" + t2.channel + "입니다"); 

t2 = t1; 
t1.channel = 7; //channel 값을 7로 한다 

System.out.println("t1의  channel 값을 7로 변경하였습니다"); 

System.out.println("t1의 channel의 값은 :"+t1.channel+"입니다"); 
System.out.println("t2의 channel의 값은 :"+t2.channel+"입니다"); 

} 
} 
//위의 예제는 Tv 클래스의 인스턴스 t1과 t2 를 생성후에 , 인스턴스 t1 의 맴버변수인 channel 의 값을 변경하였다.

안녕하세요 .  
오늘은 다섯째 공부 인데요 오늘은 양이 짧습니다. 이해부탁드리겠습니다. 


첫번재로는 배열 앞6자리 바꾸기입니다. 

package 삼월십오일; 

public class ArrayEx8 { 
public static void main(String args[]) { 

// 45 개의 정수값을 저장하기우한 배열 생성 
int[] ball = new int [45]; 

//배열의 각 요소에 1~45 값을 저장한다 . 
for(int i = 0; i< ball.length; i++) { 
ball[i] = i+1; 
} 
int temp = 0; //두 값을 바꾸는데 사용할 임시변슈 
int j = 0; // 임의의 값을 얻어서 저장할 변수 

// 배열의  i 번째 요소와 임의의 요소에 저장된 값을 서로 바꿔서 값을 섞는다. 
//0번재부터 5번째 요소까지 모두 6개만 바꾼다. 
for(int i=0; i< 6; i++){ 
j = (int)(Math.random() * 45); //0부터 44범위의 정수를 얻는다 
temp  = ball[i]; 
ball[i] = ball[j]; 
ball[j] = temp; 

} 
//배열 ball 의 앞에서 부터 6개의 요소를 출력한다. 
for(int i = 0; i <6; i++){ 
System.out.printf("ball[]%d=%d%n", i, ball[i]) ; 
} 

} 
} 
두번째는 최대값 , 최소값 구하는 것 입니다. 
package 삼월십오일; 

public class ArrayEx6 { 
public static void main(String args[]) { 
int []score = {79,88,91,33,100,55,95}; 

int max = score[0]; 
int min = score[0]; 

for(int i = 1; i < score.length; i++){ 
if(score[i] > max){ 
max= score[i]; 
}else if (score[i] < min ){ 
min  = score[i]; 
} 
} 
System.out.println("최소값 : " + min); 
System.out.println("최대값 : " + max); 
} 
}

오늘로써 4번째 공부한 내용을 작성하는날인데요 
오늘 연습한내용한번 정리해보겠습니다. 


첫번째로  메뉴 선택하는 소스 입니다. 

package 삼월십사일; 

import java.util.Scanner; 

public class FlowEx32 { 
public static void main(String args[] ){ 
int menu = 0; 
int num = 0; 

Scanner scanner = new Scanner(System.in); 

while (true) { 
System.out.println("(1) square"); 
System.out.println("(2) square root"); 
System.out.println("(3) log"); 
System.out.println("원하는 메뉴 (1~3 가지중에서 선택하세요 (종료 : 0)"); 

String tmp = scanner.nextLine(); //화면에서 입력받은 내용을 tmp 에 저장 
menu = Integer.parseInt(tmp); // 입력받은 문자열 (tmp) 를 숫자로 변환 

if(menu == 0) { 
System.out.println("프로그램을 종료합니다"); 
break; 
} else if (!( 1 <=menu && menu <=3)) { 
System.out.println("메뉴를 잘못선택하셨습니다. (종료 : 0 )"); 
 continue; 
} 
System.out.println("선택하신 메뉴는 " + menu +"입니다."); 


} 
} 
} 


두번째는 자신이 선택한 음식에대한 값을 지불하는 것입니다. 
package 삼월십사일; 

import java.util.Scanner; 

public class FlowEx34 { 
public static void main(String args[]) { 
int menu =0; 
int num  = 0; 

Scanner scanner = new Scanner (System.in); 

outer : 
while(true) { 
System.out.println("(1)  square"); 
System.out.println("(2) square root"); 
System.out.println("(3) log"); 
System.out.println("당신이 원하는 메뉴 (1~3) 까지 선택하세요 (종료 :0)"); 

String tmp = scanner.nextLine(); 
menu = Integer.parseInt(tmp); 

if(menu == 0) { 
System.out.println("프로그램을 종료합니다"); 
break; 
}else if (!(1<=menu && menu <= 3)){ 
System.out.println("메뉴를 잘못 선택하셨습니다."); 
continue; 
} 

for(;;) { 
System.out.println("계산할 값을 입력하세요 계산종료 :0. 전채종료 : 99"); 
tmp =scanner.nextLine(); 
num = Integer.parseInt(tmp); 

if(num ==0) 
break; 
if(num ==99) 
break outer; 

switch(menu) { 
case 1: 
System.out.println("result = "  + num * num); 
break; 
case 2 : 
System.out.println("result =" + Math.sqrt(num)); 
break; 
case 3 : 
System.out.println("result = " + Math.log(num)); 
break; 
} 
} 

} 

} 
} 

3번째는 음.. 오늘 배열을 들어가서 간단한 실습 ? 같은것들 입니다. 
package 삼월십사일; 

import java.util.Arrays; 

public class FlowEx35 { 
public static void main (String args[]) { 
int [] iArr1 = new int[10]; 
int [] iArr2 = new int [10]; 
/*int[] iArr3 = new int[] {100,95,80,70,60};*/ 
int [] iArr3 ={ 100,95,80,70,60}; 
char[] chArr = {'a', 'b', 'c', 'd'}; 

for(int i=0; i<iArr1.length; i++) { 
iArr1[i] = i +1; //1~에서 10 까지의 숫자를순서대로 배열에 넣는다. 

} 
for (int i=0; i<iArr2.length; i++) { 
iArr2[i] = (int) (Math.random()*10) +1; //1에서 ~10까지의 값을 배열에 저장 

} 
//배열에 저장된 값들을 출력한다, 
for(int i=0; i<iArr1.length; i++) { 
System.out.println(iArr1[i] + ","); 

} 
System.out.println(); 
System.out.println(Arrays.toString(iArr2)); 
System.out.println(Arrays.toString(iArr3)); 
System.out.println(Arrays.toString(chArr)); 
System.out.println(iArr3); 
System.out.println(chArr); 

} 
} 
이상 네번째 포스팅을  마치겠습니다 !!