IT is 아폴로딸기맛

 public class StaticDemo {
 public static void main(String[] args){
  Demo[] d = new Demo[5];
  for (int i = 0; i < d.length; i++) {
   d[i] = new Demo();
  }
  System.out.println(d[0].su);
  System.out.println(d[0].num);
 }
}
class Demo{
 int su;
 static int num;
 public Demo(){
  su++;
  num++;
 }
}

 public class StaticDemo1 {
 private static int su = method(); //static 멤버가 가장 먼저 메모리에 올리오기 때문에 main() 보다 method()가 먼저올라온다.
 public static void main(String[] args){
  System.out.println(su);  
 }
 private static int method(){
  System.out.println("i'm method");
  return 1000;
 }
}

public class StaticDemo2 {
 private int su;
 private static int num;
 public StaticDemo2(){
  System.out.println("나는 생성자");
  su=10;
 } 
 public static void main(String[] args) { 
  System.out.println("나는 메인");
 }
 static{
  System.out.println("나는 스태틱 초기화 블록");
  num = 100;
 }
}

 
public class NestedClassDemo {
 public static void main(String[] args) {
  Outer.Inner in = new Outer.Inner(); // Outer를 생성하지 않아도 static인 Inner에 접근가능.
  in.method1();
 }
}
class Outer{
 private int a;
 public int b;
 public Outer(){   //outer class constructor
  this.a = 5;   this.b = 10;
 }
 public static void method(){  //outer class method
  System.out.println("나는 스태틱");
 }
 static class Inner{
  private int c;
  public int d;
  public Inner(){
   this.c = 5;
   this.d = 10;
  }
  public void method1(){
   Outer out = new Outer();
   System.out.println("a ="+out.a); //static은 멤버에 접근 불가능. 주소를 가져야 하기때문에 생성자 필요
   method();  //static은 static에 바로 접근이 가능하다.
  }
  public static void method2(){}
 }
}

 public class MemberClassDemo {
 public static void main(String[] args) {
  Outer1 out = new Outer1();
  Outer1.Inner1 in = out.new Inner1();
 }
}
 class Outer1{
 private int a = 5;
 private static int b= 10;
  class Inner1{
   private int c = 100;
 //  public static int d =4; //static 변수 사용 할 수 없다.
   public void method(){
    System.out.println("a="+a);
    System.out.println("b="+b);
   }  
 }
}

 public class LocalClassDemo {
 public static void main(String[] args) {
  Outer2 out = new Outer2();
  out.method();
 }
}
class Outer2{
 private int a= 5;
 private static int b = 10;
 public void method(){
  int c = 100; //메소드의 지역변수
  final int c2 = 100;  //지역 상수
  class Inner2{
   private int d = 100;
   public Inner2(){
    System.out.println("나는 생성자");
   }
   public void display(){ 
    System.out.println(a+b+d);
   // System.out.println(c);  // 사용 불가
    System.out.println(c2); //사용가능
   }
  }
  Inner2 in = new Inner2(); // method() 내에서는 순차적으로 처리된다.(Inner2를 알고있어야 생성가능)
  in.display();
 }
}

 public class AnonymousClassDemo {
 public static void main(String[] args) {
  Super s = new Super(){
   public void display(){
    System.out.println("hello22");
   }
  };
  s.display();
 }
}
class Super{
 public void display(){
  System.out.println("hello");
 }
}

 public class EnumDemo {
 public static void main(String[] args) {
  for (Subjects s : Subjects.values()) {
   System.out.print(s+"-->");
   System.out.print(s.ordinal()+"==>"); //나열순서 출력
   System.out.print(s.get()+"==>");
   System.out.println(getInfo(s));
  }
 }
 static String getInfo(Subjects s){
  String info = null;
  switch(s){
  case JAVA : info ="열정" ; break;
  case JDBC : info ="Oracle" ; break;
  case JSP : info ="Javascript" ; break;
  case Android : info ="SmartPhone" ; break;
  case Project : info ="Idea" ; break;
  }
  return info;
 }
}

 public class AbstractDemo {
 public static void main(String[] args) {
  Jasic j = new Jasic();
  j.display();
 }
}

abstract class Bumo{  // abstract 메소드를 가지고있는 클래스 역시 absract로 선언.
 abstract void display(); // 바디를 정의하지않는 메소드는 앞에 abstract를 선언해야한다.
}
class Jasic extends Bumo{
 void display(){
  System.out.println("son");
 }
}

 public class CloneDemo {
 public static void main(String[] args) {
  Demo original = new Demo(5);
 // Demo copy = original; //주소복사
 // Demo copy = (Demo)original.clone(); //사용할 수 없음.
  Demo copy = original.copy();
 }
}
class Demo implements Cloneable{ // 멤버가 없는 인터페이스 이지만 상속 받을 경우 copy권한을 얻게된다.
 private int su;
 public Demo(int su){
  this.su = su;
 }
 public void set(int su){
  this.su = su;
 }
 public int get(){
  return this.su;
 }
 public Demo copy(){
  Object obj = null;
  try {
   obj=clone();
  } catch (CloneNotSupportedException e) {
   System.out.println("복제 실패함");
  }
  return (Demo)obj;
 } 
}

 javac–d D:\project\first Employee.java

 public class Resume {
 private int a =5;
 int b = 10; // default는 하위 클래스도 접근 불가능
 protected int c = 100;  //상속되며 하위 클래스를 통해 접근이 가능
 public int d =5000; //다른 패키지에서도 접근 가능.
}

import static java.lang.System.*;
import static java.lang.Math.*;  //or import static java.lang.Math.random    메소드뒤에 ()까지 쓰면 안된다.

public class StaticImportDemo {
 public static void main(String[] args) {
  out.println("hello,world");  //System 클래스를 import했기때문에 쓰지않아도 된다.
  int r = (int)(random()*10+1);
 }
}

 public class CastDemo {
 public static void main(String[] args) {
  Test td = new Test();
  Demo d = new Demo();
  td = (Test)d;  // 오류
 }
}

class Test{
 int su = 5;
}
class Demo{
 String name = "taehyung";
}

 public class CarCentar {
 public static void main(String[] args) {
  CarCentar cc = new CarCentar();
  Matiz m = new Matiz("마티즈");
  Carnival c = new Carnival("카니발");
  Sonata s = new Sonata("소나타");
  cc.repair(m);
 }
 void repair(Car c){   //부모형 변수에 자식들의 입력을 자동으로 받는다.
  if (c instanceof Sonata) { // 형태를 검사한다.
   System.out.println("현대차 ");
  }else if(c instanceof Matiz){
   System.out.println("대우차 ");
  }else if(c instanceof Carnival){
   System.out.println("기아차 ");
  }  
  System.out.println(c.getName()+" 수리완료!"); //들어온 형태에 상관없이 getName메소드를 사용할수있다.
 }
}

 private < default < protected < public

C++ 

Java 

C# 

부모

 Base

Super 

base 

 표현

  :

 extends 

 자식

 Derived

 다중상속

 sub

단일상속