package com.util;

import java.awt.image.SinglePixelPackedSampleModel;

//Singleton pattern 이 적용된 클래스
//객체 생성을 한번만 수행하고 그 이후로는 생성된 객체 공유
//singleton pattern 객체 조건

//private, static field : 필드는 static 이고 private 이여야 한다.
//생성자 private 이여야 한다. (외부에서 객체 생성이 불가능함)
//getInstance():객체를 생성해서 리턴해 주는 static method가 꼭 있어야 한다.

public class SingletonObject {

    private static SingletonObject instance; //자기 자신 타입 SingletonObject 인 필드 생성
    
    private SingletonObject() { //생성자는 private 이여야 한다 (외부에서 객체 생성이 불가능하게)
        
    }
    
    public static SingletonObject getInstance() { //객체는 getInstance() 통해서만 생성 가능하게 한다
        if(instance == null) {
            instance = new SingletonObject(); // 이미 만들어진 instance 가 없으면 객체를 생성하고
있으면 바로 return 해준다
        }
        return instance;
    }
    
    public void print() {
        System.out.println("hello, print!");
    }
    
}

생성자를 접근을 못하니까 바로 메소드를 불러서 객체를 생성한다.
package com.util;

public class SingletonObjectUser {

    public static void main(String[] args) {
        SingletonObject o1 = SingletonObject.getInstance(); //생성자를 메소드로 불러서 객체 생성
        SingletonObject o2 = SingletonObject.getInstance();
        SingletonObject o3 = SingletonObject.getInstance();
        
        o1.print();
        o2.print();
        o3.print();
        
        System.out.println(o1==o2);
        System.out.println(o3==o2);
    } 
}



#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

타입상속 : 추상클래스, interface

부모 클래스에서 추상(미완성) 메소드를 자식에게 물려줌



타입 상속
여러 종류의 객체들을 하나의 배열에 넣고 핸들링 하면 좀 편하게 사용 할 수 있다.

ex) 상속 관계로 묶지 않으면 여러 클래스에서 객체를 만들고 list 에 쓸려면 각각 만들어야하는데

큰타입(부모클래스)로 만들면 부모클래스 타입으로 배열을 만들고 객체에 집어 넣을 수 있다


Shape (추상 클래스)
getArea() - 추상 메소드
getCircum() - 추상 메소드
Circle Rect TriAngle
getArea() getArea() getArea()
getCircum() getCircum() getCircum()

자식 클래스가 상속받은 추상 클래스를 완성시켜야한다.

추상클래스를 상속받을려면 무조건 오버라이딩을 해서 완성을 시키던가

아니면 자식 클래스도 추상클래스로 만들어야한다.

추상 메소드도 없는데 클래스를 추상클래스로 바꾸는 이유=> 객체 생성 못시키게 할려고



#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

#Wrapper class

Java의 기본형 데이터 타입을 객체화 시키는 클래스들이다.
Java 5.0 버전 이상에서 자동으로 type 변경 기능을 제공한다.

int num = 99; // 기본형 입니다.
//기본형 데이터를 참조형(클래스)로 바꿈
Integer num2 = new Integer(num);
num2++; //객체라서 더하기가 안되는데, 내부에서 auto-unboxing이 일어나고 연산을 하고
다시 auto-boxing이 일어남
System.out.println(num2);   

int 타입으로 명시적으로 박스를 풀수도있다.
int x =num2.intValue();



#StringBuilder

문자열을 편집하여 사용하고자 할 경우에 사용하는 클래스이다.
String의 수정을 편리하게 한다.
StringBuffer 클래스를 개선하여 성능을 향상한 클래스이다.

ex)
StringBuilder sb =new StringBuilder("mylimeorange");ㅕ
sb.append("hello"); //String class 에서 concat() 함수와 비슷하다.
System.out.println(sb); //sb.toString() 가 호출된다.
=>mylimeorangehello

sb.setLength(5); //sb의 length를 강제로 5로 출력한다.
System.out.println(sb);
=>mylim

sb.insert(2, 'q'); //인덱스가 2번인 위치에 q를 끼워 넣어라
System.out.println(sb);
=>myqlim

sb.reverse(); //뒤집어 준다.
System.out.println(sb);


String 클래스와 차이점은
따로 저장을 안해도 변화가 바로바로 반영이 된다.






#String 클래스

String s = "mylimeorange";
String t = new String("mylimeorange");
String x = "mylimeorange";

new로 만들면 heap에 객체가 생성된다.
s 처럼 값을 그냥 주면 class area 안에 있는 Constant Pool 에 저장한다.


if(s == t) { //주소 비교하는거라 false
    System.out.println("s==t"); //false
}


if(s.equals(t)) { //내용 비교 String 에서 equals는 내용 비교이다. 기본 Object 에서는 주소비교이다 (재정의 한거임 )
    System.out.println("s.equals(t)"); //true
}

if(s==x) { //주소를 비교하는데 constant pool 에 같은 "mylimeorange" 을 가리키고 있다.
    System.out.println("s==x");
}
String 클래스는 원본의 값을 바꿀수 없다.


s.toUpperCase();
System.out.println(s); //대문자로 바꿔라.
String은 값이 하나 들어가면 원본데이터를 바꿀수가 없다

String a=s.toUpperCase();
System.out.println(a);
이런식으로 따로 저장해서 따로 생성된 값을 사용해야한다.

s=s+"gogogo";
System.out.println(s);
s 는 mylimeorangegogogo 를 가리키게 된다.


#String 메소드

String s = "mylimeorange";
s.length() -문자열의 길이를 출력해주는
s.charAt(3) -인덱스가 3번인 글자 하나
s.isEmpty() - 비어있니?
s.startsWith("m")- m으로 시작하니?
s.endsWith("e") -e로 끝나니?
s.substring(2,6) - 문자열 분할 2번 인덱스 부터 5번 인덱스 까지
s.substring(7) - 7번 인덱스 부터 끝까지
s.contains("r") - 문자열 r 을 포함하니?


#concat()

문자열 뒤에 추가시켜주는 경우
String q =s.concat("hello");
//s.concat("hello");
System.out.println(q);




#equals(Object o) : boolean - 객체의 내용을 비교 할 수 있도록 구현한다.

Truck t1 = new Truck(4,"abc",2019);
Truck t2 = new Truck(4,"abc",2019);
System.out.println(t1==t2); //주소 비교
System.out.println(t1.equals(t2)); //내용 비교 (밑에서 오버라이딩 해서 내용비교가 된다,
재정의 안해주면 주소비교라서 false)

둘다 false 가 나오는데
== 연산자의 경우 주소를 비교하는거니까 무조건 false 가 나오는데
equals()는 기본 object에서 주는 클래스로 들어가 보면 == 연산자로 비교하고 있다
그래서 재 정의해서 주소값 말고 내용을 비교 할 수 있도록 사용해야한다.

@Override
public boolean equals(Object obj) {
    if(obj !=null && obj instanceof Truck) {
        Truck t = (Truck)obj;
        if(num == t.num && model.equals(t.model) && year ==t.year) {
         return true;
            }   
        }
    return false;
}


//객체 비교하면 주소값이 비교가 되서 재정의 하지 않으면 equals로 내용을 비교할 수가 없다..

String class equals 는 내용 비교하는거로 바꿔서 그냥 사용할 수 있다.



#toString

package com.ssafy;

public class Truck {
    int num;
    String model;
    int year;
    
    public static void main(String[] args) {
        Truck t = new Truck(4,"abc",13);
        System.out.println(t); //toString() 호출
        System.out.println(t.toString());
    }

    public Truck(int num, String model, int year) { //생성자
        this.num = num;
        this.model = model;
        this.year = year;
    }

    
    @Override
    public String toString() {
        return "hello"; //오버라이딩 이름, 리턴타입, 파라메터, 모두 같아야한다,
// 접근 지정자가 커지는건 가능하지만 작아지는건 불가능하다.
    }


}

System.out.println(t); //toString() 호출
객체만 넣어줘도 재 정의된 toString() 이 호출된다.

@Override

public String toString() {
    return "hello";
}

이거 재정의 안하면 com.ssafy.Truck@15db9742 이런식으로 주소 값만 출력된다.
// 많이 봤지..? 그냥 처음부터 재정의 해주던가. 객체 접근할때 좀더 신경써서 접근할 수 있도록



#Reference Type Casting

래퍼런스 타입의 변수들은 상속관계일 경우 형변환이 가능하다.
Member cc = new MainMember();
MainMember c = (MainMemver) cc; //큰타입에 작은 타입으로 형변환은 가능하지만
이건 가능하지만

Member cc = new Member();
MainMember c = (MainMemver) cc;
이건 컴파일은 되고 실행하면 캐스팅 오류가 난다.

Parent c = new Child();
Child xx = (Child)c; // 큰 타입을 작은 애로 형변환 가능.
// 통은 큰데 들어있는 내용이 작으니 가능
이러면 자식 클래스의 메소드, 필드에 접근이 가능하다.
이거 역시 가능하지만

Parent c = new Parent(); // 진짜로 큰 타입을 작은 걸로 형변환 안됨.
Child xx = (Child)c;
// 통도 크고 들어있는 내용도 크면 작은 걸로 못들어감.



#문자열 공백 제거 Trim() 함수

String str = " 문자열에 공백이 있습니다. ";        
System.out.println(str);

str = str.trim();
System.out.println(str);

문자열에 공백이 있습니다.
문자열에 공백이 있습니다.



#배열에 객체가 넘어갔을때

File playList[]=new File[size];
File 타입에 playList 배열을 하나 생성하고 그 배열에 객체 값을 넣게되면

playList[0]=fl;
이렇게 fl이라는 객체가 들어가게 되면 fl객체의 레퍼런스(주소)값이 들어가게 된다.
그래서
playList[0].get..()
playList[0].set..()
playList[0].prittName()..
이런식으로 객체의 field, 메소드 에 접근이 가능하다.


main(){
    File fl = new File("mp3", 500, "Home");
}



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

+ Recent posts