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

예외

  • 프로그램이 실행되는동안 발생할수 있는 비정상적인 상태
  • 컴파일시의 에러말고 실행시의 에러
  • 모든 예외 => 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

추상클래스

  • 코드 만들 때 중요한 정보와 그렇지 않은 정보를 구분해서 설계해야 함
  • 공통 속성을 뽑아냄 (일반화)
  • ex) Animal(추상클래스)은 Dog와 Cat의 공통 속성을 뽑아낸다.

 

추상화 

  • 중요한 것은 남기고 필요 없는 것은 없애는 것
  • 객체들 간의 공통되는 특성을 추출하는 것

 

추상 클래스

  • 실체 클래스를 만들기 위한 부모 클래스로만 사용
    • 스스로 객체가 될 수 X -> 부모 클래스로만 사용
    • 물려주기만 하는 용도 (확장을 위한 용도)
    • 구현이 불가능 -> 선언만 함
  • 하나 이상의 메서드만 가짐
  • 속성(필드)와 기능(메서드)를 정의할 수 있다
  • 추상 클래스를 상속하는 실체 클래스 -> 추상 메소드를 반드시 구현해야함
    • 특정 기능을 구현 강요하는 측면 있음
      • ex) Car라는 추상 클래스를 상속하는 Sport Car가 있으면
      • Car의 가속()이라는 메소드를 Sport Car 클래스에 가속()클래스를 오버라이딩해서 무조건 구현해야한다.
  • 추상 메소드는 추상 클래스에만 존재
    • 추상 클래스는 하나 이상의 추상 메서드를 가짐
      • 오버라이딩 해야함

 

추상 클래스의 선언

  • 클래서 선언에 abstrct 키워드

 

실습

shpae.java

package shape.v1;

//	추상 클래스
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();
}

Rectangle.java

package shape.v1;

public class Rectangle extends Shape{
	//	필드
	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 shape.v1;

public class Circle extends Shape {
	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);
	}

}

ShapeApp.java (메인)

package shape.v1;

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();
	}

}

결과

사각형[x = 10, y = 20, w = 100, h = 50, area = 5000.000000]
원[x=10, y=10, r=30.000000, area = 2827.433388]을 그렸어요

 

 

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

인터페이스  (0) 2021.12.07
예외  (0) 2021.12.07
[모의 필기테스트] 오답노트 & 정리  (0) 2021.12.07
java Class  (0) 2021.12.06
[DAY+2]Java Programming  (0) 2021.12.03

클래스 선언 불가 : protected, private

  • protected 
    • 다른 패키지에 있는 생성자, 메소드, 필트 호출 X
    • 상속 관계에 있는 클래스 : 호출 O
      • 자식클래스에서 protected변수 불러오기 가능
    • protected 메소드는 모든 하위 클래스에서 호출 할 O
  • private
    • 클래스 내부만 사용 가능

try catch문 그 다음 finally가 있음

  • finally는 무조건 실행 되는 친구

String

  1. Strring 변수는 바로 초기화 안 해주면 에러다
    • Stirng a; (X)
    • String a = new String() (O)
    • String a = ""; (O)
  2. String 타입은 객체형이다.

Static

  1. Static변수는 메인 안에 선언X
    1. 지역 변수에 static 못 붙음
  2. Static안에서 static이 안 붙은 클래스 or 객체 생성하지 못 한다. 
    • Static { Person a =  new Person(); (X) }
    • static { class Person(){ ... } (X)

Class

  • 복수의 인터페이스 구현 (implements)할 수 O
  • 복수의 부모 클래스로부터 상속 받을 수 X
  • 모든 클래스는 상속을 통한 확장(extend)이 가능X -> finall클래스 안 됨
    • finall 클래스는 상속 X

인터페이스

  • 인터페이스는 또 다른 인터페이스로부터 상속받을 수 있다.
  • 인터페이스를 구현한 클래스는 인터페이스에 포함된 모든 메소드를 구현하지 않아도 됨

finall

  • finall 클래스는 오버로딩 할 수 X
  • finall 클래스는 상속 X

Garbage Collection

  • 자바 프로그램 실행 중 객체가 garbage collection 되지 않을 수 있다.
  • garbage collection 이 객체의 완전한 소멸을 의미X
  • System.gc() 메소드를 호출하여 강제로 garbage collection 을 실행해도 garbage collection이 보장 X

오류

  • 컴파일 오류 : 빨간줄 뜨는 것
  • 런타임 오류 : 실행 했을 때
  • 논리적 오류 : 프로그램 잘 못 짠 것

추상 클래스

  • 추상 클래스는 추상 메소드를 아무것도 가지지 않아도 된다.
  • 객체를 생성할 수 X

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

인터페이스  (0) 2021.12.07
예외  (0) 2021.12.07
추상 클래스  (0) 2021.12.07
java Class  (0) 2021.12.06
[DAY+2]Java Programming  (0) 2021.12.03

- 클래스의 구조

  • 필드
    • 객체 데이터, 상태 저장하는 변수
    • 멤버 변수 
    • Goods.java
    •  
    • package com.javaex.oop.goods.v1; public class Goods { // 필드 String name; int price; }​
    • GoodsApp.java
    • package com.javaex.oop.goods.v1;
      
      public class GoodsApp{
      	public static void main(String [] args) {
      		Goods camera = new Goods();
      		camera.name = "nikon";
      		camera.price = 400000;
      		
      		Goods smartphone = new Goods();
      		smartphone.name = "iPhone 13";
      		smartphone.price = 1000000;
      		
      		System.out.println("이름 : " + camera.name + "\n가격 : " + camera.price);
      		System.out.println("이름 : " + smartphone.name + "\n가격 : " + smartphone.price);
      	}
      }
      결과 
      이름 : nikon
      가격 : 400000
      이름 : iPhone 13
      가격 : 1000000
  • 생성자
    • 객체 생성시 수행되는
    • 목적 : 객체 초기화 -> heap 객체 생성 -> 조소값 받기
  • 메소드

 

- 접근 제한자

public > protected > default > private

  • public
  • protected
  • default
    • 아무것도 안 적으면 default
  • private
    • 자신의 클래스 안에만 사용 가능

 

- 메서드

  • 매개변수
    • 메소드 호출에서 들어가는 구체적인 값 : 인자(Argument)
  • 반환타입
    • int일 때, return 비워두면 안 된다.
  • 메서드 이름
    • 메서드 명은 기능을 알기 쉽게 작성해야함 (ex. a, b, c, -> 무슨 기능인지 알 수 없음)
    • package com.javaex.oop.methods;
      
      public class MethodsEx {
      	public static void main(String[] args) {
      		//입력 x, 출력 x
      		printMessage();
      		
      		//입력 o, 출력 o
      		double result = getSum(4,5);
      		System.out.println("4 + 5 = "+ result);
      		
      		//입력 x, 출력 o
      		//입력 o, 출력 x
      		
      		printTotal("합계", 1,2,3,4,5,6,7,8,9);
      	}
      	//고정인수, 가변 인수
      	private static void printTotal(String message, double ... values) {
      		System.out.println(message+ " : " + getTotal(values));
      	}
      	
      	//가변 인수를 이용한 다수 인수 전달
      	private static double getTotalVar(double ... values) {
      		return getTotal(values);
      	}
      	
      	private static double getTotal(double[] values) {
      		double total = 0;
      		
      		for(double value: values) {
      			total += value;
      		}
      		return total;
      	}
      }

 

- 가변 인수

  • 매개 변수의 개수를 알 수 없을 때 사용
  • 고정인수, 가변인수 같이 올 때 -> ① 고정인수, ②가변인수 (순서 중요)
    public class MethodsEx {
    	public static void main(String[] args) {		
    		printTotal("합계", 1,2,3,4,5,6,7,8,9);
    	}
    	//고정인수, 가변 인수
    	private static void printTotal(String message, double ... values) {
    		System.out.println(message+ " : " + getTotal(values));
    	}
    	
    	private static double getTotal(double[] values) {
    		double total = 0;
    		
    		for(double value: values) {
    			total += value;
    		}
    		return total;
    	}
    }​

- Getter, Setter

  • 객체 외부에서 직접적으로 접근하는 것을 막음

Goods.java

  • package v2;
    
    public class Goods {
    	//	필드
    	private String name;
    	private int price;
    	
    	//외부 접근 방식 노출
    	//	getter/setter
    	//	getter : 데이터 참조하기 위함
    	public String getName() {
    		return name;
    	}
    	
    	public void setName(String name) {
    		this.name = name;
    	}
    	
    	public int getPrice() {
    		return price;
    	}
    	
    	public void showInfo() {
    		System.out.println("상품이름 : " + name);
    		System.out.println("가격 : "+ price);
    	}
    }
     Goods.App.java
    package v2;
    
    public class GoodsApp{
    	public static void main(String [] args) {
    		Goods camera = new Goods();
    		camera.setName("nikon");
    		camera.setPrice(400000);
    		
    		Goods smartphone = new Goods();
    		smartphone.setName("iPhone 13");
    		smartphone.setPrice(1000000);
    		
    //		System.out.println("이름 : " + camera.getName() + "\n가격 : " + camera.getPrice());
    		camera.showInfo();
    //		System.out.println("이름 : " + smartphone.getName() + "\n가격 : " + smartphone.getPrice());
    		smartphone.showInfo();
           	}
    }​

생성자

  • 생성자를 실행시키지 않고 클래스로부터 객체 만들 수 없다.
  • void 안 씀
  • setter가 없으면 readOnly

 

this

  • 현재 사용중인 instance 자신
  • this() : 현재 인스턴스에 있는 다른 생성자 호출
    	public Goods(String name) {
    		this.name = name;
    	}
    	
    	//	생성자 2.
    	public Goods(String name, int price) {
    		this(name);	//	다른 생성자 호출
    		this.price = price;
    	}​

 

메소드 오버로딩

  • 하나의 클래스에 같은 이름의 메소드 존재 가능

 

static, instance, local

  • static :
    • 클래스 영역
    • 해당 클래스로 만들어진 인스턴스
    • new 아니라도 접근 가능
    • static내에서는 static 멤버만 접근 가능 
      • static -> instance 접근 (x)
        public class StaticEx {
        	public static int refCount;	//	 클래스(static) 멤버
        	public static String classVar;	//	클래스 멤버
        	public String instanceVar;	//	인스턴스 멤버
        	
        	// 	static 블록으로 static 영역의 초기화
        	static {
        		refCount = 0;
        		classVar = "static Member";
        		//instanceVar = "Instance Member";	-> 에러
        		// 중요 : sataic 영역에서는 static 만 접근 가능
        	}
        
        }​
  • instance
    • 클래스 영역
    • new 키워드로 인스턴스 사용
    • 인스턴스 내에서 사용
    • instance -> static영역 접근 가능
      public class StaticEx {
      	public static int refCount;	//	 클래스(static) 멤버
      	public static String classVar;	//	클래스 멤버
      	public String instanceVar;	//	인스턴스 멤버
      	
      	// 	static 블록으로 static 영역의 초기화
      	static {
      		refCount = 0;
      		classVar = "static Member";
      		//instanceVar = "Instance Member";	-> 에러
      		// 중요 : sataic 영역에서는 static 만 접근 가능
      	}
      	
      	StaticEx(){
      		//	참조 카운트 증가
      		// 	인스턴스 멤버 -> sataic 멤버 접근 가능
      		refCount++;
      		System.out.println("인스턴스 갯수 : " + refCount);
      	}
      
      }​

    • StaticEx.java
      package com.javaex.oop.staticmember;
      
      public class StaticEx {
      	public static int refCount;	//	 클래스(static) 멤버
      	public static String classVar;	//	클래스 멤버
      	public String instanceVar;	//	인스턴스 멤버
      	
      	// 	static 블록으로 static 영역의 초기화
      	static {
      		refCount = 0;
      		classVar = "static Member";
      		//instanceVar = "Instance Member";	-> 에러
      		// 중요 : sataic 영역에서는 static 만 접근 가능
      		System.out.println("static Block");
      	}
      	
      	StaticEx(){
      		//	참조 카운트 증가
      		// 	인스턴스 멤버 -> sataic 멤버 접근 가능
      		refCount++;
      		System.out.println("인스턴스 갯수 : " + refCount);
      		System.out.println("생성자 호출 : 인스턴스 생성");
      	}
      
      }​
      StaticApp.java
    • package com.javaex.oop.staticmember;
      
      public class StaticApp {
      
      	public static void main(String[] args) {
      		StaticEx s1 = new StaticEx();
      		//static 멤버는 new 없이 접근 가능
      		System.out.println("RefCount"+ StaticEx.refCount);
      		
      		StaticEx s2 = new StaticEx();
      		System.out.println("RefCount"+ StaticEx.refCount);
      	}
      }
      • static영역 먼저 실행
      • StaticApp의 생성자 실행
      • StaticApp mian의 프린트 실행
    • 객체 초기화 : null 로 설정해주면 됨 (heap 메모리에 남아있지만, GTC를 통해 없어짐)
      // 소멸자
      	@Override
      	protected void finalize() throws Throwable{
      		refCount--;
      		System.out.println("소멸자 호출");
      		super.finalize();
      	}​
      	// 	주의 : 가비지 컬렉터를 직접 호출하지 않는다. 
      		System.gc();
      		try {
      			Thread.sleep(3000);//3초간  대기
      		}catch(Exception e) {​
      가비지 수집기 : 사용하지 않은 메모리를 자동적으로 회수하는 서비스GC클래스 : 가비지 수집기 제어
  • local 영역
    • 메서드 영역
    • 메소드 내에서 사용
    • 벗어나면 찾을 수 없음

 

singleton (static의 활용)

  • 단 하나의 인스턴스만 유지
    • 함부러 생성자 호출 불가능하게 -> 생성자를 private로
    • 단 한번만 수행 -> static으로 객체 만들기

Singleton.java

package com.javaex.oop.staticmember;

//	목표 : 어떤 상황에서든 단 한개의 인스턴스만 유지
public class Singleton {
	//	생성자
	private Singleton() {
		
	}
}​

SingletonApp.java

 

package com.javaex.oop.staticmember;

public class SingletonApp {

	public static void main(String[] args) {
		Singleton s1 = new Singleton();	//	생성 불가
	}

}

 

  •  
  •  
  • static 블록에서 생성자 호출
    • Singleton.java
package com.javaex.oop.staticmember;

//	목표 : 어떤 상황에서든 단 한개의 인스턴스만 유지
public class Singleton {

	//	static 블록에서 생성자를 호출
	private static Singleton instance  =  new Singleton();
	
	//	생성자
	private Singleton(){
		
	}

	public static Singleton getInstance() {
		return instance;
	}
}​
  • SingletonApp.java
    package com.javaex.oop.staticmember;
    
    public class SingletonApp {
    
    	public static void main(String[] args) {
    //		private static s1 = new Singleton();	//	생성 불가
    		Singleton s1 = Singleton.getInstance();
    		Singleton s2 = Singleton.getInstance();
    		
    		//객체 주소가 같으면 같은 객체다.
    		System.out.println("s1, s2 같은 객체? " + (s1 == s2));
    	}
    
    }​

 

상속 ( Inheritance )

  • 클래스간 계층적 분리 및 관리 가능
  • 중복 상속을 제거한다. (오직 하나만 상속한다.)
    • ex) 엄마, 아빠 클래스 중 뭐 쓸까 고민,,하는거 안 해도 됨
  • 가급적으로는 상속 배제하도록
    • 상속의 깊이이가 길어지면 유지보수가 어려워진다. 
  • 최상위 클래스 : java.lang.Object
  • 자식 생성자에서 특별한 지시가 없으면 부모 클래스의 기본 생성자가 선택됨
    • 부모의 특정 생성자 사용시에는 명시 해줘야한다. -> super(x,y);
  • 부모의 필드나 메서드에 접근시에는 super 키워드 사용

 

메서드 오버라이딩 (Method Overriding)

  • 물려받은 것을 사용하지 않고, 다른 기능 사용하는 것
    • 같은 이름, 같은 리턴타입, 같은 시그너쳐
    • 부모 메서드 무시
  • @Overriding ( 일종의 지시자 )
    • 매서드 앞에 명시 -> 부모에게 메서드가 있는가?
      • 진짜로 오버라이딩 한 건가?
      • 컴파일러에게 맡김 
      • 시그너쳐 위반 했는지 안 했는지 
  • 객체를 참조하고자 할 때
    • 자식 객체를 부모 타입으로 참조할 수 있다. 
    • 부모 참조
      • person p1 = new Student( );
        • 참조 타입(person) 설계도 내의 메서드만 호출 가능
        • p1.getName( ) (O)
        • p1.getSchoolName( ) (X) -> person에 없음
        • p1.showInfo( ) -> 오브라이딩 된 자식 클래스의 메소드
    • 자기자신 타입으로 참조
      • Studnet s1 = new Student( );
        • s1.getName( ) (O)
        • s1.getSchoolName( )
        • s1.showInfo( ) -> 자기자신의 오버라이딩 된 메소드
    • 다형성의 일부
      • ex) 주소록을 만들 때, 
        • Student[] s = new Studnet[3];
        • s[0] = new Student( );
        • s[1] = new Student( );
        • s[2] = new Person( ); -> 안 됨
      • ex2 ) 주소록
        • Person p[] = new Person[3];
        • p[0] = new Student( );
        • p[1] = new Student( );
        • p[2] = new Person( ); (O)
    • 부모 타입으로 자식객체를 참고할 수 있다.
    • override해도 부모의 메소드 사라지지 않는다.
    • point.v4패키지
      • Point.java
        package point.v4;
        
        //	v4. 상속
        public class Point {
        	protected int x;
        	protected int y;
        	
        	//	기본 생성자 : 매개 변수가 없는
        //	public Point() {
        //		
        //	}
        //	
        	//	전체 필드 초기화 생성자
        	public Point(int x, int y) {
        		this.x = x;
        		this.y = y;
        	}
        	
        	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;
        	}
        	public void draw() {
        		System.out.printf("점[x=%d, y=%d]을 그렸습니다.\n",x,y);
        	}
        	
        	//메서드 오버로딩
        	//매개변수 타입, 갯수, 순서가 같은 이름의 메서드 
        	public void draw(boolean bDraw) {
        		String message = String.format("점[x=%d, y=%d]을 ", x, y);
        		if(bDraw) {	//	true라면
        			message += "그렸습니다.";
        		}else {
        			message += "지웠습니다.";
        		}
        		System.out.println(message);
        	}
        }​
      • ColorPoint.java
        package point.v4;
        
        //	상속
        public class ColorPoint extends Point{
        	private String color;
        	
        	//	생성자
        	public ColorPoint(int x, int y, String color) {
        		super(x,y);
        		this.color = color;
        	}
        	
        	@Override	//	컴파일러에게 이 메서드가 오버라이딩한 메서드인지 확인
        	public void draw(boolean bDraw) {
        		//부모로부터 물려 받은 메서드를 덮어 쓰기
        		String message = String.format("색깔점[x = %d, y = %d, color = %s]을 ",
        				x, y, color);
        		message += bDraw ? "그렸습니다.":"지웠습니다";
        		
        		System.out.println(message);
        		
        		//부모의 메서드 호추하려면
        		super.draw(bDraw);
        	}
        }​
      • PointApp.java
        package point.v4;
        
        public class PointApp {
        	public static void main(String[] args) {
        		Point p = new Point(4,4);
        		
        		p.setX(10);
        		p.setY(20);
        		p.draw();
        		p.draw(true);
        		p.draw(false);
        		
        
        		Point p2 = new Point(60,40);
        		p2.draw();
        		p2.draw(true);
        		p2.draw(false);
        		
        		ColorPoint cp1 = new ColorPoint(10,20,"RED");
        		cp1.draw(true);
        
        		//	다형성 : 부모타입으로 자식객체 참조
        		Point cp2 = new ColorPoint(30, 40,"RED");
        		cp1.draw(true);
        	}
        }​
    • 위의 같은 경우에서 point.java의 매개변수 없는 생성자와, ColorPoint의 매개변수 없는 생성자를 만들고 실행시키면, point 생성자 먼저 실행되고, ColorPoint 생성자가 실행된다. 
    • 그렇지만, Point의 생성자를 만들지 않고 ColorPoint의 생성자를 만들면 오류생긴다. 

 

업캐스팅, 다운 캐스팅

특정 객체 다운 캐스팅 할 때, instanceof로 확인해라.

 

casting 패키지

Animal.java

package com.javaes.oop.casting;

public class Animal {
	protected String name;
	
	//	생성자
	public Animal(String name) {
		this.name = name;
	}
	
	public void eat() {
		System.out.println(name + " is eating");
	}
	
	public void walk() {
		System.out.println(name + " is walking");
	}
}

Dog.java

package com.javaes.oop.casting;

public class Dog extends Animal{
	//생성자 Animal 없어서 오류났음 -> 생성자 ㅏ만들어줘야 함
	public Dog(String name) {
		//부모생성자의 일부 호출해줘야한다. 
		super(name);
	}
	
	public void bark() {
		System.out.println(name + ": 멍멍!");
	}
}

Cat.java

package com.javaes.oop.casting;

public class Cat extends Animal{
	public Cat(String name) {
		super(name);
	}
	
	public void meow() {
		System.out.println(name + ": 야옹!");
	}
}

AnimalApp.java

package com.javaes.oop.casting;

public class AnimalApp {
	public static void main(String[] argv) {
		//	업 캐스팅, 다운 캐스팅
		Dog dog1 = new Dog("스누피");
		dog1.eat();
		dog1.walk();
		dog1.bark();
		
		//	업 캐스팅 : 참조 자료형에 있는 설계된 멤버에만 접근 가능
		Animal dog2 = new Dog("아지");
		dog2.eat();
		dog2.walk();
//		dog.bark();	//오류남
		
		//	다운 캐스팅
		//	animal -> dog로
		((Dog)dog2).bark();	//	일시적으로 변환
		
		
		//	업 캐스팅
		Animal cat1 = new Cat("야옹이");
		cat1.eat();
		cat1.walk();
//		((Dog)cat1).bark();//	오류남,,-> cat과 Dog 서로 캐스팅 안 됨
		
		if(cat1 instanceof Dog) {	//cat1이 Dog의 인스턴스인가?
			((Dog)cat1).bark();
		}else if(cat1 instanceof Cat){	// 	cat1이 Cat의 인스턴스?
			((Cat)cat1).meow();
		}
		
//		Dog[] pets = new Dog[3];
		Animal[] pets = new Animal[3];
		pets[0] = dog1;
		pets[1] = (Dog)dog2;
		pets[2] = new Dog("멍멍이");
//		pets[3] = new Cat("아즈라엘");// 오류남
		
		for(Animal pet : pets) {
			pet.eat();
			pet.walk();
			
			if(pet instanceof Dog) {
				((Dog)pet).bark();
			}else if(pet instanceof Cat)
				((Cat)pet).meow();
			
		}
		
	}
}
  • 다운 캐스팅 : 자료형에 있는 설계된 멤버만 접근 가능 
    • Animal dog2 = new Dog()
    • 이면, Dog에만 있는 dark()는 오류가 난다.
  • 같은 부모를 상속하는 자녀 사이에 캐스팅이 안 된다.
    • Cat과 Dog는 서로 캐스팅이 안 됨
  • Dog[] pets = new Dog[3];을 한 뒤,
  • pets[3] = new Cat() -> 오류난다. 
    • Dog객체에 Cat을 넣었기 때문.

 

 

 

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

인터페이스  (0) 2021.12.07
예외  (0) 2021.12.07
추상 클래스  (0) 2021.12.07
[모의 필기테스트] 오답노트 & 정리  (0) 2021.12.07
[DAY+2]Java Programming  (0) 2021.12.03

어노테이션?

@기호를 사용해서 음 내 생각인데 음 아마,, 어,, 뭔가 유지 관리가 편함

한번에 설정해서 그런지 뭐라지 내 이해로는 표가 있으면 한 행을 다 한번에 설정해서 좋아보임

public static String[] one(){
	return new String[]{"번호", "이름", "가격"};
}
public Object[] getData(){
	return new Object[]{productNo, productName, price};
}

public static int[] getWidth(){
	return new int[]{100, 400, 200};
}

이게 

public class ProductVo{
	@Grid(name = "번호", width = 100, order = 1)
    private String productNo;
    
    @Grid(name = "이름", width = 400, order = 2)
    private String productName;
    
    @Grid(name = "단가", width = 200, order = 3)
    private String price;
}

이렇게 바뀜

 

 

다시 돌아가서, 

(Desc.java)

package object_1;

import java.lang.annotation.*;
/** 
 * toString()을 위한 @Desc어노테이션
 * */

@Retention(RetentionPolicy.RUNTIME)	//	자바 로딩 된 후에도 어노테이션 사용하겠어
@Target(ElementType.FIELD)	//	해당 어노테이션을  전연변수에만 사용하겠다.
public @interface Desc{
	public String name();	// @Desc(name = "속성명")사용 가능하게 타입 정의
}

 

(DefaultVo.java)

package object_1;

import java.lang.reflect.Field;
public class DefaultVo {
	@Override
	public String toString() {
		
		//StringBuffer 클래스 객체 생성 : 문자열 자료 저장하기 위함
		StringBuffer sb = new StringBuffer();
		
		//문자열에 Class 객체생성, 클래스 정보 저장
		Class<? extends DefaultVo> clazz = this.getClass();
		sb.append(clazz.getName() + "정보");
		
		//Field 목록 객체 생성
		Field[] declaredFields = clazz.getDeclaredFields();
		for(Field f : declaredFields) {
			if(f != null) {
				//변수 조회
				String name = f.getName();
				String desc = "";
				
				//@Desc 어노테이션에 명시된 name()값 조회 : 필드 항목명
				Desc anno = f.getDeclaredAnnotation(Desc.class);
				if(anno != null) {desc = anno.name();}
				
				//전역 변수 값 조회
				String value = "";
				try {
					//접근 권한 부여 -> 전역변수 값 조회 -> 접근 권한 복원
					boolean accessible=f.isAccessible();
					f.setAccessible(true);
					Object obj = f.get(this);
					if(obj != null) { value = obj.toString();}
					f.setAccessible(accessible);
				}catch(IllegalArgumentException e) {e.printStackTrace();
				}catch(IllegalAccessException e) {e.printStackTrace();}
				
				
				//앞 문자열에 name, value, desc의 정보를 갖는 문자열 추가
				sb.append("\r\n\t" + name + " = "+ value + " ["+ desc + "]");
				
			}
		}
		return sb.toString();
	}
}
  • @Override : 부모 클래스가 가지고 있는 함수를 재정의 한다. 
    • 재정의 된 로직이 실행됨
  • toString() : Object 클래스가 가지고 있는 함수
    • System.out.println이 실행될 때, 객체 toString()함수를 호출함 -> 객체를 Stirng 타입으로 반환해줌
  • StringBuffer() : 문자열 정보 관리

음 Desc에 저장되어 있는거 String으로 반환하려고 만든 거.

신기한건, <? extends DefaultVo>인데,, 클래스 정보가 저장이 되나봐

<? extend Object> 는 어떤 자료형의 객체도 매개변수로 받겠다는 의미라고 한다.

 

 

(ProductVo.java)

package object_1;

public class ProductVo extends DefaultVo{
	//전역 변수 정의
	@Desc(name = "품목번호")
	private String productNo;
	
	@Desc(name = "품목명")
	private String productName;
	
	@Desc(name = "단가")
	private int price;
	
	//getter setter 함수의 정의
	public String getProductNo() {return productNo;}
	public void setProductNo(String productNo) {
		this.productNo = productNo;
	}
	
	public String getProductName() {return productName;}
	public void setProductname(String productName) {
		this.productName = productName;
	}
	public int getPrice() {return price;}
	public void setPrice(int price) {this.price =price;}	
}

Desc 정보 저장.

 

(MemberVo.java)

package object_1;

public class MemberVo extends DefaultVo{
	
	//전역 변수 정의
	@Desc(name ="회원아이디")
	private String memberld;
	
	@Desc(name = "회원명")
	private String memberName;
	
	
	//getter sater함수 정의
	public String getMemberld() {return memberld;}
	public void setMemberld(String memberld) {this.memberld = memberld;}
	public String getMemberName() {return memberName;}
	public void setMemberName(String memberName) {
		this.memberName = memberName;
	}
}

 

(TestMain.java)

package object_1;

public class TestMain {
	public static void main(String [] args) {
		//prodectVo 객체 생성 -> 속성 설정 -> 객체정보 조회
		ProductVo v1 = new ProductVo();
		v1.setPrice(1000);
		v1.setProductname("아메리카노");
		v1.setProductNo("a001");
		System.out.println(v1);
		
		//MemberVo 객체 생성 -> 속성 설정 -> 객체 정보 조회
		MemberVo v2 = new MemberVo();
		v2.setMemberld("m001");
		v2.setMemberName("홍길동");
		System.out.println(v2);
	}
}

 

결과

 

음 실습 해보니깐 어노테이션 좀 알 것 같기도 하고,,

근데 막상 짜보라고 하면,, 

한번 실습 해보고싶다. 문제 줘서

ㅎㅎㅎ

get, set도 알겠당

 

근데 패키지가 너무 신기하네,, 패키지 안에만 있으면 import안 해도 다 연결이 되나봐,, 

 

 

출처 : 자바 프로그래밍 100% 실전 가이드 세트(애프터스킬 시리즈)(전2권) | 심상원 | 아이콕스 - 교보문고 (kyobobook.co.kr) -> 391~ 397쪽

 

 

'study > java' 카테고리의 다른 글

Error querying database. Cause: java.lang.UnsupportedOperationException  (0) 2022.02.05
[Tomcat] 설치 및 eclipse 설정  (0) 2022.01.01
JAVA 상속  (0) 2021.12.04
[백준] 2750_수 정렬하기 (java)  (0) 2021.11.13
java Ajax 연습하기  (0) 2020.07.25

상속

Object 클래스

package Object;

import java.lang.reflect.*;
import java.util.*;

public class Practice {
	public static void main(String[] args) {
	
		Class clz = Practice.class;
		
		Class superClass = clz.getSuperclass();
		System.out.println("부모 클래스 : "+ superClass);
		
		Field[] fields = superClass.getDeclaredFields();
		for(Field f: fields) {
			System.out.println("전력변수  = "+ f.getName());
		}
		
		Method[] methods = superClass.getDeclaredMethods();
		for (Method m : methods) {
			String name = m.getName();
			String parameterTypes = Arrays.toString(m.getParameterTypes());
			System.out.println("함수 = "+ name+" : "+parameterTypes);
		}
	}
}

결과 : 

부모 클래스 : class java.lang.Object
함수 = finalize : []
함수 = wait : [long]
함수 = wait : [long, int]
함수 = wait : []
함수 = equals : [class java.lang.Object]
함수 = toString : []
함수 = hashCode : []
함수 = getClass : []
함수 = clone : []
함수 = notify : []
함수 = notifyAll : []
함수 = registerNatives : []

 

  • 부모 클래스 : class java.lang.Object
    • 상속이 없으면 Object클래스가 부모 클래스임
    • Object는 클래스들의 기본, 최상위 타입

 

- hashCode() 함수

  • 객체에 해시코드 값을 반환하는 함수
  • 해시코드란 : 객체를 구별하기 위한 값, 메모리 주소를 바탕으로 정수화된 값
    • 객체의 해시코드 값의 중복이 일어날 가능성이 있음 -> 중복이란 말이 똑같은 곳 가리킨다는 것인가??? 근데 주의라고 적혀있으면 뭐지

- toString()함수

  • 해당 객체의 정보를 문자열로 반환하는 함수
  • 객체 정보 : '클래스명@해시코드(16진수로)' -> 대부분 재정의를 하여 사용함
    package Object;
    
    public class PracticeHash_toString {
    	public static void main(String [] args) {
    		PracticeHash_toString a = new PracticeHash_toString();
    		int hashCode = a.hashCode();
    		
    		// int to 16진수 : Integer.toHexString
    		String hexHashCode = Integer.toHexString(hashCode);
    		String toString = a.toString();
    		
    		System.out.println("클래스정보 : " +toString + "\nHeshcode 값 : " + hexHashCode );
    	}
    }​
     
    • 결과
      클래스정보 : Object.PracticeHash_toString@7d6f77cc
      Heshcode 값 : 7d6f77cc

 

super, protected

  • 부모 클래스 : Practice_Parent
package Object;

public class Practice_Parent {
	
	//전역 변수
	protected String name = "parent";
	public int value = 1;
	private Type type = Type.A;
	
	//enum 타입
	public enum Type {A,B,C,D};
}
  • 자식 클래스 : Practice_child
package Object;

public class Practice_child extends Practice_Parent{
	//전역 변수
	private int value = 2;
	{
		//비교1
		System.out.println("name = " + name);	//	부모 필드
		System.out.println("value = " + value);	//	자식 필드
		
		//비교 2
		System.out.println("super.name = " + super.name);
		System.out.println("super.value = "+ super.value);
		
		//비교 2
		System.out.println("this.name = "+ this.name);	//부모 필드
		System.out.println("this.value = " + this.value);	//자식필드
		
		System.out.println("부모 클래스의 enum 접근" + Type.A);
		
	}
	
	public static void main(String[] args) {
		new Practice_child();
	}
}
  • 결과 
name = parent
value = 2
super.name = parent
super.value = 1
this.name = parent
this.value = 2
부모 클래스의 enum 접근A
  • 자식에 없는 변수를 부모꺼 씀
  • 만약 자식에도 변수가 있고, 부모에도 있다면 자식에서 사용시 자식꺼 먼저 사용함
  • 부모꺼 사용하고 싶을 땐, super이용
  • super없으면 부모보단 자식이 우선순위가 높음 (자식에서 사용할 때)

 

 

출처 : 

자바 프로그래밍 100% 실전 가이드 세트(애프터스킬 시리즈)(전2권) | 심상원 | 아이콕스 - 교보문고 (kyobobook.co.kr)

 

자바 프로그래밍 100% 실전 가이드 세트 - 교보문고

기본은 물론 응용까지 새로운 JAVA 필독서 | 단순히 웹 영역을 넘어 일반 응용 프로그래밍 분야에 이르도록 거의 모든 개발자들에게 필수 언어가 되어가고 있는 자바(Java)는 그 유연한 활용도만큼

www.kyobobook.co.kr

 

'study > java' 카테고리의 다른 글

[Tomcat] 설치 및 eclipse 설정  (0) 2022.01.01
JAVA 상속(2)  (0) 2021.12.04
[백준] 2750_수 정렬하기 (java)  (0) 2021.11.13
java Ajax 연습하기  (0) 2020.07.25
jfreechart bar그래프 두 개 그리기  (0) 2020.07.23
  • Java Development Environment
    • integrated Development Environment (IDE)
      • 통합 개발 환경
      • Eclipse, Netbeans, InteliJ IDEA

 

예약어와 식별자

  • 식별자
    • 명명 규칙에 따라야함
      1. 문자, $, _로 시작해야함
      2. 숫자로 시작할 수 없음
      3. 대,소문자 구분됨
      4. 예약어는 사용할 수 없음

 

변수와 자료형

  • 변수
    • 데이터를 다루는 상자 (공간)
  • 자료형
    • 기본 자료형
      • 변수를 사용하는 도중 변경할 수 없음
      • 최소 단위의 자료형
      • 메소드 없이 값만 가짐
      • ex) 
      • int score = 50;​
    • 참조형
      • 여러 자료형들의 집합
      • 클래스의 객체를 참조
      • 데이터 있을 수도 있고 없을 수도 있음
      • 데이터와 메소드를 가짐 
      • 상자보다는 짝대기라고 생각.
      • ex)
        String mStr = new mStr();​

 

 

 

 

 

 

 

 

이렇게 보면

H1과 H3가 같고

H2는 다르게 가르키는 것을 알 수 있다. 

 

 

 

 

 

 

  • 기본 자료형
    • 정수형
      • 가장 왼쪽 비트 : 부호
      • long > int > short
        public static void intLongEx() {
        		//byte(1) < short(2) < int(4:default) < long(8)
        		int intVar1;	//변수 선언
        		int intVar2;	//선언
        		
        		intVar1 = 2021;	//변수 초기화
        		//intVar2 = 1234567891234; 	//표현할 수 있는 범위 초과
        		
        		System.out.println(intVar1); 	//변수 값 조회
        		
        		long longVar1 = 2021;	// 선언 + 초기화
        		// long longVar2 = 1234567891234;	//오류
        		long longVar2 = 1234567891234L;		//	L (or l)추가
        		
        		
        		//	2진수, 8진수, 16진수
        		int bin, oct, hex;
        		bin = 0b1101;	//	2진수 0b
        		oct = 0721;		// 8진수 0
        		hex = 0xFF;		// 16진수 0x
        		
        //		결과 -> bin : 13, oct : 465, hex : 255
        		System.out.println("bin : " + bin + ", oct : " + oct + ", hex : "+ hex);
        		
        		
        	}
      • 문자형
        // 	문자형 타입 : 부호 없는 정수
        	private static void charEx() {
        		char ch1 = 'A';
        		char ch2 = '한';
        		
        		System.out.println(ch1);
        		System.out.println(ch2);
        		
        //		결과 -> ch1 4글자 뒤인 69가 나온다.
        		System.out.println(ch1+4);
        //		결과 -> ch1 4글자 뒤인 E가 나온다.
        		System.out.println((char)(ch1+4));
        	
        		
        	}​
    • 실수형 논리형
      • 실수형 
        • double :  정밀도 포기, 표현 범위만 넓어짐, 형 변환시 유실 일어남
        • 지수 표기법 (e) : 3E - 6F = 3 * 10^-6
          //	실수형 타입
          	private static void floatDoubleEx() {
          		//	float(4) < double(8)
          		// 	정밀도 포기, 표현 범위 넓힌 것 -> 금융권 안 씀
          		
          		// float floatVar = 3.14159;	//오류
          		float floatVar = 3.14159F;	// 	float사용 시 뒤에 F or f 추가
          		double doubleVar = 3.14159;
          		
          		floatVar = 0.123456890123456789F;
          		doubleVar = 0.123456890123456789;
          		
          //		결과 -> float : 0.12345689, Double : 0.12345689012345679
          		//	둘 다 오차가 있음, double은 수용범위 안에서 반올림 한다.
          		System.out.println("float : "+ floatVar + ", Double : " + doubleVar);
          		
          //		결과 -> 0.30000000000000004
          		System.out.println(0.1*3);
          		
          		
          		//지수 표기법(e)
          		floatVar = 3E-6F;	// 3 * 10 ^ -6
          		System.out.println(floatVar);
          		
          	}​
      • 논리형
        • C처럼 boolean 값을 값으로 하지 않는다. 
        • true/false 그 자체로 저장이 가능하다.
          //	논리형 : 참 or 거짓
          	private static void booleanEx() {
          		boolean b1 = true;
          		boolean b2 = false;
          		
          		System.out.println(b1);
          		System.out.println(b2);
          		
          		boolean result;
          		
          		int var1 = 3;
          		int var2 = 5;
          		
          		result = var1 < var2;	//비교 결과 넣기
          //		결과 -> 3 < 5 = true
          		System.out.println(var1 + " < " + var2 + " = " + result);
          	}​
  • 상수와 형변환
    • 상수
      • 변경할 수 없는 고정된 데이터
      • 코드의 이해와 변경이 쉬움
      • final 로 선언 ( 선언과 동시에 할당)
        1. final class : 상속 불가
        2. final 메소드 : 오버라이딩 불가 (재사용)
      • 대문자로 표현한다. 
      • ex)
        int SPEED = 110;​
        스피드의 값을 함수안에서 SPEED로만 가지고 사용하면
        1. 코드 가독성이 좋아짐
        2. 유지보수 종속성이 높아짐
        3. 안정성
    • 형 변환
      • byte(1) < short, char (2) < long (8) < float (4) < double (8) 
      • 암묵적 형변환
        //	형 변환(Promotion)
        	private static void promotionEx() {
        // 1. 암묵적 형 변환
        	//	표현 범위 좁은 자료 -> 표현 범위가 넓은 자료
        	//	자동으로 변환 promation
        		byte b = 25;	//1바이트 정수
        		System.out.println(b);
        		
        		short s = b;	//	2바이트 정수
        		
        		int i = s;	//	4바이트 정수
        		System.out.println(i);
        		
        		float f = i;	//	4바이트 실수
        		System.out.println(f);	
        	}​
        • 표현범위가 작은 곳에서 큰 곳으로 할당
      • 강제 형 변환
        • 큰 자료형에서 작은 자료형
          // 2. 강제 형 변환 (Casting)
          	private static void castingEx() {
          	//	표현 범위가 넓은 자료 -> 표현 범위 좁은 자료
          	//	명시적으로 변환 해줘야 함
          		float f = 123.456f;
          		System.out.println(f);
          		
          		//int i = f;	//오류
          		int i = (int)f;
          		System.out.println(i);	//123
          		
          		int i2 = 1234567890;
          		System.out.println(Integer.toBinaryString(i2));	//1001001100101100000001011010010
          
          		short s = (short)i2;
          		System.out.println(Integer.toBinaryString(s));	//1011010010
          		
          		//주의점 : 형 변환 시 자료 유실이 일어날 수 있으므로 주의
          		
          	}​

연산자와 문자열

  • 연산자
    • 순위
      1. 함수
      2. 산술연산 -> 비교연산-> 논리연산
      3.  .....
      4. 할당연산자
    • 산술 연산자
      //	산술 연산자
      	private static void arithOperEx() {
      		int a = 7;
      		int b = 3;
      		
      		//부호 연산자 (+,-)
      		System.out.println(-a);	// -1 * a
      		
      		//	산술 연산자 (+, -, *, /, %)
      		System.out.println(a / b);	//	int / int = int(몫)
      		System.out.println(a % b); //	정수 나눗셈의 나머지
      		
      //		System.out.println(a / 0);	//	에러 발생 (정수 나누기 0은 무한대라서)
      		System.out.println(7.0 / 0); //	Infinity(무한대)
      		System.out.println(7.0 / 0 + 100); // 	Infinity가 포함된 산술식 : 무한대
      		
      		//	어떤 값이 Infinity인지 체크
      		System.out.println(Double.isInfinite(7.0 / 0));	// 	true
      		
      		//	연산 결과값이 수치가 아닌 경우 (Not a Number) 체크
      		System.out.println(0.0 / 0.0);	//	NaN
      		System.out.println(Double.isNaN(7.0 / 0));	//	false -> 무한대라서 NaN아님
      		
      	}​
    • 전위 증감 연산
      //전위 증감
      	private static void prefixIncrEx() {
      		int a = 7;
      		int b = 0;
      		
      		b = ++a;
      		System.out.println("b : " + b);		// 8
      		System.out.println("a : " + a);		// 8
      	}​
    • 후위 증감 연산
      //	후위 증감 연산
      	private static void suffixIncrEx() {
      		int a = 7;
      		int b = 0;
      		
      		b = a++;
      		System.out.println("b : " + b);		// 7
      		System.out.println("a : " + a);		// 8
      	}​
    • 비교, 논리 연산
      //	비교, 논리 연산
      	private static void logicalOperEx() {
      		//	비교 연산자 : >, >=, <=, ==(equal), !=(not equal)
      		//	논리 연산자 : 논리곱 (AND, &&), 논리합(OR, ||), 논리 부정 (NOT, !)
      		int a = 5;
      		//	a가 0초과, 10미만의 값?
      		//	조건 1 : a > 0
      		//	조건 2 : a < 10
      		//	결과 : 조건1 AND 조건2
      		boolean b1 = a > 0;
      		boolean b2 = a < 10;
      		
      		boolean r = b1 && b2;
      		System.out.println("b1 && b2 = " + r);	//	true
      		
      		
      		//	10이상, 0이하
      		//	조건 1 : a <= 0
      		//	조건 2 : a >= 10
      		b1 = a <= 0;
      		b2 = a > 10;
      		r = b1 || b2;
      		System.out.println("b1 || b2 = " + r);	//false
      		
      		//	논리 부정 (NOT !)
      		System.out.println("!r == " + !r);	//true
      		
      	}​
    • 비트 연산자
      //비트 연산자
      	private static void bitOperEx() {
      		// int에서만
      		// 비트 단위의 미세한 제어에 이용
      		int b1 = 0b11011101;
      		int mask = 0b10101010;
      		
      		System.out.println(Integer.toBinaryString(b1));
      		System.out.println(Integer.toBinaryString(mask));
      		
      		System.out.println(Integer.toBinaryString(b1 & mask));	//비트 논리 곱
      		System.out.println(Integer.toBinaryString(b1 | mask));	//비트 논리 합
      		System.out.println(Integer.toBinaryString(~b1));	//비트 논리부정
      		
      	}​
    • 비트 시프트
      //비트 시프트
      	private static void bitshiftOperEx() {
      		int val = 1;
      		System.out.println(Integer.toBinaryString(val));
      		//왼쪽으로 3비트 시프트
      		System.out.println(Integer.toBinaryString(val<<3));
      		
      		int val1 = 0b1000;
      		System.out.println(Integer.toBinaryString(val1));
      		System.out.println(Integer.toBinaryString(val1>>2));
      	}​
    • 삼항 연산자
      //3항 연산자
      	private static void conditionalOperEx() {
      		int a = 10;
      		//	a가 짝수면 짝수, 홀수면 홀수 출력
      		System.out.println(a + "는 " + (a % 2 == 0? "짝수":"홀수"));
      		
      		int score = 49;
      		String message;
      		//	점수가 90점 이상이면 Good, 50점 미만이면 Fails, 아니면 Pass
      		System.out.println(score + "는 " + (score > 90? "Good":score < 50? "Fails":"Pass"));
      		
      	}​
  • 콘솔 입출력
    • 콘솔 출력
      private static void consoleOutputEx() {
      		//	System.out.print : 개행 안 함
      		//	System.out.println : 개행함
      		//	System.out.printf : 형식 지정 문자열 출력 -> String.format
      		
      		System.out.print("print : 개행 안 함");
      		System.out.println(" println : 개행함");
      		
      		
      		//	이스케이프 문자
      		//	\n(개행), \t(탭문자), \"(따옴표), \\(역슬래시)
      		System.out.println("Hello\n Java");	//	개행
      		System.out.println("Hello\t Java");	//	탭 문자
      		System.out.println("Hello \"Java\"");	//	따옴표 
      		
      		String dir = "C:\\User\\Bit\\Desktop";
      		System.out.println(dir);
      	}​
    • 콘솔 입력
      //	콘솔 입력
      	private static void consoleInputEx() {
      		Scanner scanner = new Scanner(System.in);
      		System.out.print("이름 : ");
      		String name = scanner.next();
      		System.out.print("나이 : ");
      		int age = scanner.nextInt();
      		
      		System.out.println("당신의 이름은 "+ name+ ", 나이는 "+ age + "입니다.");
      		scanner.close();
      	}​

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

인터페이스  (0) 2021.12.07
예외  (0) 2021.12.07
추상 클래스  (0) 2021.12.07
[모의 필기테스트] 오답노트 & 정리  (0) 2021.12.07
java Class  (0) 2021.12.06

자바 공부하기 위해 한번 작성하면서 공부를 해보겠다.

 

https://www.acmicpc.net/problem/2750

 

2750번: 수 정렬하기

첫째 줄에 수의 개수 N(1 ≤ N ≤ 1,000)이 주어진다. 둘째 줄부터 N개의 줄에는 수 주어진다. 이 수는 절댓값이 1,000보다 작거나 같은 정수이다. 수는 중복되지 않는다.

www.acmicpc.net

 

정렬부터 시작했는데, 

먼저 첫 번째는 

Arrays함수를 사용해서 sort함수 이용해서 했다. ㅎㅎㅎㅋㅋㅋㅋ

import java.util.*;

public class Main{
	public static void main(String args[]){
		Scanner scanner = new Scanner(System.in);
		int N= scanner.nextInt();
		int array[] = new int[N];
		for(int i = 0; i<N; i++) {
			array[i]= scanner.nextInt();
		}
		Arrays.sort(array);
		for(int i = 0; i<N; i++)
			System.out.println(array[i]);
	}
}

뭐 함수를 써보긴 해야 하니깐,, 

 

 

두 번째는 

버블 정렬을 사용했다. 

import java.util.*;
//버블 정렬
public class Main{
	public static void main(String args[]){
		Scanner scanner = new Scanner(System.in);
		int N= scanner.nextInt();
		int array[] = new int[N];
		for(int i = 0; i<N; i++)
			array[i]= scanner.nextInt();
		
		for(int i = 0; i<N-1; i++) {
			for(int row = 0, tem = 0; row <N-1-i; row++) {
				if(array[row] > array[row+1]) {
					tem = array[row];
					array[row] = array[row+1];
					array[row+1] = tem;
				}
			}
		}
		for(int i = 0; i<N; i++)
			System.out.println(array[i]);
	}
}

 

선택정렬

package backjoon;

import java.util.*;
//버블 정렬
public class Main{
	public static void main(String args[]){
		Scanner scanner = new Scanner(System.in);
		int N= scanner.nextInt();
		int array[] = new int[N];
		for(int i = 0; i<N; i++)
			array[i]= scanner.nextInt();
		
		for(int i = 1,j; i<N;i++) {
			int compare_num = array[i];
			for(j = i-1; j>=0 && array[j]>compare_num; j--)
				array[j+1] = array[j];
			array[j+1] = compare_num;
			}
		for(int i = 0; i<N; i++)
			System.out.println(array[i]);
	}
}

 

확실히 정렬을 오랜만에 만들어보는데

저학년일 때보다는 낫다,,

 

더 해보자,, 

'study > java' 카테고리의 다른 글

[Tomcat] 설치 및 eclipse 설정  (0) 2022.01.01
JAVA 상속(2)  (0) 2021.12.04
JAVA 상속  (0) 2021.12.04
java Ajax 연습하기  (0) 2020.07.25
jfreechart bar그래프 두 개 그리기  (0) 2020.07.23

+ Recent posts