#map

//Key, Value 구조로 데이터를 저장함
//Key를 기준으로 데티어를 찾으므로 Key가 중복되면 안됨
//순서x , 중복 x

HashMap<String, String> map = new HashMap<>();
map.put("num", "123");
map.put("name", "Tommy");

String val = map.get("num");
System.out.println(val);

val = map.get("name");
System.out.println(val);

//map 안에 모든 데이터를 꺼내서 출력하는 방법
        
Set<String> keys = map.keySet();
for(String key :keys ) {
    System.out.println(key+" : "+map.get(key));
}

Java Map 반복(Iteration)시키는 2가지 방법

위에서 사용한 방법과 비슷한 개념인

for( String key : map.keySet() ){
System.out.println( String.format("키 : %s, 값 : %s", key, map.get(key)) );
}


Iterator<String> keys = map.keySet().iterator();
while( keys.hasNext() ){
String key = keys.next();
System.out.println( String.format("키 : %s, 값 : %s", key, map.get(key)) );
}





'JAVA > JAVA 기본 문법' 카테고리의 다른 글

[JAVA] Set  (0) 2019.01.20
[JAVA]- 리스트 ArrayListTest, Vector  (0) 2019.01.20
[JAVA]-#Collection API  (0) 2019.01.20
[JAVA]- instance of 연산자  (0) 2019.01.20
[JAVA]-interface  (0) 2019.01.20

# Set

HashSet

중복 X ,순서 X

HashSet<String> set = new HashSet<>();
set.add("red");
set.add("yellow");
set.add("blue");
set.add("red");
set.add("white");

//전체 출력하는 방법
for(String color : set) {
    System.out.println(color);
}



결과 값:
red
blue
white
yellow

중복된 red 한번만 나오고 순서도 전혀 상관없이 나온다.
set.get() //사용 불가능 하다 순서가 없어서 인덱스로 가지고오지도 못함

#set.iterator(); 타입으로 한번에 출력 가능
Iterator<String> it =set.iterator();
    while(it.hasNext()) { //it 데이터가 있을때 까지 입력
        String color = it.next();
        System.out.println(color);
    }



TreeSet

정렬이 되어서 나옴  

TreeSet<String> set = new TreeSet<>();
set.add("red");
set.add("yellow");
set.add("blue");
set.add("red");
set.add("white");

결과값:
blue
red
white
yellow


'JAVA > JAVA 기본 문법' 카테고리의 다른 글

[JAVA]- Map  (0) 2019.01.20
[JAVA]- 리스트 ArrayListTest, Vector  (0) 2019.01.20
[JAVA]-#Collection API  (0) 2019.01.20
[JAVA]- instance of 연산자  (0) 2019.01.20
[JAVA]-interface  (0) 2019.01.20

#리스트

1) Vector

-객체들의 삽입, 삭제 검색 할 수 있는 컨테이너 클래스
-배열의 길이 제한 단점을 극복할 수 있다.
-삽입되는 객체의 수가 많아지면 자동으로 크기가 조절된다.
-벡터의 맨마지막이나 중간에 삽입이 가능하다.
-맨뒤에 추가 할때는 벡터 공간이 부족하면 자동으로 늘려준다.
(크기가 부족하면 현재 사이즈보다 2배씩 늘어난다, 따로 설정이 가능하다 얼마나 늘어나는지)
-중간에 삽입하면 뒤에 존재하던 객체는 뒤로 한칸씩 이동한다.
-임의의 위치에 있는 객체 삭제 : 객체 삭제후 한칸씩 앞으로 자동이동.
그래서 전체 크기가 동적으로 바뀐다. 잘 신경 쓰면서 삭제해야함
String, Integer, 등 다양한 타입의 객체가 삽입이 가능하다.

* 전체 크기가 동적으로 바뀐다는 매력적인 부분 *

기본 선언 구조
Vector<타입> v = new Vector<>(); //<>안에는 무조건 레퍼런스 변수가 들어가야한다.

출력문
for(String i :v2) {
        System.out.println(i);
    }

많이 쓰는 메소드
1. v.add("spring"); 추가 할때 사용
v.add(1,"fall") //키워 넣기
2. v.size(); 크기 반환
3. v.remove(1) //인덱스로 삭제
4. v.remove("summer") //내용으로 삭제
5. v.clear() //모든 데이터 삭제
6. v.isEmpty() // 비었는지 체크
7. v.capacity() //현재 용량을 반환



2) ArrayListTest //순서 O , 중복 O

ArrayList<Integer> scores = new ArrayList<>(); //<>안에는 무조건 레퍼런스 변수가 들어가야한다.
        scores.add(100);                       //<int> 기본형 타입이 못들어와서 Integer 이런식으로 사용한다.     
        scores.add(90);

for(int i=0; i<scores.size(); i++) {
        System.out.println(scores.get(i));
}

Vector랑 상속받는 내용이 비슷해서 같이 쓰면 된다. 근데 쓸려면 ArrayList 먼저 써라


ArrayList<File> playList;
    
public FileManagerImpl() { //생성자
    this.playList =new ArrayList<>();
}


.add(playList.get[i]) 이런식으로 더해서 사용


'JAVA > JAVA 기본 문법' 카테고리의 다른 글

[JAVA]- Map  (0) 2019.01.20
[JAVA] Set  (0) 2019.01.20
[JAVA]-#Collection API  (0) 2019.01.20
[JAVA]- instance of 연산자  (0) 2019.01.20
[JAVA]-interface  (0) 2019.01.20

#Collection API

Java

interface 와 interface 사이에도 extends가 된다.


☆많이씀 집합과 비슷 PYTHON 딕셔너리
ㅇㅇ | List | Set | Map |(KEY(중복 X), Value) 한 쌍
중복 | O | X | X |
순서 | O | X | X |
종류 | ArrayList | HashSet | HashMap |
종류 | Vector | | HashTabble |

Vector 보단 ArrayList 가 성능이 좋고 HashTabble 보단 HashMap 이 성능이 좋다.
새거가 성능이 짱짱 좋음

List 와 Set 은 상위클래스가 비슷해서 비슷한 메소드를 상속 받지만 Map은 좀 경우가 다르다
보통 Map이라고 붙어있는 메소드가 새로 만들어진거니까 그거 쓰면 성능이 좋다.


많이 사용하는 메소드 예시


package com.util;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class CollectionsTest {
    
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>(); //ArrayList 타입의 fruits 객체 생성
       
//add 함수로 하나하나 저장
 fruits.add("apple");
        fruits.add("orrange");
        fruits.add("banana");
        
//1.addAll()
        Collections.addAll(fruits,"apple","orange","banana"); //한번에 추가하는 방법
        
        //2.sort
        Collections.sort(fruits); //오름 차수 정렬 방법
        System.out.println(fruits.toString());
    
        //3.search
        Collections.sort(fruits);
        System.out.println(Collections.binarySearch(fruits, "banana")); // 찾으면 바로 인덱스 반환
        System.out.println(Collections.binarySearch(fruits, "grape")); //못 찾으면 마지막 인덱스에 - 붙여서 나옴
        
        //4.copy
        List list =new ArrayList();
        Collections.addAll(list, "one","two","three","four");
        Collections.copy(list,fruits);
        System.out.println(fruits.toString());
        
        //5.fill
        Collections.fill(list, "filled with dummy data"); //list안에 모든 데이터를
"filled with dummy data" 초기화 한다
        System.out.println(list.toString());
    
    }
    
}







'JAVA > JAVA 기본 문법' 카테고리의 다른 글

[JAVA] Set  (0) 2019.01.20
[JAVA]- 리스트 ArrayListTest, Vector  (0) 2019.01.20
[JAVA]- instance of 연산자  (0) 2019.01.20
[JAVA]-interface  (0) 2019.01.20
[JAVA]-abstract  (0) 2019.01.20

instance of 연산자 



instaceof


참조 변수가 instanceof로 형 변환 가능한 타입인지 연산,
형 변환이 가능하다면 true로 반환, 가능하지 못하면 false 반환 한다.

부모 클래스 참조 변수 instance of 연산

class A{

}

class B extends A{

}

public class instanceOf {

        public static void main(String[] args){
            A a = new A();
            if(a instanceof Object){
                System.out.println("오브젝트 클래스 형변환 가능");
            }
            if(a instanceof A) {
                System.out.println("자신클래스 형변환 가능");
            }
            if(a instanceof B) {
                System.out.println("자식클래스 형변환가능");
            }
        }
}

//부모 타입의 객체는
오브젝트 클래스로 형변환이 가능하고 자신 클래스로 형변환이 가능하다.
자식 클래스로는 형변환이 불가능함,

class A{

}

class B extends A{

}



public class instanceOf {

        public static void main(String[] args){
            B b = new B();
            if(b instanceof Object){
                System.out.println("오브젝트 클래스 형변환 가능");
            }
            if(b instanceof A) {
                System.out.println("부모클래스 형변환 가능");
            }
            if(b instanceof B) {
                System.out.println("자신클래스 형변환가능");
            }
        }
}

//자식 타입의 객체는
자식클래스에 포함된 범위 object, 부모클래스 모든 타입들로 형 변환 가능하다.



Tom t1 = new LittleTom(); //다형성으로 이런식의 객체가 생성되면
LittleTom l = (LittleTom) t1; //형 변환 가능
        
if(t1 instanceof Tom) {
        System.out.println("x "); //어쨌든 들어있는건 LittleTom() 객체 이기 때문에 부모타입으로는 당연히
형변환이 가능하고
    }
        
        
if(t1 instanceof LittleTom) {//자식 타입으로도 형변환이 가능하다.
        System.out.println("y ");
    }



 if(little instanceof Bill) { //*상속 관계가 없어서 비교가 안되면 instanceof 연산자도 사용을 못함 *
            System.out.println("instanceof Bill");
  }




'JAVA > JAVA 기본 문법' 카테고리의 다른 글

[JAVA]- 리스트 ArrayListTest, Vector  (0) 2019.01.20
[JAVA]-#Collection API  (0) 2019.01.20
[JAVA]-interface  (0) 2019.01.20
[JAVA]-abstract  (0) 2019.01.20
[JAVA]- static  (0) 2019.01.19

#interface


인터페이스는 상수와 구현되지 않은 메서드로만 구성된다. (추상 아닌 메소드는 못들어온다)
추상아닌 메소드와 섞어서 쓰고 싶으면 추상클래스로 만들면 된다.
abstract 클래스는 꼭 추상 메소드만 들어가는게 아니라 추상이 아닌 메소드도 들어갈 수 있지만
interface는 무조건 추상 메소드만 들어가기 때문이다 !!!



interface field 는 기본적으로 public static final 수식어가 붙는다

interface method 는 기본적으로 public, abstract 붙어있다.

때문에 interface의 추상 메소드를 재정의 할때는 무조건 public을 적어줘야 한다. 상속받은 메소드 보다 접근제한자가

커져야 하는데 그 전 메소드가 public 이기 때문이다 .

interface를 implements 하면 무조건 모든 추상메소드를 재정의해줘야한다.


package com.inter;
//interface : 내부에 추상메소드만 가지고 있는 객체. 미완성 객체. 객체 생성 불가능
public interface Myinterface {
    
    //인터페이스 안의 필드는 기본으로 static 변수이다, final이 붙어있다
//총 public staitc fianl 3개가 붙어있다
    int num=100; //static, final

    public abstract void go(); //추상 메소드인데 abstract붙여도 안붙여도 똑같다 interface로 시작했기 때문에
    void stop();//인터페이스 안에 메소드는 기본으로 public abstract 붙어있다.

}



package com.inter;
//interface IShape를 상속 받아 추상 메소드를 완성 시켜 놔야 됨.
public class ICircle implements IShape{ //상속받는 키워드가 implements로 바뀜
    
int r;
    
public ICircle(int r) {
        this.r = r;
    }

    @Override
    public double getArea() { //접근 지정자를 무조건 public 으로 바꿔야한다
//아까 따로 적어주진 않았지만 interface 안에 메소드는
//public 과 abstract 붙어있다.
        return r * r * Math.PI;
    }

    @Override
    public double getCircum() {
        return 2 * r * Math.PI;
    }   
}


//interface 를 implements 해도 상속이라고 봐도 괜찮다.
class Boat{}

public class ICircle extends Boat implements IShape{

}

ICircle 입장에서 보면 Boat{} 은 클래스를 상속 받는 개념이고 IShape 도 implements로 상속 받는 개념이여서 다중 상속이 가능하다
extends 상속은 하나만 받을 수 있지만 interface는 계속해서 추가해서 넣어도 되기 때문에 다중상속이 가능.

interface Seoul{}
class Boat{}

public class ICircle extends Boat implements IShape,Seoul{

}
다 상속 관계로 묶여있음


package com.inter;

public interface Calculator { //틀
    int add(int a, int b);
    int sub(int a, int b);
    int multi(int a, int b);
    int divide(int a, int b);
}


package com.inter;

public class CalculatorImpl implements Calculator {
    
    int a;
    int b;
    
    public CalculatorImpl(int a, int b) {
        this.a = a;
        this.b = b;
    }

    @Override
    public int add(int a, int b) {
        return a+b;
    }

    @Override
    public int sub(int a, int b) {
        // TODO Auto-generated method stub
        return a-b;
    }

    @Override
    public int multi(int a, int b) {
        // TODO Auto-generated method stub
        return a*b;
    }

    @Override
    public int divide(int a, int b) {
        // TODO Auto-generated method stub
        return a/b;
    }

    
}
//이런식으로 사용한다.


'JAVA > JAVA 기본 문법' 카테고리의 다른 글

[JAVA]-#Collection API  (0) 2019.01.20
[JAVA]- instance of 연산자  (0) 2019.01.20
[JAVA]-abstract  (0) 2019.01.20
[JAVA]- static  (0) 2019.01.19
[JAVA]- final  (0) 2019.01.19

#abstract

자식 클래스가 상속받은 추상 클래스를 완성시켜야한다.
추상클래스를 상속받을려면 무조건 오버라이딩을 해서 완성을 시키던가
아니면 자식 클래스도 추상클래스로 만들어야한다.
추상 메소드도 없는데 클래스를 추상클래스로 바꾸는 이유=> 객체 생성 못시키게 할려고


package com.abst;

//abstract class(추상 클래스): 클래스 내부에 추상 메소드가 있음. 미완성 클래스. 키워드
abstract를 붙여줌, 객체 생성 안됨

abstract class MyAbstract{
    //메소드 바디가 없는 메소드를 abstract method(추상 메소드), 미완성의 메소드, 키워드 abstract를 붙여줌
    public abstract void run();
    
    //concrete method(구상메소드): 바디가 있는 메소드.
    public void stop() {
        System.out.println("stop ! ");
    }
}

//자식 클래스에서 상속 받은 후에 부모가 가지고있던 추상메소드를 완성(구현)시켜야 함.

class MyAbstractChild extends MyAbstract{ //MyAbstractChild는 MyAbstract 타입이다.

    @Override //추상 메소드를 재정의 해야한다.
    public void run() {
        System.out.println("run run ~");    
    }
}

public class AbstractTest {
    public static void main(String[] args) {
        MyAbstractChild mc = new MyAbstractChild();
        mc.run();
    }
}


'JAVA > JAVA 기본 문법' 카테고리의 다른 글

[JAVA]- instance of 연산자  (0) 2019.01.20
[JAVA]-interface  (0) 2019.01.20
[JAVA]- static  (0) 2019.01.19
[JAVA]- final  (0) 2019.01.19
[JAVA]-Java Reference Type Casting  (0) 2019.01.19

#static


#static 붙어있는 메소드에서는 this, super 를 사용할 수 없다.
#Overriding 안됨

객체는 생성하지 않아도 되니까 클래스이름.(필드, 메소드) 이런식으로 사용가능.
*!!!!!클래스 이름으로!!!!!

field , method, { } block 앞에 사용이 가능하다.

1.소스 작성

2.컴파일
컴파일 시간에(실행 하기 전에) static 붙은 애들은 컴파일러가 class area에 만들어준다.
객체가 아무리 많아도 하나만 만들어진다. => 하나로 모든 객체가 공유를 한다.
static 여부에 따라서 생성 시간이 다르다.
그래서 실행할때 객체를 따로 생성 안해도 괜찮다.


3.실행
static이 없는 애들은 객체가 만들어 지는 순간 만들어지고 heap 영역에 사용된다
생성 시간과 장소 모두 다르다 static 타입과

package com.basic;

public class StaticTest {

    //1.static field. class area에 실행전 한개만 미리 만들어짐
    static int scount; //0 class 변수
    int count; //0 heap에 실행이 되면 객체마다 만들어짐. instance 변수
    //필드는 객체를 생성하면 기본값이 있다.
    
    public static void main(String[] args) {
        StaticTest s1 =new StaticTest();
        StaticTest s2 =new StaticTest();
        StaticTest s3 =new StaticTest();
        
        System.out.println(++s1.count+ "--" + ++s2.count +"--" + ++s3.count); //계속 1 출력
        System.out.println(++s1.scount+ "--" + ++s2.scount +"--" + ++s3.scount); //1,2,3 출력
        
    }

}


static method
객체 생성을 하지 않아도 됨


ex) StaticTest.java

public class StaticTest {
    //1.static field. class area에 실행전 한개만 미리 만들어짐, 객체 생성을 하지 않아도 됨
    static int scount; //0 class 변수
    int count; //0 heap에 실행이 되면 객체마다 만들어짐. instance 변수
    //필드는 객체를 생성하면 기본값이 있다.
    
    //2. static method
    public static void go() {
        System.out.println("gogogo~");
    }
}

HelloWorld.java
System.out.println(StaticTest.scount); //클래스 이름으로 static 변수 사용 가능
    StaticTest.go();




//3. static block :{ }

static 블럭은 main보다 먼저 사용된다.

static {
    System.out.println("static block-1");
}

main{

}

static {
    System.out.println("static block-2");
}

출력 결과
static block-1
static block-2
+main()





'JAVA > JAVA 기본 문법' 카테고리의 다른 글

[JAVA]-interface  (0) 2019.01.20
[JAVA]-abstract  (0) 2019.01.20
[JAVA]- final  (0) 2019.01.19
[JAVA]-Java Reference Type Casting  (0) 2019.01.19
[JAVA]-Java 상속  (0) 2019.01.19

#final

  • final class : 상속 받을 수 없음 (그 안에 있는 모든 method 는 건드리지 못함,
  • 따라서 메소드 안에 전부다 final 변수를 붙인것과 같은 효과를 낸다.)
  • final method : Override 할 수 없음 (final 붙어 있는 메소드는 오버라이딩을 하지 못한다.)
  • final varialbe : 상수로 정의, 값을 수정할 수 없다. 항상 같은 값을 가짐


package com.basic;

//final class 는 상속을 받을 수 없다.
final class MyFinal{
    public void test () {
        System.out.println("MyFinal-test");
    }
}

class YourFinal{
    //2.fianl method: overriding 이 안됨
    public final void test() {
        System.out.println("YourFinal-test()");
    }
}

public class FinalTest extends YourFinal {
    /*public final void test() { //overriding 안된다. final method 이기 때문에 재정의를 할 수 없다.
        System.out.println("YourFinal-test()");
    }*/
    
    //final variable:값을 수정할 수 없음
    final int max = 999;

    public static void main(String[] args) {    
        FinalTest f = new FinalTest();
        f.max=988; //값을 수정이 불가능하다.
    }

}


'JAVA > JAVA 기본 문법' 카테고리의 다른 글

[JAVA]-abstract  (0) 2019.01.20
[JAVA]- static  (0) 2019.01.19
[JAVA]-Java Reference Type Casting  (0) 2019.01.19
[JAVA]-Java 상속  (0) 2019.01.19
[JAVA]-Java Encapsulation  (0) 2019.01.19

Reference Type Casting

reference type

타입은 부모 클래스가 더 크다.
Parent x = new Child(); //자식을 만들어서 부모 타입으로 저장 "정답"
작은 값을 큰 타입에 저장하는건 형변환이 필요가 없다.

new Child(); 만든건 2층 짜리 구조이다
Parent x 1층짜리만 이용할게~
자리가 있을때 안쓰는경우

Child x = new Parent(); //부모를 만들어서 자식 타입으로 저장 error
new Parent(); 1층 짜리 구조를 만들고
Child x 난 1,2층 다 이용하고싶은데
자리가 없어서 error

class Parent{
protected void printName() {
        System.out.println("name:" + name);
    }
}

class Child extends Parent{
public void callSuper() {
     super.printName();
}
@Override
protected void printName() {
        //super.printName();
     System.out.println("name: Tomson");
}

}

//Child c = new Child();
Parent c = new Child(); //다형성 (생성된 객체를 가리키는 변수) 상속 관계가 있을때만 가능하다.
c.callSuper(); // 자식 클래스라서 접근을 못한다. Parent 타입이라서 자식 클래스에는 접근이 불가능하다
하지만 재정의된 메소드면 접근이 가능하다. 무조건 재정의된 메소드가 출력된다
c.printAddress();
c.printName() // @Override 때문에 자식 클래스 값이 출력이 되고
만약에 부모 클래스의 printName()를 출력하고 싶으면
자식 클래스 printName()에서 한번더 super.printName(); 를 이용해서 호출 할 수있도록 한다.

@Override
재정의 해뒀으면 자식 클래스에 접근이 가능하고 무조건 재정의된 메소드가 호출이 된다.


'JAVA > JAVA 기본 문법' 카테고리의 다른 글

[JAVA]- static  (0) 2019.01.19
[JAVA]- final  (0) 2019.01.19
[JAVA]-Java 상속  (0) 2019.01.19
[JAVA]-Java Encapsulation  (0) 2019.01.19
[JAVA]-Java #접근수식어 (접근지정자, 접근 제한자)  (0) 2019.01.19

# 상속 

원칙적으로 JAVA는 단일 상속만을 지원하지만 다중상속 하는 기능도 지원을 한다.

class A{
data;
method;
}

A클래스를 물려 받는 B클래스

extends : 상속 받기 위한 keyword
class B extends A{
}

A(부모) <- B(자식)
B가 A를 상속 받으면 UML 표기법 에서는 부모쪽으로 화살표가 향한다.

ex) is -an 관계가 성립하면 상속을 받을 수 있다
Lion is an Animal //Lion이 물려 받는다
사자는 동물의 특징을 가지고 있어서 사자는 동물이다
Apple is a Fruit //Apple 가 물려받는다
사과는 과일이다.
Tiger is an Animal //Tiger 가 물려받는다.
호랑이는 동물이다.

Generalization : 일반화 부모 클래스, super class, base class
-추출된 class의 공통적인 특성을 모아 super class로 정의할 수 있다.

Specialization : child class, subclass, derived class
-비슷한 속성과 기능을 가지고 있는 다른 class를 상속 받아 새로운 class를 정의할 수 있다.



#상속 기본 코드 구조

package com.inherit;


//부모 클래스, super class, base class, parent class

class Parent{
    String name="Tom"; //부모 클래스의 field
    String address="Seoul";
    
    public void printName() {
        System.out.println("name:"+name);
    }
    
    public void printAddress() {
        System.out.println("address:"+address);
    }
        
}

//자식 클래스, sub class, derived class, child class
public class Child extends Parent {
    int age=25; //자식 클래스의 field는 부모 클래스의 name, address 포함해서 총 3개
    public static void main(String[] args) {
        Child c = new Child();
//상속 관계가 존재하는, 자식 객체를 생성하면, 메모리에 부모 객체가 먼저 만들어 진다.
        때문에
        자식 객체를 생성할때는 부모 객체가 만들어 지도록 변수값을 넘겨야한다.
        *
그래서 자식 클래스 생성자를 만들때
super(변수) 이런식으로 먼저 부모 객체가 만들어 질 수 있도록 변수를 넘겨줘야 한다.




        *
        c.printName(); // 부모 클래스의 printName()
        c.printAddress();
    }

    //메소드는 main, 부모 클래스의 printName(); 부모 클래스의 printAddress();
    이렇게 가지고 있다.
}



#method overriding

부모한테서 물려 받은 메소드를 자식 클래스에 맞게 수정하는 일(오버라이딩)

!!method 이름, 리턴타입, 파라메터 타입 모두 동일해야함
접근지정자는 수정이 가능하다.
중요 !!!!! (부모가 가지고 있는 접근 지정자 보다 커지는건 괜찮은데 좁아지는건 안된다)
    
//부모 클래스, super class, base class, parent class
class Parent {
    String name = "Tom";
    String address = "Seoul";

    public void printName() {
        System.out.println("name:" + name);
    }

}

//자식 클래스, sub class, derived class, child class
public class Child extends Parent {
    int age = 25;

    //method overriding : 부모한테서 물려 받은 메소드를 자식 클래스에 맞게 수정하는 일
    public void printName() {//method 이름, 리턴타입, 파라메터 타입 모두 동일
        System.out.println("name: Tomson" );
    }

이렇게 해도 되고 밑에 처럼 source에서 자동으로 추가 해주면 된다.

    @Override :@annotation: 프로그램에 대한 설명이나 설정 사항 등을 나타냄
:오버라이딩된 메소드에서는 안붙이거나, 붙여도 상관이 없는데 오버라이딩이랑 상관없는
메소드에 붙이게 되면 오류가 나게된다
    
@Override
protected void printName() {
        System.out.println("name: Tomson");
    }

//자식이 부모메소드를 오버라이딩 하게 되면 게속 overriding된 메소드가 실행됨
//overriding 된 메소드 말고 부모 클래스의 메소드를 사용하고 싶으면 super 키워드를 이용해준다.

//super, this, --> static 메소드에서 사용이 불가능 하다.
그래서 main에서 사용이 불가능 하고 메소드를 하나 더 만들어서 사용한다.

public void callSuper() { //부모 클래스의 printName() 호출한다.
     super.printName();
    }


    public static void main(String[] args) {
        Child c = new Child();
        //상속 관계가 존재하는, 자식 객체를 생성하면, 메모리에 부모 객체가 먼저 만들어 진다.
//그래서 생성자를 찍어보면 부모생성자 부터 생성되고 자식 생성자가 만들어진다.
        c.printName(); //재정의된 자식 클래스의 printName() 호출
        c.printAddress(); //부모클래스의 printAddress //부모클래스에만 존재해서
        c.callSuper(); //부모 클래스의 printName()호출
    }

}


상속 예제 

부모 클래스 Parts
package com.computer2;

public class Parts {
    String maker;
    int price;

    public Parts(String maker, int price) { //부모 클래스 생성자
        this.maker = maker;
        this.price = price;
    }

    public void info() {
        System.out.println("maker :"+maker);
        System.out.println("price :"+price);    
    }
    
}


자식 클래스 Mouse
package com.computer2;

public class Mouse extends Parts { //Parts 클래스 상속
    boolean wireless;
    
    public Mouse(String maker, int price, boolean wireless) {
        super(maker,price); //부모의 생성자 호출
자식 클래스의 생성자가 호출될때 부모클래스의 생성자가 먼저 호출이 되기 때문에 부모 클래스가 생성자를 먼저 생성할
수 있도록 위와 같은 방식으로 값을 넘겨 주어야 한다.
무조건 super가 위에 있어야 오류가 안난다.
//this.maker=maker; //이렇게 값을 정하게 되면 자식 클래스의 생성자가 호출될때
//this.price=price; //부모 클래스의 생성자가 파라미터가 맞지 않기 때문에 생성되지가 못한다
this.wireless=wireless;

    }

    public boolean isWireless() {
        return wireless;
    }

    public void click() {
        System.out.println("마우스 클릭중 입니다");
    }
    
    public void scroll() {
        System.out.println("마우스 스크롤 중입니다");
    }
    
    @Override
    public void info() {
        super.info();
        System.out.println("마우스 wireless :"+wireless);  
    }
}


'JAVA > JAVA 기본 문법' 카테고리의 다른 글

[JAVA]- final  (0) 2019.01.19
[JAVA]-Java Reference Type Casting  (0) 2019.01.19
[JAVA]-Java Encapsulation  (0) 2019.01.19
[JAVA]-Java #접근수식어 (접근지정자, 접근 제한자)  (0) 2019.01.19
[JAVA]-Java #Method Overloading  (0) 2019.01.19

#Java Encapsulation



#Encapsulation

중요한 데이터나 복잡한 구현을 숨기고, 사용에 꼭 필요한 기능만을 공개하여 정의하는 기법

-중요하거나 상세한 구현은 숨긴다 (private)
-접근에 필요한 기능만을 public 하게 공개한다.
-set..(), get...()을 통해 접근한다
-data :private
-method:public
중요한 데이터의 은닉과 보고
복잡하고 상세한 구현을 숨김


#getter, setter

캡슐화의 사용 도구이다.
우선 사용하는 가장 큰 이유는 직접 접근이 불가능하게 하기 위함이다.

ex) cc.num =123 같은 경우에는 잘못된 데이터가 들어와도 거를수가 없다

getter와 setter 를 이용하면 if문으로 조건을 확인하고 수행할 수있다.
Source 에서 자동으로 추가가 가능하니까 그렇게 사용하면 된다.

public void setNum(int num) {
        if(num>0) {
            this.num = num; //0보다 큰 값만 num에 저장.
        }else {
            System.out.println("잘못된 값 입니다");
        }
        
    }

캡슐화를 하는 이유를 아는게 중요하다.
get , set 방식을 사용해도 데이터에 저장이 가능하고 접근이 가능하다.
그래도 캡슐화를 하는 이유는, 들어오는 데이터에 직접 접근하지 못하게 하기 위함인데 잘못입력된 값이 들어왔을때는 바로 저장하는게
아니라 한번 더 제한 조건을 줄수있도록 한다.








#접근수식어 (접근지정자, 접근 제한자)



#접근수식어 (접근지정자, 접근 제한자)

* public, > protected, > default(아무것도 없는거), > private *


Access/Modifier | Same class | Same package | Subclass | universe
public | YES | YES | YES | YES
protected | YES | YES | YES |
(default) | YES | YES | |
private | YES | | |

private - 같은 클래스 안에만

default - 같은 클래스, 같은 패키지 안에서 사용가능

protected - 같은 클래스, 같은 패키지, 상속 클래스 패키지가 달라도 상속 관계면 사용이 가능하다

public - 모든곳에서 가능


****class 접근 제한자는 public 와 default 만 사용이 가능하고, ****
****method, field 에는 4개다 사용이 가능하다. ****

#private : 오직 같은 클래스 안에서만 접근이 가능
접근 제어자가 private으로 설정되어 있다면 private이 붙은 변수, 메소드는 해당 클래스에서만 접근이 가능하다.

public class AccessModifier {
private String secret;
private String getSecret() {
return this.secret;
}
}

secret 변수와 getSecret()메소드는 AccessModifier 클래스에서만 접근이 가능하고 다른 클래스에서는 접근이 불가능하다.

#default : 다른 클래스도 괜찮, 근데 같은 패키지 안에는 있어야함
접근제어자를 별도로 설정하지 않는다면 접근제어자가 없는 변수, 메소드는 dafault 접근제어자가 되어 해당 패키지 내에서만 접근이 가능하다.

HouseKim.java

*package jump2java.house; //패키지가 동일

public class HouseKim {
String lastname = "kim"; //default 접근 제한자 같은 패키지에 다른 클래스에서도 사용이 가능하다
}

HousePark.java

*package jump2java.house; //패키지가 동일

public class HousePark {
String lastname = "park";

public static void main(String[] args) {
HouseKim kim = new HouseKim();
System.out.println(kim.lastname); //default 지정자인 lastname에 접근이 가능하다.
}
}

위의 예제를 보면 같은 패키지 안에 있는 두 클래스에서 default 접근제한자를 가지고 있으면 접근이 가능하다.

#protected 같은 패키지 안에 있으면 무조건 접근이 가능하고, 또 다른 패키지 라도 상속 받은 클래스가 있으면
접근이 가능하다

HousePark.java

*package jump2java.house;
public class HousePark {
protected String lastname = "park";
}



EungYongPark.java

*package jump2java.house.person;
import house.HousePark; // 패키지가 다를 경우 import 해줘야 한다.             
// 다른 패키지인 경우에 import 해서 사용해야하는데 protect 접근 제한자는 상속받은 경우에 다른
클래스에서 접근이 가능하다.

public class EungYongPark extends HousePark { //상속 받은 경우에 접근이 가능하다
public static void main(String[] args) {
EungYongPark eyp = new EungYongPark();
System.out.println(eyp.lastname);
}
}

패키지가 다른데 HousePark 클래스에 접근이 가능한 이유는
EungYongPark 클래스가 HousePark 클래스를 상속 받기 때문이다.
그래서 protected 접근제한자도 접근이 가능하다.

#public
import 로 패키지를 가지고 올 수 있으면 어떤 변수, 메소드 전부다 접근이 가능하다.




'JAVA > JAVA 기본 문법' 카테고리의 다른 글

[JAVA]-Java 상속  (0) 2019.01.19
[JAVA]-Java Encapsulation  (0) 2019.01.19
[JAVA]-Java #Method Overloading  (0) 2019.01.19
[JAVA]-Java 클래스 생성자  (0) 2019.01.19
[JAVA]-Java 클래스  (0) 2019.01.19

Java #Method Overloading



#Method Overloading

같거나 비슷한 일을 하는 메서드 구현 시에 메서드의 이름을 같게 정의하여 사용을 편하게 한다.
* 메서드명은 같고 파라메터는 반드시 달라야한다
* 제한자, return-type은 상관없음

조건을 잘 구분하는게 중요하다.

****메서드 이름은 무조건 통일해야하고 파라메터는 달라야한다, 접근제한자, 리턴타입은 상관이 없다.*******

class OverloadTest{
public String print(String x, String y){
return x+"와"+y+"를 출력합니다.";
}

public String print(String x, int y){
return x+"와"+y+"를 출력합니다.";
}

public String print(int x, int y){
return x+"와"+y+"를 출력합니다.";
}
}

메서드 명이 다 print() 로 같지만 하는일이 파라메터 마다 다르다.
만약 main 에서

OverloadTest ol = new OverloadTest();

ol.print(String a, String b)
이런식으로 호출을 하면 파라메터 타입이 String String 타입인

public String print(String x, String y){
return x+"와"+y+"를 출력합니다.";
}

메서드가 호출되는 방식이다.






'JAVA > JAVA 기본 문법' 카테고리의 다른 글

[JAVA]-Java Encapsulation  (0) 2019.01.19
[JAVA]-Java #접근수식어 (접근지정자, 접근 제한자)  (0) 2019.01.19
[JAVA]-Java 클래스 생성자  (0) 2019.01.19
[JAVA]-Java 클래스  (0) 2019.01.19
[JAVA]-Java 다차원 Array  (0) 2019.01.19


Java 클래스 생성자

생성자는 무조건!!! 클래스와 이름이 같아야 한다 void 타입도 적으면 안돼


#한번에 생성자 생성 하는 방법
Source => Generate Constructor field 선택



#생성자

생성자 메소드 이름이 클래스와 같아야한다.
리턴 타입이 반드시 없어야 한다. (*void도 없어야한다.)

public class Car {
Car(){ // default 생성자 : parameter가 없음
default 생성자의 접근 제한자는 클래스 선언 형태를 따른다.
             이경우에는 Car 클래스가 public 이니까 생성자도 public이다.

}
Car(int a){ //파라미터 있는 생성자 조건 2개만 만족하면 무조건 생성자
생성자 메소드 이름이 클래스와 같아야하고, 리턴 타입이 없어야한다
}
void Car(){ //리턴타입(void 포함) 있으면 생성자가 아니다.

}
car(){ //대소문자 달라도 생성자 아니다

}
}

초기화 작업을 수행한다.
객체를 생성하면 알아서 호출된다.
만약 생성자를 적지 않아도 컴파일러가 default 생성자를 자동으로 하나 넣어준다.
생성자를 계속 추가하면서 만들 수 있다.


//default 생성자가 아닌경우에는

//parameter 있는 생성자
    Car(int num){
        this.num=num; //prarmether가 우선순위가 잴 높아서 그냥 적으면 되는데 field 는 this 로 구분을 해주어야 한다.
    }

Car(int number){
     num=number; //이름을 바꾸면 this를 안적어도 괜찮지만 변수 이름이 많아지면 복잡해지기 때문에 보통은
this를 붙여서 맞춰 쓴다.
    }


//객체 생성

Car c1 = new Car(1234);



#생성자 기본 구조

//default 생성자
int num;
String model;
String owneer;


    public Car() { //2가지 조건이 다 충족한다 default 생성자
        System.out.println("Car 생성자");
    }

    // parameter 있는 생성자
    public Car(int num) {
        this.num = num; //this.num <- 클래스 안에 있는 num을 지정하고 싶어서 사용한다.
    }
//prarmether가 우선순위가 잴 높아서 그냥 적으면 되는데 field 는 this 로 구분을 해주어야 한다.

this 변수를 사용하기 싫으면
Car(int number){
    num=number; //이름을 바꾸면 this를 안적어도 괜찮지만 변수 이름이 많아지면 복잡해지기 때문에
보통은 this를 붙여서 맞춰 쓴다.
}


    public Car(int num, String model) {
        this.num = num;
        this.model = model;
    }

    public Car(int num, String model, String owner) {
        this.num = num;
        this.model = model;
        this.owner = owner;
    }

Car c1=new Car(); //default 생성자가 호출된다.
    Car c2=new Car(4); // public Car(int num) 생성자가 호출된다. 그래서 4을 넘겨주면 4가 num에 저장된다.
    Car c3=new Car(5,"BMW"); // public Car(int num, String model) 생성자가 호출된다
    Car c4=new Car(6,"HUN","MIN"); //쓰고 싶은 생성자를 이용한다.



#생성자가 여러개 있는 경우에 하는 일이 겹칠때 this() 메소드

this():생성자 안에서만 사용이 가능하다. =>생성자안에서 사용되면서 다른 생성자를 호출함


int num; String model;

String owner;


Car() {
        //num=0;
this(0); //parameter 개수랑 타입을 보고 어느 생성자를 호출할지 결정한다.
    
    }


public Car(int num) {
        //this.num = num;
this(num,"xyz"); //모자른 parameter 개수를 채우기 위해 쓰레기값 넣어줌
}


    public Car(int num, String model) {
        //this.num = num;
        //this.model = model;
this(num,model,"anonymous");
    }


    public Car(int num, String model, String owner) {
        this.num = num;
        this.model = model;
        this.owner = owner;
    }

//이런 경우에 num이 계속 겹친다.
그럼 똑같은 일을 하는 다른 생성자 한테 일을 넘긴다



=====================================================================================================

public class CarUser{

Car c1 = new Car();
//Car c1 =new Car(1);
//Car c2 =
    System.out.println(c1.num +" "+ c1.model+" "+c1.owner);

만약 이런식으로 호출을 하면
default 생성자에서 this() 함수로 같은 일을 하는 생성자가 있는지 찾아본다.

public Car(int num) {
       //this.num = num;
this(num,"xyz"); //모자른 parameter 개수를 채우기 위해 쓰레기값 넣어줌
}

그럼 이런식으로 기본생성자 일도 하면서 num 변수에 값을 설정하는 생성자에게 일을 넘긴다
....


이런식으로 계속 넘기다보면 더 넘길수 없는 생성자가 나오는데 이제 그 생성자를 불러서 값을 초기화 시켜준다

public Car(int num, String model, String owner) {
this.num = num;
this.model = model;
this.owner = owner;

}

}

출력값 : 0 xyz anonymous







Class 

보통은 jdk 에서 제공되는 기본 클래스(라이브러리) 를 많이 사용한다.

class vs object (객체)
붕어빵 찍어내는 틀 vs 붕어빵
설계 vs 생성
1개 vs 여러개


기본 구조
[modifiers] class [class_identifer]{
[modifiers] data_type attribute_identifier;
[modifiers] class_identifir(...){...}
[modifiers] return_type method_identifier
([arguments]){
method_code_block
...
}
}

class_identifier : 키워드 x, 숫자 시작 x
: 특수 문자는 _, $ 두개만 가능
: 첫 글자는 보통 대문자, 명사형
: 보통 길이 제한은 없다고 말한다.

class : -data (재료) -field, 속성, 등등.. 이라고 부른다.
-method (동작)

ex) Car : 자동차 창문, 바퀴, 색, .... (설계자 마음대로라서 정답은 없음)
: 달리고, 멈추고, (동작, 행위, 일)



Class 기본 예제


ex)
Car 클래스
package com.ssafy;
public class Car {
//field, data, property, instance, variable, attribute, global variable 등등 다양한 용어가 있다.
    int num;
    String model; //전역 변수
    String owner;
    // 전역변수는 딱히 초기화를 안해줘도 괜찮다, 객체를 생성하면 default 값이 들어간다


#main() 안에 있는 변수들은 꼭 초기화를 시켜줘야 한다.
class 안에 변수를 만들면 전역 변수로 설정 되어 초기화를 시켜줄 필요가 없지만    
main()안에는 꼭 초기화를 시켜줘야한다. main 안에서는 지역 변수이기 때문에

    
    //method
    public void run() {
        int number ; //local variable 기본값이 없어서 초기화가 필요하다.
        System.out.println("run method...");
    }
    
    public void stop() {
        System.out.println("stop method...");
    }
    
    public void info() {
        System.out.println("num:"+num);
        System.out.println("model:"+model);
        System.out.println("owner:"+owner);
    }
}

CarUser 클래스 (main 메소드가 있어서 실행이 가능)

package com.ssafy;
public class CarUser {

    public static void main(String[] args) {
        //Car 객체 생성
        Car c1=new Car(); //객체를 생성해야 그 클래스의 필드값, 메소드를 사용할 수 있다.
        c1.model="BMW";
        c1.num=1234;
        c1.owner="tom";

        //*객체 생성을 하면 field는 기본값을 가지고 있음.* -> 참조형 변수는 생성될때 기본 값이 주어지기 때문에
        c2.info();
        System.out.println();
//num:0 기본값
//model:null 기본값
//owner:null 기본값


        c1.run();
        c1.stop();
        c1.info();
    }

}




'JAVA > JAVA 기본 문법' 카테고리의 다른 글

[JAVA]-Java #Method Overloading  (0) 2019.01.19
[JAVA]-Java 클래스 생성자  (0) 2019.01.19
[JAVA]-Java 다차원 Array  (0) 2019.01.19
[JAVA]-Java Operation(메소드)  (0) 2019.01.19
[JAVA]-Java 1차원 배열  (0) 2019.01.19

#다차원 Array

같은 타입의 많은 데이터를 행과 열을 이용하여 저장하기 위해 사용


*선언

    int[][] su;

    int su[][];


*생성

    su=new int[5][3]; //5행(가로) 3열(세로) 


*값 할당

    su[0][0]=10;


#2차원 배열의 length

arr[5][3]

arr.length -> (행) 길이는 5

arr[x].length (열) 길이는 3


for(int i=0; i<multi.length; i++) {

for(int j=0; j<multi[i].length ; j++) {

System.out.print(multi[i][j]+"\t");

}

System.out.println();

}


이런식으로 배열 입력, 출력 가능


#행 마다 length 가 다른 배열도 선언이 가능하다

int[][] some = new int[3][];

some[0] = new int[3];

some[1] = new int[5];

some[2] = new int[7];

'JAVA > JAVA 기본 문법' 카테고리의 다른 글

[JAVA]-Java 클래스 생성자  (0) 2019.01.19
[JAVA]-Java 클래스  (0) 2019.01.19
[JAVA]-Java Operation(메소드)  (0) 2019.01.19
[JAVA]-Java 1차원 배열  (0) 2019.01.19
[JAVA]-Java 반복문  (0) 2019.01.19

#Operation(메소드)


기본 구조

public static return_tyep method_name(parameter list)

{

    //수행할 문장들

}


메소드의 종류는 총 4가지가 있다.


1. 입력과 출력이 모두 있는 메소드

public int sum(int a, int b) { //파라메타로 a,b 모두 입력 받고 

    return a+b; // 리턴해준다.

}

Test myTest = new Test(); //메소드 사용할려면 객체 생성해야한다. myTest 클래스의 객체를 만들고 메소드 호출

int c = myTest.sum(a, b);

*return 타입이 int라서 int로 받아야한다. 


2. 입력과 출력이 모두 없는 메소드

public void say() {

    System.out.println("Hi");

}


Test myTest = new Test();

myTest.say();


3. 입력은 없고 리턴은 있는 메소드

public String say() {

    return "Hi";

}


Test myTest = new Test();

String a = myTest.say();

System.out.println(a);


4. 입력은 있고 리턴은 없는 메소드

public void sum(int a, int b) {

    System.out.println(a+"과 "+b+"의 합은 "+(a+b)+"입니다.");

}


리턴값이 없는 메소드는 명시적으로 리턴타입 부분에 void라고 표기

Test myTest = new Test();

myTest.sum(3, 4);



#배열 타입 메소드 활용하기

static void total(int[] data) {

int sum=0;

for(int i=0; i<data.length; i++) {

sum+=data[i];

}

    System.out.println(sum);

}

int[] data = {10,28,30,50,90,123,450,66,67};

total(data);


#리턴 타입이 배열인 경우

static int[] makeArray(int len) {

int code[]=new int[len];

return code;

}


int[] data1;

data1=makeArray(3);

for(int i=0; i<data1.length; i++) {

System.out.println(data1[i]);

}



#return의 또 다른 쓰임새!

특별한 경우에 메소드를 빠져나가기를 원할 때 return만 단독으로 써서 메소드를 즉시 빠져 나갈 수 있다.


public void say_nick(String nick) {

    if ("fool".equals(nick)) {

        return;

    }

    System.out.println("나의 별명은 "+nick+" 입니다.");

}


만약 nick의 입력값이 "fool" 이면 바로 메소드를 빠져나가게 하고 싶어서 return 을 써준다.

이 방법은 리턴자료형이 void형인 메소드만 해당된다. 리턴자료형이 명시되어 있는 메소드에서 return 문만작성하면 컴파일 오류가 발생

void // 리턴이 없는 메소드에 형식적으로 쓰는건데

그떄 return 을 써버리면 강제적으로 메소드를 종료시킨다.



'JAVA > JAVA 기본 문법' 카테고리의 다른 글

[JAVA]-Java 클래스  (0) 2019.01.19
[JAVA]-Java 다차원 Array  (0) 2019.01.19
[JAVA]-Java 1차원 배열  (0) 2019.01.19
[JAVA]-Java 반복문  (0) 2019.01.19
[JAVA]-Java 조건문  (0) 2019.01.19

Java 배열

Java에서 배열은 객체이다. 그러므로 객체를 생성하여 사용하듯이 배열도 객체 생성하여 사용해야한다.


기본 선언문 

int[] su = new int[7];


1. 배열 선언 

int[] score;

int score2[];

int[] a,b;

int[] x,y[],z[]; //x 1차원 , y 2차원, z 2차원


2. 배열 생성

score = new int[3]; //배열도 객체이기 때문에 new로 생성해주고 사용한다, 생성 할때 사이즈를 줘야한다. 

2-1. 선언과 생성을 동시에    

            int score[] = {50,90,88,100,50};

 int code[]= new int[] {2,4,5,6,7}


3. 배열 사용

score[0]=123;

score[1]=300;

score[2]=789;  

//배열을 만든 후에 값을 대입하고 사용 

        

for(int i=0; i<score.length; i++) {

System.out.println(score[i]);

}

for(int i:score ) {

System.out.println(i);

}//인덱스 위치를 알기는 어렵다

보통 이렇게 많이 사용한다.


#배열의 크기 

int len=score.length; 

length 함수를 이용해서 배열의 크기를 반환 받을 수 있다.


#배열의 초기값

int codes[]= new int[1000]; // 디폴트값 0 대입 

boolean flags[] = new boolean[20]; //디폴트값 false

double points[] =new double[300]; //디폴트값 0.0

String names[] =new String[500];//참조형 타입은 기본값이 null 예외 처리를 잘 해줘야 한다. 

배열이 아닌 일반 타입들은 초기값이 없다.

System.out.println(names[567]);


#배열 전체 초기화(Arrays.fill)

import java.util.Arrays;

int codes[]= new int[1000];

Arrays.fill(codes, 1);



#args 배열 사용법

public static void main(String[] args)

실행할 때 마다 값을 다르게 하고싶을때 사용한다.

사용하는 방법


public static void main(String[] args) {

for(String a:args) {

System.out.println(a);

}

}


Run->Run Configuration -> Arguments -> 값 설정 


#배열 복사하기 - System.arraycopy()

Java의 한번 설정된 배열은 사이즈 조절이 되지 않는다.

그래서 더 큰 크기의 배열을 만들어 복사를 한다


System.arraycopy(소스배열, 시작위치, 목적배열, 시작위치, 길이)


class CopyArray{

    public static void main(String[] args){

        int[] soArray={11,22,33,44};

        int[] tarArray=new int[10];

        System.arraycopy(soArray,0,tarArray,0,soArray.length);

    }


}


'JAVA > JAVA 기본 문법' 카테고리의 다른 글

[JAVA]-Java 다차원 Array  (0) 2019.01.19
[JAVA]-Java Operation(메소드)  (0) 2019.01.19
[JAVA]-Java 반복문  (0) 2019.01.19
[JAVA]-Java 조건문  (0) 2019.01.19
[JAVA]-Java 연산자  (0) 2019.01.19

Java 반복문

기존 썼던 반복문이랑 똑같이 쓰면되는데 추가된 반복문이 있다.

for -each

for(type 변수: 데이터들 ){

//반복 처리 문장

}

int sum = 0;

int su[] = {24,6,7,36,36,65,245,56,3,64};

for ( int s : su) {

        sum+=s;

}

System.out.println(sum);

맨날 forforforofoororrr만 쓰지말고 ㅠ_ㅠ 

! while 쓰는 연습좀 하자 

반복문에서 사용되는 문장들

break;

반복중인 루프를 벗어나기 위해 사용한다.


continue;

아랫부분의 문장들을 무시하고, 반복중인 루프를 계속 처리한다.


label:

//

//

break label:

다중 루프문을 처리하고 있을 경우 지정된 label의 루프를 벗어난다.




'JAVA > JAVA 기본 문법' 카테고리의 다른 글

[JAVA]-Java Operation(메소드)  (0) 2019.01.19
[JAVA]-Java 1차원 배열  (0) 2019.01.19
[JAVA]-Java 조건문  (0) 2019.01.19
[JAVA]-Java 연산자  (0) 2019.01.19
[JAVA]-Java Data Types, 형 변환  (0) 2019.01.19

+ Recent posts