'study/JAVA 전문가' 카테고리의 글 목록 (6 Page)

study/JAVA 전문가

추상 클래스

2021. 12. 7. 10:36

추상클래스

코드 만들 때 중요한 정보와 그렇지 않은 정보를 구분해서 설계해야 함
공통 속성을 뽑아냄 (일반화)
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

[모의 필기테스트] 오답노트 & 정리

2021. 12. 7. 00:05

클래스 선언 불가 : protected, private

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

try catch문 그 다음 finally가 있음

finally는 무조건 실행 되는 친구

String

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

Static

Static변수는 메인 안에 선언X
1. 지역 변수에 static 못 붙음
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

java Class

2021. 12. 6. 15:58

- 클래스의 구조

필드

객체 데이터, 상태 저장하는 변수
멤버 변수
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

[DAY+2]Java Programming

2021. 12. 3. 00:47

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

PREV 1 ···3 4 5 6 NEXT

iridescent