public class 

  • 다른 패키지에서도 사용 가능 하게

 

이클립스 단축키 정리하기!

 

inner class

처음부터 가지고 있다. 

Member Inner class

package inner;

class Outter{
	private int num = 0;
	private static int num2 = 3;
	
	class Inner{
		public void disp() {
			System.out.println(num);
			System.out.println(num2);
		}
	}
}
public class MemberInnerTest {
	public static void main(String[] args) {
		Outter o = new Outter();
		Outter.Inner inner = o.new Inner();
		inner.disp();
	}
}

 

		Outter o = new Outter();
		Outter.Inner inner =o.new Inner();
Outter.Inner inner = new Outter().new Inner();

두개는 같은 소스 코드이다. 

static inner clas

package inner;


class Outter{
	private static int num = 0;
	private static int num2 = 3;
	
	static class Inner{
		public void disp() {
			System.out.println(num);
			System.out.println(num2);
		}
	}
}
public class MemberInnerTest {
	public static void main(String[] args) {
		Outter.Inner a = new Outter.Inner();
		a.disp();
	}
}

 

local class

package inner;


class Outter{
	private static int num = 0;
	private static int num2 = 3;
	
	public void Output() {
		class Inner{
			public void disp() {
				System.out.println(num);
				System.out.println(num2);
			}
		}
		Inner in = new Inner();
		in.disp();
	}
}
public class MemberInnerTest {
	public static void main(String[] args) {
		Outter o = new Outter();
		o.Output();
	}
}

 

Anonymous inner class

package inner;
abstract class Abs{
	abstract void disp();	// "disp"
}

class Outter{
	private static int num = 0;
	private static int num2 = 3;
	
	public void output(){
		new Abs() {
			@Override
			void disp() {
				System.out.println(num);
				System.out.println(num2);
			}
		}.disp();
	}
	
}
public class MemberInnerTest {
	public static void main(String[] args) {
		Outter out = new Outter();
		out.output();
	}
}

 

'study > JAVA 전문가' 카테고리의 다른 글

mysql 3  (0) 2021.12.17
DBMS  (0) 2021.12.15
자료구조 2 - 복습  (0) 2021.12.10
자료구조 1  (0) 2021.12.09
Wrapper Class, 제너릭, ,,  (0) 2021.12.08

복습

추상화

  • 내가 물건을 파는 사람이라고 생각
  • 이것을

캡슐화

  • 어떻게 흘러가는지 100% 파악
  • 데이터 손실이 발생했을 때 찾기 쉽다 : DB

상속

  • 물려받는 것
  • 내 것이 아닌데 생기는 것
  • 관계를 명확해야한다.
  • 확장성, 유지보수
  • 설계를 잘 해야한다.
  • 남들이 봤을 때 잘 보이게
  • Class관계
    • Has ~ A관계 (~가 ~를 가지고 있다.) => 임베디드 오브젝트
      • 상식적인 선에서 관계를 맺어야 한다.
    • Is ~ A관계 (~는 ~이다.) => 상속
      • is like관계 X
      • ~는 ~와 같다 X

 

인터페이스

  • 다중상속 대체 
  • 기능 가지고 있지 않다.
    • 강제성 부여
  • 인터페이스만 봐도 '저런 동작을 하구나'를 안다. 
  • 메뉴판과 같다.

 

코드 리뷰

  • 생성자에서 상수 크기, 변수 초기화
    • 잘게 쪼개라
  • protected 
    • private : 오직 메소드를 통해서만 사용 할 수 있다. (getter/setter)
  • abstract : 
    • 행위는 똑같지만, 안에 내용이 다를 때
  • 동적 바인딩
    • 부모가 아는 것만 접근 O
  • final : 꼭 써야 할 때
  • 초기화 null 해야함

 

'study > JAVA 전문가' 카테고리의 다른 글

DBMS  (0) 2021.12.15
inner  (0) 2021.12.10
자료구조 1  (0) 2021.12.09
Wrapper Class, 제너릭, ,,  (0) 2021.12.08
arrays 클래스  (0) 2021.12.08

레퍼런스 타입

  • 오브젝트
    • 메모리에 안 올라옴
  • New
    • 메모리에 올라옴
    • 인스턴스화

 

레퍼런스 변수 

  • 그냥 이름이 홍길동이라면 진짜 사람 홍길동 대상을 접근하는 것

 

배열

  • 동일한 데이터 타입을 순차적으로 확보한 것
  • C언어 :
    • 일반적으로 메모리 할당
    • 1차원 배열로 저장됨 
    • 그냥 표현을 2차원, 다 차원으로 할 뿐
    • <그림>
  • JAVA 
    • int [ ] [ ] arr = new int [2][3];
    • 레퍼런스와 1:1관계
    • <그림>

 

Class 구성원

  • 필드
  • 생성자
    1. 객체 생성
      • 객체 등록 new
    2. 필드 초기화
      • 객체가 생성되는 시점에
      • 쓰레기값 방지
      • java는 디폴트 값 0임
  • 메소드
    • 쓰는 목적
      • 외부와 내부 연결 시켜줌
      • 데이터를 사용 할 수 있게 해줌
      • 캡슐화 메소드를 통해서 함 
    • 인스턴스
      • 각 하나씩 있음
      • new
      • 데이터를 안정적으로 쓰려고
      • 레퍼런스._____
      • this ( O ) 
        • this : 자기자신을 구별하는 키워드
        • 인스턴스 메소드의 첫번째 메소드
        • 무조건 있음 (선언 안 해도)
          • void setXXX ( A this ,,,,)
        • 객체 구별 할 수 있다.
          • 누구의 Set/Get인지
    • static 
      • 미리 만들어진 메모리
      • 공유하는 목적
      • 안 쓰면 안 사라짐
      • 메모리 절약할 수 있음 (공유하면서)
      • 클래스.______
      • this ( X )
        • 객체 구별 X
          • 필드 값 없음
      • 메모리 접근 X
    • final
      • 절대 안 바뀜

 

this 

  • this의 목적
    1. 객체 구별
      1. 지벽변수, 필드 변수
    2. 메소드 내 자신을 리턴
      1. return this 
      2. toString
  • this( )
    • 생성자 호출
    • 내 자신의 오버로딩된 함수에 있는 생성자
    • 내 클래스 내에 오버로딩 된거 부를 때
    • 또 다른 생성자 부름 (필드 초기화)

 

 

접근 제어자 

  • private
  • defalut
  • protected
  • public

 

 

this( )

  • 코드의 가독성이 좋아짐
package pratice;

public class First {
	private int A;
	private int B;
	public First() {
//		A = B = 0;
		this(0,0);
	}
	public First(int a) {
//		this.A = a;
//		B = 0;
		this(a,0);
	}

	public First(int a, int b) {
		this.A = a;
		this.B = b;
	}
	public int getB() {
		return B;
	}

	public int getA() {
		return A;
	}


	public static void main(String[] args) {
		First aa  = new First();
		First bb  = new First(10);
		First cc  = new First(20,3);
		
		System.out.println(aa.getA()+ "\t" + aa.getB());	// 0,0
		System.out.println(bb.getA()+ "\t" + bb.getB());	// 10,0
		System.out.println(cc.getA()+ "\t" + cc.getB());	// 20,3
		
		
	}
}

 

 

static 메소드

  • 인스턴스 필드 값
    • 구별 못 함 -> 구별하지 못 해서 ( this )
    • 메모리 접근하지 못 함 : 인스턴스 객체 만들어지지 못 해서 
  • 구별을 하지 않아도 되는 거 씀 -> static 필드

인스턴스 메소드

 

 

추상 클래스 

  1. 오직 상속을 목적으로 사용
  2. 추상 클래스를 상속 받는 sub class는 무조건 추상 메소드를 오버라이드 해야만 한다. 
    • 하지 않은 경우 추상 클래스화 돼서 객체를 생성할 수 없다. 
  3. 추상 메소드는 강제성을 발휘하기 때문에 꼭 오버라이드를 해야만 한다. 
  4. 추상 클래스 보다 더 추상화 된 것은 interface이다. 
  5. 추상 메소드 , 상수를 갖는게 원칙.
  6. 인터 페이스는 다중 상속을 허용한다. ( 모호성이 발생하지 않는다. )
    • 기능이 없음 -> 클래스에서 정함
  7. 다중 상속을 대체하기 위해 만들어졌다. 
    1. 스레드가 된다. 

 

인터페이스

  • 다중 상속 허용
  • 여러개 쓸 수 있다. 
interface ss{
	//	상수, 추상 메소드
    /*(final static) 생략*/int num = 100;	//	상수

	void disp();	//	추상 메소드
    abstract vodi disp();
}

두가지 경우가 있다.

1.

class second implements ss{

	@Override
	public void disp() {
		// TODO Auto-generated method stub
		
	}
	
}

2.

abstract class second implements ss{
	
}

 

  • 클래스 - 인터페이스 : implement

 

동적 바인딩

  • 부모의 레퍼런스로 자식을 접근하는 방식
  • 서브 클래스가 생겨도 h.disp( )로 접근
  • 접근하기 쉽다. 
  • 코드의 가독성 높임
package Cource;
class Halbe{
	public void disp() {
		System.out.println("halbe");
	}
}
class Abe extends Halbe{
	public void disp() {
		System.out.println("abe");
	}
}
class Me extends Abe{
	public void disp() {
		System.out.println("me");
	}
}
class second{
	public static void main(String [] args) {
		Halbe halbe = new Halbe();
		Abe abe = new Abe();
		Me me = new Me();
		
		Halbe h;
		
		
		h = halbe;
		h.disp();
		
		h = abe;	//	원래 안 되야함. 
		h.disp();
		
		h = me;
		h.disp();
		
		halbe.disp();
		me.disp();
		abe.disp();
		
		
	}
}

 

'study > JAVA 전문가' 카테고리의 다른 글

inner  (0) 2021.12.10
자료구조 2 - 복습  (0) 2021.12.10
Wrapper Class, 제너릭, ,,  (0) 2021.12.08
arrays 클래스  (0) 2021.12.08
얕은 복제, 깊은 복제  (0) 2021.12.07

Wrapper Class

  • 박싱 : 기본 데이터를 Wrapper 클래스에 담는거
    • Integer ten = Integer.valueOf(10);
  • 언박싱 : 박싱 반대
package com.javaex.api.array;

public class WrapperEx {
	public static void main(String [] args) {
		Integer i = new Integer(10);	//	deprecated
		Integer i2 = Integer.valueOf(10);
		
		Integer i3 = Integer.valueOf("10");	
		
		//	자동 박싱 
		Integer i4 = 10;	//	Integer i4 = Integer.valueOf(10);
		
		//	자동 언박싱
		int value = i4;		//	int value = i4.intValue();
		
		//	포장된 값 비교
		System.out.println(i == i2);	//	false됨 : Wrapper Class도 객체다. 객체 주소 비교 (주의)
		System.out.println(i.intValue() == i2.intValue());	//	첫번째 방법
		System.out.println(i.equals(i2));	//	두번째 방법
		
	}
}

결과 

false
true
true

 

Generic

 

package com.javaex.api.generic;

public class BoxApp {

	public static void main(String[] args) {
		IntBox iBox = new IntBox();
		iBox.setContent(10);
		System.out.println("IntBox : "+ iBox.getContent());
		
		StrBox sBox = new StrBox();
		sBox.setContent("String");
		System.out.println("StrBox : "+ sBox.getContent());
		
		//	다 들어감 ->
		//	1. 제한이 안 되어 있음
		//	2. 캐스팅 해야함 (런타임오류 발생 가능)
		ObjBox oBox = new ObjBox();
		oBox.setContent(10);
		oBox.setContent("String");
		
		String value = (String)oBox.getContent();
		System.out.println("content : " + value);
		
//		int value1 = (Integer)oBox.getContent(); -> 런타임 오류 발생
		
		
		//	제너릭 사용
		GenericBox<Integer> intGBox = new GenericBox<Integer>();
		//	1. 컴파일러에서 타입 체크 가능
		intGBox.setContent(101);
		//	2. 다운 캐스팅의 불편 해소
		Integer iValue = intGBox.getContent();
		System.out.println("Generic content " + iValue);
		
		
		GenericBox<String> strGBox = new GenericBox<>();
	}

}

GenericBox.java

package com.javaex.api.generic;

public class GenericBox<T>{
	T Content;

	public T getContent() {
		return Content;
	}

	public void setContent(T content) {
		Content = content;
	}
	
}

 

Collection Framwork

인터페이스

  • list
    • 순서 O
    • 중복 허용
  • Set
    • 순서 X
    • 중복 X
  • Map
    • 키와 값의 쌍
    • 순서 유지 X
    • 중복 
      • 키는 중복 X
      • 값은 중복 O

 

배열

  • 빠른 접근
  • 고정된 크기
  • 비효율적 메모리 점유

리스트

  • 가변 크기
  • 느린 접근
  • 참조 자료 유형만 사용 가능

 

Vector

package com.javaex.api.list;

import java.util.Enumeration;
import java.util.Vector;

public class VectorEx {
	public static void main(String[] args) {
		//	백터 선언
		Vector<Integer> v = new Vector<>();
		System.out.println("[아무것도 안 한거] Size : "+ v.size() + ", Capacity : " + v.capacity());
		
		for(int i = 1; i<=10; i++) {
			v.addElement(i);
		}
		System.out.println("[10개 추가] Size : "+ v.size()+ ", Capacity : "+v.capacity());
		
		v.addElement(11);
		System.out.println("[addElement사용] Size : "+ v.size()+ ", Capacity : "+v.capacity());
		
		
		//	삽입
		v.insertElementAt(5, 7);
		System.out.println("[insertElementAt] Size : "+ v.size()+ ", Capacity : "+v.capacity());
		
		//	조회
		System.out.println(v.elementAt(5));
		
		//	검색
		System.out.println("[indexOf(7)] : "+v.indexOf(7));
		System.out.println("[indexOf(12)] : "+v.indexOf(12));
		
		//	포함 여부 확인
		System.out.println("[contains(10)] : "+v.contains(10));
		
		//	삭제
		v.removeElement(5);	//	객체 5를 삭제
		System.out.println("[5삭제 ] : "+ v);
		
		//	순회 -> 이 방법 보단 반복자 사용을 권장
		for(int i = 0; i < v.size(); i++) {
			Integer item = v.elementAt(i);
			System.out.print(item + " ");
		}
		System.out.println();
		
		//	반복자 활용
		Enumeration<Integer> e = v.elements();
		while(e.hasMoreElements()) {	//	값이 있니?
			Integer item = e.nextElement();
			System.out.print(item + " ");
		}
		System.out.println();
		
		
		//	비우기
		v.clear();
		System.out.println("[clear] : "+ v);
	}
}

 

Linked List

  • List는 인터페이스이기 때문에 사용 방법이 같다. 
  • 필드 정의할 때, LinkedList 또는 ArrayList 둘 중 하나로 하면 됨.
package com.javaex.api.list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

public class ListEx {
	public static void main(String[] args) {
		//	List는 interface : 사용 방법이 다 같다.
//		List<String> lst = new LinkedList<>();
		List<String> lst = new ArrayList<>();
		
		//	객체 추가
		lst.add("Java");	//	맨 뒤에 새 노드 추가
		lst.add("C");
		lst.add("C++");
		lst.add("Python");
		
		//	객체 삽입
		lst.add(2, "C#");	//	중간에 객체 삽입
		System.out.println(lst);
		
		//	List는 중복삽입 허용
		lst.add("Java");
		System.out.println(lst);
		
		//	List 항목 수 
		System.out.println("Size : " + lst.size());
		
		//	삭제 
		lst.remove(2);
		lst.remove("Java");		//	처음것만 삭제 되나봐 (중복이있어도)
		System.out.println(lst);
		
		//	List, Set의 경우 Iterator 사용
		Iterator<String> it = lst.iterator();
		while(it.hasNext()) {	//	위치를 그 때 그 때 생성해줌
			String item = it.next();	//	다음 요소를 가져온다.
			System.out.print(item + " ");
		}
		
		//	List 비우기
		lst.clear();
		System.out.println(lst);	
	}
}

 

Stack

스택이 비어 있는지 없는지 확인해주면서 pop해야함

package com.javaex.api.list;

import java.util.Stack;

//	Stack : Last input First Output (LIFO : 후입선출)
public class StackEx {
	public static void main(String[] args) {
		//	스택 선언
		Stack<Integer> stack = new Stack<>();
		
		for(int i = 1; i<= 10; i++) {
			//	push
			stack.push(i);
			System.out.println("STACK : " + stack);	
		}
		
		//	가장 위 데이터를 확인 : peek
		System.out.println("PEEK : "+ stack.peek());
		System.out.println("STACK : "+ stack);
		
		//	인출 : pop
		System.out.println("POP : "+stack.pop());
		System.out.println("STACK : "+stack);
		
		while(!stack.isEmpty()) {	//	인출 전에 비어있는지 체크 해줘야 한다.
			System.out.println("POP : "+ stack.pop());
			System.out.println("STACK : "+ stack);
		}
	}
}

 

Queue

  • offer(넣는 것) : 넣기
  • peek( ) : 첫번째 데이터 확인
  • poll( ) : 뽑아 내기
    package com.javaex.api.list;
    
    import java.util.LinkedList;
    import java.util.Queue;
    
    public class QueueEx {
    	public static void main(String[] args) {
    		Queue<Integer> queue = new LinkedList<>();
    		
    		//	First Input First Output(FIFO : 선입선출)
    		for(int i = 0; i <= 10; i++) {
    			queue.offer(i);	//	enqueue
    			System.out.println("QUEUE : " + queue);
    		}
    		
    		//	queue의 첫번째 데이터 확인
    		System.out.println("PEEK : "+ queue.peek());
    		System.out.println("QUEUE : " + queue);
    		
    		//	
    		System.out.println("POLL : " + queue.poll());
    		System.out.println("QUEUE : " + queue);
    		
    		
    		while(!queue.isEmpty()) {
    			System.out.println("POLL : " + queue.poll());
    			System.out.println("QUEUE : " + queue);
    		}
    		
    		
    	}
    }​

 

Hash Set

  • 순서 X
  • 중복허용 X
private static void hashSetCustom() {
		HashSet<Student> hs = new HashSet<>();
		
		Student s1 = new Student("홍길동", 1);
		Student s2 = new Student("홍길동", 2);
		Student s3 = new Student("홍길동", 1);
		
		hs.add(s1); hs.add(s2); hs.add(s3);
		
		System.out.println(hs);
		
		//이름도 같고 아이디도 같은게 들어감
		
		
	}
[Student [id=2, name=홍길동], Student [id=1, name=홍길동], Student [id=1, name=홍길동]]

이름도 같고 id가 같은데 들어간다. 

 

이걸 해결하기 위해

HashCode를 사용함

HshCode

  1. HashCode비교
  2. equals확인
  3. 동등 판별

Student.java

package com.javaex.api.collection.hash;

public class Student {
	int id;
	String name;
	
	public Student(String name, int id) {
		this.name = name;
		this.id = id;
	}

	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + "]";
	}
	
	//	hashCode 비교 -> equals 확인 -> 동등 판별
	@Override
	public int hashCode() {
		//	 객체 식별값 (정수)
		return id;
	}

	@Override
	public boolean equals(Object obj) {
		if(obj instanceof Student) {
			//	다운캐스팅
			Student other = (Student)obj;
			return name.equals(other.name) && id == other.id;
		}
		return super.equals(obj);
	}
	
	
}

HashSetEx.java

package com.javaex.api.collection.hash;

import java.util.HashSet;

public class HashSetEx {
	//	Hash 알고리즘을 사용하는 컬렉션
	//	HashSet 순서가 없다. 중복을 허용하지 않음
	//	
	public static void main(String[] args) {
		hashSetEx();
		hashSetCustom();
	}
	private static void hashSetCustom() {
		HashSet<Student> hs = new HashSet<>();
		
		Student s1 = new Student("홍길동", 1);
		Student s2 = new Student("홍길동", 2);
		Student s3 = new Student("홍길동", 1);
		
		hs.add(s1); hs.add(s2); hs.add(s3);
		
		System.out.println(hs);
		
		//이름도 같고 아이디도 같은게 들어감
		
		
	}
 }

결과

[Student [id=1, name=홍길동], Student [id=2, name=홍길동]]

 

Hash Table

  • 키 중복 X
  • 키 순서 X
  • 이미 값이 있는 키에 값을 넣으면 덮어쓰기 된다.
    package com.javaex.api.collection.hash;
    
    import java.util.Hashtable;
    import java.util.Iterator;
    import java.util.Map;
    
    public class HashtableEx {
    	public static void main(String[] args) {
    		Map<String, Integer> map = new Hashtable<>();
    		
    		//	키 - 값의 쌍으로 저장
    		//	맵에 데이터 넣기
    		map.put("SOCCER", 11);
    		map.put("BASEBALL", 9);
    		map.put("VOLLEYALL", 6);
    		
    		System.out.println(map);
    		
    		//	키는 HashSet : 키는 중복 될 수 없고 순서가 없다.
    		map.put("VOLLEYALL", 12);
    		System.out.println(map);
    		
    		//	키 포함 여부
    		System.out.println("SOCCER 키가 있는가 ? " + map.containsKey("SOCCER"));
    		
    		//	값 포함 여부 
    		System.out.println("값에 9가 있는가 ? "+ map.containsValue(9));
    		
    		
    		//	Iterator
    		Iterator<String> it = map.keySet().iterator();
    		while(it.hasNext()) {
    			String key = it.next();
    			System.out.printf("[Key] %s => [value] %d%n",
    					key, map.get(key));
    		}
    		
    		//	맵 비우기
    		map.clear();
    		System.out.println(map);
    	}
    	
    }​
    결과
    {SOCCER=11, VOLLEYALL=6, BASEBALL=9}
    {SOCCER=11, VOLLEYALL=12, BASEBALL=9}
    SOCCER 키가 있는가 ? true
    값에 9가 있는가 ? true
    [Key] SOCCER => [value] 11
    [Key] VOLLEYALL => [value] 12
    [Key] BASEBALL => [value] 9
    {}​

 

'study > JAVA 전문가' 카테고리의 다른 글

자료구조 2 - 복습  (0) 2021.12.10
자료구조 1  (0) 2021.12.09
arrays 클래스  (0) 2021.12.08
얕은 복제, 깊은 복제  (0) 2021.12.07
인터페이스  (0) 2021.12.07

복제

package com.javaex.api.array;

import java.util.Arrays;

public class ArrayEx {
	public static void main(String[] args) {
		arrayCopyEx();
	}
	private static void arrayCopyEx() {
		int arr[]  = new int[] {1,2,3,4,5};
		
		//	System 이용 복사
		int[] target = new int[arr.length];
		System.arraycopy(arr,	// 원본배열 
				0,	//	시작인덱스
				target,	//	대상 배열
				0,	//	시작 인덱스
				arr.length	//	복사할 길이
				);
		System.out.println("원본 배열 : " + Arrays.toString(arr));
		System.out.println("System 복제 : "+ Arrays.toString(target));
		
		
		//	arrays의 복제 메서드
		target = Arrays.copyOf(arr, arr.length);	//	원본 배열, 복사할 배열 길이
		System.out.println("CopyOf : "+ Arrays.toString(target));
		
		
		// 	배열 일부 복제
		target = Arrays.copyOfRange(arr, 1, 3);	//	원본 배열, 복사 시작 인덱스, 복사할 끝 인덱스
		System.out.println("CopyOfRange : " + Arrays.toString(target));
	}
}
  • Arrays.arraycopy ( 원본 배열, 시작인덱스, 대상 배열, 대상 배열의 시작 인덱스, 복사할 길이)
  • Arrays.copyOf( 원본 배열, 복사할 배열 길이)
  • Arrays.copyOfRange( 원본 배열, 복사 시작 인덱스, 복사할 끝 인덱스)

 

정렬

1. 

//역순 정렬
	private static void basicSortDesEx() {
		Integer[] scores = {80,50,70,90,75,88,77};
		System.out.println("원본 : "+ Arrays.toString(scores));
		Arrays.sort(scores, Collections.reverseOrder());
		//	배열이 기본 타입이아닌, 랩컨버런스?로 해줘야함 int -> Integer
		System.out.println("역순 정렬 : "+ Arrays.toString(scores));
	}
	private static void basicSortEx() {
		int[] scores = {80,50,70,90,75,88,77};
		System.out.println("원본 : "+ Arrays.toString(scores));
		Arrays.sort(scores);
		System.out.println("Sort정렬 : "+ Arrays.toString(scores));
	}

 

2. 

private static void customClassSort() {
		Member[] members = {
				new Member("홍길동"),
				new Member("고길동"),
				new Member("장길산"),
				new Member("임꺽정")
		};
		System.out.println("원본 : "+ Arrays.toString(members));
		Arrays.sort(members);	//	런타임 에러 ->   cannot be cast to class java.lang.Comparable
		System.out.println("정렬 : "+ Arrays.toString(members));
		Arrays.sort(members, Collections.reverseOrder());;
		System.out.println("역순 정렬 : "+ Arrays.toString(members));
		
	}
package com.javaex.api.array;

public class Member implements Comparable {
	String name;
	
	public Member(String name) {
		this.name = name;
	}

	@Override
	public String toString() {
		return "Member [name=" + name + "]";
	}
	
	//	ComparTo를 오버라이딩 해줘야한다. 
	@Override
	public int compareTo(Object o) {
		//	0 : 두 객체의 순번이 같다. 
		//	음수 : 순서가 앞이다. 
		//	양수 : 순서가 뒤다.
		if(o instanceof Member) {
			Member other = (Member)o;
			return name.compareTo(other.name);
		}
		return 0;
	}
	
	
	
}

 

다른 방법으론

private static void customClassSort() {
		Member[] members = {
				new Member("홍길동"),
				new Member("고길동"),
				new Member("장길산"),
				new Member("임꺽정")
		};
		System.out.println("원본 : "+ Arrays.toString(members));
		Arrays.sort(members);	//	런타임 에러 ->   cannot be cast to class java.lang.Comparable
		System.out.println("정렬 : "+ Arrays.toString(members));
		
//		Arrays.sort(members, Collections.reverseOrder());;
		Arrays.sort(members, new Comparator<Member>() {

			@Override
			public int compare(Member o1, Member o2) {
				return o1.name.compareTo(o2.name);
			}
			
			
		});
		System.out.println("역순 정렬 : "+ Arrays.toString(members));
		
	}

Comparetor<Member>를 사용한다. 

검색

이진 검색

  • 미리 정렬이 되어 있어야 한다. 
  • private static void bsicSearch() { int [] scores = {80,50,70,90,75,88,77}; // 이진 검색 방식은 미리 정렬이 되어 있어야 한다. Arrays.sort(scores); System.out.println("원본 : " + Arrays.toString(scores)); int index = Arrays.binarySearch(scores,75); // 75가 몇 번째 인덱스? System.out.println("75가 있는 인덱스 : "+ index); }​

 

 

 

'study > JAVA 전문가' 카테고리의 다른 글

자료구조 1  (0) 2021.12.09
Wrapper Class, 제너릭, ,,  (0) 2021.12.08
얕은 복제, 깊은 복제  (0) 2021.12.07
인터페이스  (0) 2021.12.07
예외  (0) 2021.12.07

Object 클래스 toSting() 오버라이드

Point.java

package com.javaex.api.objectclass.v1;

//	자바 최상위 클래스는 Object
public class Point {
	private int x;
	private int y;
	
	public Point(int x, int y) {
		this.x = x;
		this.y = y;
	}

	@Override
	public String toString() {
		//	객체 문자열 포맷을 반환
		return String.format("Point(%d, %d)",x,y);
	}
}

LangClassTest.java

package com.javaex.api.objectclass.v1;

public class LangClassTest {

	public static void main(String[] args) {
		Point p = new Point(10,10);
		
		//Object의 메서드를 기본 상속
		System.out.println(p.getClass().getName());	//	클래스 정보 : com.javaex.api.objectclass.v1.Point
		System.out.println(p.hashCode());	//	객체 식별자 : 1521118594
		System.out.println(Integer.toHexString(p.hashCode()));	//	5aaa6d82
		
		System.out.println(p);	//	클래스명@해시코드 16진수 값 : com.javaex.api.objectclass.v1.Point@5aaa6d82
		System.out.println(p.toString());
		
	}

}

결과 

com.javaex.api.objectclass.v1.Point
1521118594
5aaa6d82
Point(10, 10)
Point(10, 10)

 

 

equals( )

package com.javaex.api.objectclass.v2;

public class LangClassTest {

	public static void main(String[] args) {
		Point p1 = new Point(10,10);
		Point p2 = new Point(10,10);
		
		System.out.println("p1 == p2 ? " + (p1 == p2));
		System.out.println("p1.equals(p2) ? " + p1.equals(p2));
	}

}

결과

p1 == p2 ? false
p1.equals(p2) ? false

 

equals 오버라이딩

Point.java

package com.javaex.api.objectclass.v2;

//	자바 최상위 클래스는 Object
public class Point {
	private int x;
	private int y;
	
	public Point(int x, int y) {
		this.x = x;
		this.y = y;
	}

	@Override
	public String toString() {
		//	객체 문자열 포맷을 반환
		return String.format("Point(%d, %d)",x,y);
	}

	@Override
	public boolean equals(Object obj) {
		if(obj instanceof Point) {
			Point other = (Point)obj;	//	변환
			return x == other.x && y == other.y;
		}
		return super.equals(obj);
	}
	
	
}

결과 

p1 == p2 ? false
p1.equals(p2) ? true

 

 

객체 단순 복제

LangClassTest.java

package com.javaex.api.objectclass.v3;

public class LangClassTest {

	public static void main(String[] args) {
		Point p1 = new Point(10,10);
		
		System.out.println("p1 =" + p1);
		
		Point p2 = p1.getClone();	//	복제
		System.out.println("p2 =" + p2);
		
		System.out.println("p1 == p2 ? "+ (p1 == p2));
		
		p1.setX(100);
		p1.setY(200);
		System.out.println("p1 =" + p1);
		System.out.println("p2 =" + p2);
		
	}

}

Point.java

package com.javaex.api.objectclass.v3;

//	v3. 얕은 ㅗㅂ갓

// 	객체 필드데이터를 단순 복제
//	Cloneable 인터ㅔ이스 구현
public class Point implements Cloneable{
	public Point getClone() {
	//복제본
	Point clone = null;
	try {
		clone = (Point) clone();
	}catch(CloneNotSupportedException e) {
		e.printStackTrace();
	}
	return clone;
	}
	
	
	public int getX() {
		return x;
	}

	public void setX(int x) {
		this.x = x;
	}

	public int getY() {
		return y;
	}

	public void setY(int y) {
		this.y = y;
	}

	private int x;
	private int y;
	
	public Point(int x, int y) {
		this.x = x;
		this.y = y;
	}

	@Override
	public String toString() {
		//	객체 문자열 포맷을 반환
		return String.format("Point(%d, %d)",x,y);
	}

	@Override
	public boolean equals(Object obj) {
		if(obj instanceof Point) {
			Point other = (Point)obj;	//	변환
			return x == other.x && y == other.y;
		}
		return super.equals(obj);
	}
	
	
}

 

결과 : 

p1 =Point(10, 10)
p2 =Point(10, 10)
p1 == p2 ? false
p1 =Point(100, 200)
p2 =Point(10, 10)

객체 필드 데이터 단순 복제

 

깊은 복제

LangClassTest.java

package com.javaex.api.objectclass.v4;

public class LangClassTest {

	public static void main(String[] args) {
		ScoreBoard s1 = new ScoreBoard(new int[] { 10,20,30,40});
		System.out.println("s1 = " + s1);
		
		ScoreBoard s2 = s1.getClone();
		System.out.println("s2 = " + s2);
		
		System.out.println("s1 == s2 ? "+ (s1 == s2));
		
		s2.getScores()[2] = 100;
		System.out.println("s1 = " + s1);
		System.out.println("s2 = " + s2);
		System.out.println("s1.scores == s2.scores ? "+ (s1.getScores() == s2.getScores()));
	}

}

ScoreBoard.java

package com.javaex.api.objectclass.v4;

import java.util.Arrays;

//	v4. 깊은 복제
public class ScoreBoard implements Cloneable{
	//참조 타입 필드
	private int[] scores;
	
	//	생성자
	public ScoreBoard(int[] scores) {
		this.scores = scores;
	}
	
	public ScoreBoard getClone() {
		ScoreBoard clone = null;
		try {
			clone = (ScoreBoard)clone();
		}catch(CloneNotSupportedException e) {
			e.printStackTrace();
		}
		
		return clone;
	}

	public int[] getScores() {
		return scores;
	}

	public void setScores(int[] scores) {
		this.scores = scores;
	}

	@Override
	public String toString() {
		return "ScoreBoard [scores=" + Arrays.toString(scores) + "]";
	}
	
	
}

결과 

s1 = ScoreBoard [scores=[10, 20, 30, 40]]
s2 = ScoreBoard [scores=[10, 20, 30, 40]]
s1 == s2 ? false
s1 = ScoreBoard [scores=[10, 20, 100, 40]]
s2 = ScoreBoard [scores=[10, 20, 100, 40]]
s1.scores == s2.scores ? true

객체를 만드는 것

 

깊은 복제를 얕은 복제 시도

LangClassTest.java

package com.javaex.api.objectclass.v4;

public class LangClassTest {

	public static void main(String[] args) {
		ScoreBoard s1 = new ScoreBoard(new int[] { 10,20,30,40});
		System.out.println("s1 = " + s1);
		
		ScoreBoard s2 = s1.getClone();
		System.out.println("s2 = " + s2);
		
		System.out.println("s1 == s2 ? "+ (s1 == s2));
		
		s2.getScores()[2] = 100;
		System.out.println("s1 = " + s1);
		System.out.println("s2 = " + s2);
		System.out.println("s1.scores == s2.scores ? "+ (s1.getScores() == s2.getScores()));

	}

}

ScoreBoard.java

package com.javaex.api.objectclass.v4;

import java.util.Arrays;

//	v4. 깊은 복제
public class ScoreBoard implements Cloneable{
	//참조 타입 필드
	private int[] scores;
	
	//	생성자
	public ScoreBoard(int[] scores) {
		this.scores = scores;
	}
	
	public ScoreBoard getClone() {
		ScoreBoard clone = null;
		try {
			clone = (ScoreBoard)clone();
		}catch(CloneNotSupportedException e) {
			e.printStackTrace();
		}
		
		return clone;
	}

	public int[] getScores() {
		return scores;
	}

	@Override
	protected Object clone() throws CloneNotSupportedException {
		//	1. 얕은 복제 시도
		ScoreBoard clone = (ScoreBoard)super.clone();
		//	2. 내부 참조 객체를 복제
		clone.scores = Arrays.copyOf(scores, scores.length);
		return clone;
	}

	public void setScores(int[] scores) {
		this.scores = scores;
	}

	@Override
	public String toString() {
		return "ScoreBoard [scores=" + Arrays.toString(scores) + "]";
	}
	
	
}

결과

s1 = ScoreBoard [scores=[10, 20, 30, 40]]
s2 = ScoreBoard [scores=[10, 20, 30, 40]]
s1 == s2 ? false
s1 = ScoreBoard [scores=[10, 20, 30, 40]]
s2 = ScoreBoard [scores=[10, 20, 100, 40]]
s1.scores == s2.scores ? false

참조 타입 필드를 같이 참조하다가.

1. 얕은 복제하고

2. 내부 참조 객체를 복사해왔다.

'study > JAVA 전문가' 카테고리의 다른 글

Wrapper Class, 제너릭, ,,  (0) 2021.12.08
arrays 클래스  (0) 2021.12.08
인터페이스  (0) 2021.12.07
예외  (0) 2021.12.07
추상 클래스  (0) 2021.12.07

인터페이스

  • 서로 관계가 없는 물체들이 상호작용 하기 위해
  • 실제 클래스만 상관없이 규약만 맞으면 어디든 저장 상관 X
  • 하나 또는 그 이상 클래스들에서 똑같이구현되어질 법한 메서드 선언할 때
  • 개발 코드를 수정하지 않고, 가용하는 객체를 변경할 수 있도록
  • 부모클래스로 자식 객체 참조 O
  • 인터페이스로 구현한 객체를 참조할 수 있다.
  • 선언 : interfce "인터페이스명"
    • abstract 키워드 지정 안해도 됨 -> 추상메소드만 들어가기 때문
  • 다중 implements할 수 있음

 

추상클래스 인터페이스
- 상속관계
- "확장"
상속관계를 해치지 않음 (상속관계 상관 X)
그냥 비슷한 규약(함수) 적용

 

변수명

  • 윈도 C++ -> "I인터페이스명"
  • java -> "___able"

 

실습

ShapeApp.java

package com.javaex.oop.shape.v2;

public class ShapeApp {

	public static void main(String[] args) {
//		shape  s = shape();	//	에러 -> 추상 클래스는 객체화 할 수 없다.
		Rectangle r = new Rectangle(10, 20, 100, 50);
		r.draw();
		
		Circle c = new Circle(10, 10, 30);
		c.draw();
		
		Point p = new Point(100,100);
		
		
		System.out.println("p는 Drawable을 구현했는가?\n" + (p instanceof Drawable ? "Drawalbe 구현 O":"Drawalbe 구현 X"));
	}
}

Drawable.java (인터페이스)

package com.javaex.oop.shape.v2;

//	내부에 추상 메서드만 가진다 (	abstract 생략)
public interface Drawable {
	public void draw();
}

Rectangle.java

package com.javaex.oop.shape.v2;


public class Rectangle extends Shape implements Drawable{
	//	필드
	protected int width;
	protected int height;
	
	public Rectangle(int x, int y, int width, int height) {
		super(x,y);
		this.width = width;
		this.height = height;
	}
	
	
	//	모두 구현해줘야 한다. 
	//	source -> override/.. 클릭
	@Override
	public void draw() {
		System.out.printf("사각형[x = %d, y = %d, w = %d, h = %d, area = %f]\n",x,y,width, height,area());
	}

	@Override
	public double area() {
		return width * height;
	}	
}

Circle.java

package com.javaex.oop.shape.v2;

public class Circle extends Shape implements Drawable{
	protected double r;
	
	public Circle(int x, int y, int r) {
		super(x, y);
		this.r = r;
	}

	
	@Override
	public void draw() {
		System.out.printf("원[x=%d, y=%d, r=%f, area = %f]을 그렸어요\n", x,y,r,area());
	}

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

}

Point.java

package com.javaex.oop.shape.v2;

public class Point implements Drawable {

	protected int x;
	protected int y;
	
	public Point(int x, int y) {
		this.x = x;
		this.y = y;
	}
	@Override
	public void draw() {
		System.out.printf("점[x=%d, y=%d]을 그렸습니다.\n",x,y);
	}
	

}

shape.java

package com.javaex.oop.shape.v2;

//	추상 클래스
public abstract class Shape {
	protected int x;
	protected int y;
	
	public Shape(int x, int y) {
		this.x = x;
		this.y = y;
	}
	
	//	추상 클래스는 내부에 반드시 하나 이상의 추상메소드가 있어야 
//	public abstract void draw();	//	인터페이스에 위임
	public abstract double area();
}

결과

사각형[x = 10, y = 20, w = 100, h = 50, area = 5000.000000]
원[x=10, y=10, r=30.000000, area = 2827.433388]을 그렸어요
p는 Drawable을 구현했는가?
Drawalbe 구현 O

 

 

  • 공통점만 뽑아서 관리하면 상속관계에 상관없이 관리 가능

ShapeApp.java

package com.javaex.oop.shape.v2;

public class ShapeApp {

	public static void main(String[] args) {
//		shape  s = shape();	//	에러 -> 추상 클래스는 객체화 할 수 없다.
		Rectangle r = new Rectangle(10, 20, 100, 50);
		r.draw();
		
		Circle c = new Circle(10, 10, 30);
		c.draw();
		
		Point p = new Point(100,100);
		
		
		System.out.println("p는 Drawable을 구현했는가?\n" + (p instanceof Drawable ? "Drawalbe 구현 O":"Drawalbe 구현 X"));
		
		//	인터페이스로 구현 객체를 참조할 수 있다.
		Drawable[] objs = new Drawable[] {
				r,c,p
		};
		for(Drawable obj : objs) {
			obj.draw();
		}
	}
}

 

 

'study > JAVA 전문가' 카테고리의 다른 글

arrays 클래스  (0) 2021.12.08
얕은 복제, 깊은 복제  (0) 2021.12.07
예외  (0) 2021.12.07
추상 클래스  (0) 2021.12.07
[모의 필기테스트] 오답노트 & 정리  (0) 2021.12.07

예외가 발생하면 완벽하게 복구를 할 수가 없는 경우가 있다.

예외

  • 프로그램이 실행되는동안 발생할수 있는 비정상적인 상태
  • 컴파일시의 에러말고 실행시의 에러
  • 모든 예외 => Exception을 사용
  • 예외에는 구체적 예외, 일반적 예외가 있슴
    • 처음에 구체적 예외로 거르다가
    • catch문 밑으로 갈 수록 일반적 예외를 사용해라
    • 마지막엔 Excpetion 써라

ArithmeticException 예외 발생 

package com.javaex.exception;
import java.util.*;
public class ExceptionEx {

	public static void main(String[] args) {
		ArithmeticEx();
	}
	//	어떤 수를 0으로 나눌 때
	private static void ArithmeticEx() {
		double result = 0;
		int num;
		
		Scanner scanner = new Scanner(System.in);
		System.out.print("정수 입력:");
		
		//	예외 발생 가능 영역
		num = scanner.nextInt();
		result = 100/num;
		
		System.out.println(result);
		scanner.close();
	}
}

ArithmeticException 예외 처리 ->

package com.javaex.exception;
import java.util.*;
public class ExceptionEx {

	public static void main(String[] args) {
		ArithmeticEx();
	}
	//	어떤 수를 0으로 나눌 때
	private static void ArithmeticEx() {
		double result = 0;
		int num;
		
		Scanner scanner = new Scanner(System.in);
		System.out.print("정수 입력:");
		
		try {
			//	예외 발생 가능 영역
			num = scanner.nextInt();
			result = 100/num;
		}catch(ArithmeticException e) {
			System.err.println("0으로는 나눌 수 없어요");
		}
		catch(Exception e) {
			e.printStackTrace();	
		}
		
		System.out.println(result);
		scanner.close();
	}
}

 

결과 

정수 입력:0
0으로는 나눌 수 없어요
0.0

 

 

예제

package com.javaex.exception;
import java.util.*;
public class ExceptionEx {

	public static void main(String[] args) {
		ArithmeticEx();
	}
	//	어떤 수를 0으로 나눌 때
	private static void ArithmeticEx() {
		double result = 0;
		int num;
		
		Scanner scanner = new Scanner(System.in);
		System.out.print("정수 입력:");
		
		try {
			//	예외 발생 가능 영역
			num = scanner.nextInt();
			result = 100/num;
		}catch(InputMismatchException e) {	//	정수 입력 안 했을 경우
			System.err.println("정수로 해주세요");
		}
		catch(ArithmeticException e) {		//	0으로 나눴을 경우
			System.err.println("0으로는 나눌 수 없어요");
		}
		catch(Exception e) {	//	모든 예외 처리 가능
			e.printStackTrace();	
		}finally {
			System.out.println("예외 처리 종료");
			//	예외 유무 관계 없이 가장 마지막에
			//	자원 정리 작업에 많이 활용
		}
		
		System.out.println(result);
		scanner.close();
	}
}

 

강제 예외 발생

ExceptionEx.java

package com.javaex.exception;
import java.io.IOException;
import java.util.*;
public class ExceptionEx {

	public static void main(String[] args) {
//		ArithmeticEx();
		throwExceptionEx();
	}
	

	private static void throwExceptionEx() {
		ThrowsExcept except = new ThrowsExcept();
		try {
			except.executeException();	//	호출하는 메소드에서 처리 못 하면 
		}catch(IOException e) {
			System.err.println(e.getMessage());
		}
		System.out.println("예외 처리 완료");
	}
 }

호출하는 메서드에서 처리를 못 하면 예외를 그냥 던져주는게 좋음

 

사용자 정의 예외 사용

ExceptionEx.java

package com.javaex.exception;
import java.io.IOException;
import java.util.*;
public class ExceptionEx {

	public static void main(String[] args) {
//		ArithmeticEx();
		throwExceptionEx();
	}
	

	private static void throwExceptionEx() {
		ThrowsExcept except = new ThrowsExcept();
		try {
			except.executeRuntimeException();	//	호출하는 메소드에서 처리 못 하면 던져 주는 게 좋다. 
			except.executeException();
		}catch(RuntimeException e) {
			System.err.println(e.getMessage());
		}catch(IOException e) {
			System.err.println(e.getMessage());
		}
		
		//	사용자 정의 예외 사용
		try {
			System.out.println(except.divide(100, 0));
		}catch(CustomArithException e) {
			System.err.println(e.getMessage());
			//	예외 상황 확인
			System.err.println("나누어지는 수 : " + e.getNum1());
			System.err.println("나누는 수 : " + e.getNum2());
		}
		System.out.println("예외 처리 완료");
	}
 }

ThrowsException.java

package com.javaex.exception;

import java.io.IOException;

//	사용자 정의 예외 정의

class CustomArithException extends ArithmeticException{
	//	예외 상황 필드
	private int num1;
	private int num2;
	
	public CustomArithException(String message, int num1, int num2) {
		super(message);
		//	예외 상황 정보 저장
		this.num1 = num1;
		this.num2 = num2;
	}
	
	public void setNum1(int num1, int num2) {
		this.num1 = num1;
		this.num2 = num2;
	}
	public int getNum1() {
		return this.num1;
	}
	public int getNum2() {
		return this.num2;
	}
}



public class ThrowsExcept {
	//	checked Exception
	public void executeException() throws IOException {
		System.out.println("강제 예외 발생");
		throw new IOException("강제 예외");
	}
	
	//Unchecked Exception
	public void executeRuntimeException() {
		System.out.println("런타임오류");
		throw new RuntimeException("런타임 예외");
	}
	
	//
	public double divide(int num1, int num2) {
		if(num2 == 0) {
			//ArithmeticException
			//	구체적 예외롤 전환하여 throw 하는 것이
			//	1. 가독성을 높이고
			//	2. 예외 상황 정보를 가져올 수 있다.
			throw new CustomArithException("사용자 정의 예외", num1, num2);
		}
		return num1 / num2;
	}
}

결과

런타임오류
런타임 예외
사용자 정의 예외
나누어지는 수 : 100
나누는 수 : 0
예외 처리 완료

'study > JAVA 전문가' 카테고리의 다른 글

얕은 복제, 깊은 복제  (0) 2021.12.07
인터페이스  (0) 2021.12.07
추상 클래스  (0) 2021.12.07
[모의 필기테스트] 오답노트 & 정리  (0) 2021.12.07
java Class  (0) 2021.12.06

+ Recent posts