ImageIcon 변경할아이콘 = new ImageIcon("이미지.png");

Image 변경할이미지 = 변경할아이콘.getImage();  //ImageIcon을 Image로 변환.

Image 변경된이미지 = 변경할이미지.getScaledInstance(가로, 세로, java.awt.Image.SCALE_SMOOTH);

ImageIcon 변경된아이콘 = new ImageIcon(변경된이미지); //Image로 ImageIcon 생성

[ 파일 입출력 : 스트림(Stream) ]

0, 1(bit) * 8 = 8bit = 1byte = 최소 코드 크기 = stream

 Reader - read() / Writer - write()

1. 스트림(byte) : read() / write() - 이미지, 동영상 등

2. 한글자(char) : read() / write() - 파일문서

3. Object형 - node(class) : read() / write() - 클래스를 통해서 자료 입출력

File : 디렉토리, 파일

c - createNewFile()
r - list()
u - renameTo(File dest)
d - delete()

Throwable: JVM에서 프로그램 실행할 때 프로그램이 중단되는 경우에 자동으로 생성되는 클래스 (Exception, Errors)
Errors는 막을 수 없으나 Exception은 예외처리를 할 수 있다.

예외처리 - Exception(1983년도의 C++부터 생김)란?
Run Time시에 외부에 의한 값에 의하여 프로그램이 중단할 때 생성되는 클래스를 말하며
생성되는 클래스를 try~catch 문을 이용해서 처리하는 것을 말한다.

ex) NumberFormatException N=new NumberFormatException();
 [형식]
 단일 try~catch
   try { 오류가 날만한 코드;
    } catch(해당 Exception 객체) {
     처리코드;
    } finally { }
    
 다중 try~catch
  하나의 try에 여러개의 catch 구문을 사용하여
  후손의 Exception부터 선조의 Exception 순으로 예외처리를 구현한다.
 
 중첩 try~catch
 
 throws(위임) : Exception이 발생한 메소드가 try~catch를 처리하지 않고 호출하는 쪽에서
       try~catch를 처리하도록 위임하는 키워드 해당 메소드 뒤에 선언한다.
 throw(생성) : 발생하고자 하는 Exception을 명시 생성하는 키워드
     Ex) throw new Exception(); 

interface(full추상화) : public(공개), ① 상수(필드), ② 추상메소드, ③ jdk 1.8 default 메소드
      : 다중 상속(구현), 인터페이스는 공개형(jdk 1.8부터)이다!
     
[형식]     
class C extends A implements B {}
class는 다중 상속은 안되지만 class My extends A implements B, D {}
         =class My extends A implements D, B {}
interpace는 다중 상속이 가능하다
interface C extends A,B {}
class D implements C {}

[문법]

인터페이스의 접근 지정자는 무조건 다 public! 나머지 접근지정자는 사용하지 않는다.
멤버 없이 혼자 사용한다.

interface ITest { 필드, 추상, default
     void Prn(); // public abstract Prn();
     int a=10; // public (static final-필드) int a=10;
     default String getName() { return "홍길동"; }
    }
    
public static void Prn()
{ // 필드 - 변수를 상수화(pi=3.14 등등)
 final int k=10; // 지역필드, 변수 k는 20으로 변경할 수 없다.
}

interface ITest {} -> ITest.java -> ITest.class 생성자를 가지지 않는다.

class Test {

 int a;
 My m;
 public Test() {
 
     m=new My();

      }
 
 }
}

<캐스팅 하는 법>

(다운캐스팅-명시형)

bouble d=90.9;
int a = (int)d;

(업캐스팅-묵시형)
     
int a=100;
double d=a;

Object -> Test

Object obj=null;
Test T1=new Test();
  obj=T1;
 
Test T2=(Test)obj;

ex)

public void Prn(Object obj) {

}

Object i1 = new Object();
Prn(01);
Test T1 = new Test();
Prn(T1);

<주말>

주말 공부 ^.^

1. 자바의 자료형(7)
2. 자바의 기본 구문
   if, for, while, do while, switch, 중첩 for 등
 봄, 여름, 가을, 겨울, 구구단 짜기
3. 메소드 - Static, void, return Type

Test {

 main() {}
 Prn(100); // 출력
 Prn(100,200); 출력
 Prn(90.9);
 Prn('A');
 int a= Disp(100)); 출력
 double d=disp(100.0);
 char ch=disp02('A');
 String str=disp03("연습이야");

 My.Prn(100); // 출력
 My.Prn(100,200); 출력
 My.Prn(90.9);
 U_Test.Prn('A');
 int a= U_Test.Disp(100)); 출력
 double d= U_Test.disp(100.0);
 char ch=U_Test.disp02('A');
 String str=disp03("연습이야");

}

1. 캡슐화 : 클래스 = 속성(필드, 변수) + 메시지(기능, 메소드)
 
 2. 상속 : 캡슐화로 지정된 단일 클래스의 기능을 확장해서 사용하는 구조를 말한다.

 ex) 5과목의 총평균을 구하고 싶다.
      Score(3) -> MyScore(2) + = 5과목
     
       공학용 계산기를 만들고 싶다.
     Calc (4칙) -> 추가....
    
 클래스 간의 상속 : extends
 인터페이스 간의 상속 : extends
 클래스가 인터페이스를 상속 : implements
 
 특징 : 자바의 클래스간의 상속은 단일 상속을 원칙으로 한다.
    다중상속은 인터페이스를 여러개 구현하면서 이루어진다.
    상속시에 선조클래스와 후손클래스의 관계로 지정되며 내부적으로 생성자를 통해서 구조를 이룬다.
 
 3. 다형성
 
  public class Vector <E>
   extends AbstractList <E>
    implements List <E>
     RandomAccess, Cloneable, Serializable
     
  [형식]
   접근제한자 class 후손클래스이름
     extends 선조클래스이름{}
     
  
     
 

다차원 배열(2차원)
 : 차원이 행, 열을 가진 구조를 가진 배열
 
 [형식]
  dataType [][] 변수 = { {,,,}, {,,,} };
  dataType []변수[] = { {,,,}, {,,,} };
  
  dataType [][]변수 = new dataType[요소의 크기][요소의 크기];
  dataType [][]변수 = new dataType[][] { {,,,}, {,,,} };
  
 ============================================================
 
 ex)     0   1   2
    -----------
   0  10, 20, 30
     -----------
   1  40, 50, 60
  
   2 줄의 3칸 : ar.length=2, ar[0].length=3, ar[1].length=3
       
   ar.length + ar[0].length + ar[1].length =? -> 8
 
   int [][] ar = { {10, 20, 30},
         {40, 50, 60} }; // 2, 3의 배열
         ar[행][열]
   10 -> ar[0][0]
   20 -> ar[0][1]
   30 -> ar[0][2]
   40 -> ar[1][0]
   50 -> ar[1][1]
   60 -> ar[1][2]
  
   0 -> 0, 1, 2
   1 -> 0, 1, 2
  
   for(int i=0; i<=1; i++) {
    for(int j=0; i<=2; j++) {
     System.out.println(ar[i][j]);
    }
   }
    
  
  
 ============================================================