본 게시글은 혼자 공부하는 자바 (저자 : 신용권)의 책과 유튜브 영상을 참고하였고, 개인적으로 정리하는 글임을 알립니다.

기본 타입(기본 자료형)의 타입 변환(형 변환)에는 자동 타입 변환이 있고, 강제 타입 변환이 있다.

클래스에도 이러한 타입 변환이 있다.

메소드 재정의(오버라이딩)와 타입 변환을 이용하면 객체 지향 프로그래밍의 매우 중요한 특징인 다형성을 구현할 수 있다.

다형성은 사용 방법은 동일하지만 다양한 객체를 이용해서 다양한 실행결과가 나오도록 하는 성질이다. 예를 들어 자동차가 타이어를 사용하는 방법은 동일하지만 어떤 타이어를 장착하느냐에 따라 주행 성능이 달라질 수 있다.

어떤 타이어는 고속주행에 유리한 타이어이고, 또 다른 타이어는 눈길에서 미끄러지지 않고 주행할 수 있는 타이어가 있듯이 말이다.

다형성을 구현하려면 오버라이딩과 타입 변환이 필요하다.

자동 타입 변환(Promotion)

클래스의 변환은 상속 관계에 있는 클래스 사이에서 발생한다. 자동 타입 변환은 프로그램 실행 도중에 자동적으로 타입 변환이 일어나는 것을 말하는데 자동 타입 변환은 아래와 같은 조건에서 일어난다.

Parent a = new Child();
또는
b = new Child();
parent a = b;

즉, 자식 타입 객체만이 부모타입으로 자동 타입 변환이 일어날 수 있다. Child 클래스로 부터 Child객체를 생성하고 이것을 Parent 변수에 대입하면 자동 타입 변환이 일어난다.

자동 타입 변환의 개념은 자식은 부모의 특징과 기능을 상속받기 때문에 부모와 동일하게 취급될 수 있다는 것이다. 예를 들어, 고양이가 동물의 특징과 기능을 상속받았다면 '고양이는 동물이다.'가 성립한다. 

위 그림에서 알 수 있듯이, a는 부모 타입이므로 부모 객체를 참조하는 것이 맞지 않느냐라고 생각할 수도 있지만 그렇지 않고, a와 b 모두 자식 객체를 참조한다.

또한 바로 위의 부모가 아니더라도 상속 계층에서 상위 타입이라면 자동 타입 변환이 일어날 수 있다.

D객체는 B와 A 타입으로 자동 타입 변환이 될 수 있고, E 객체는 C와 A 타입으로 자동 타입 변환이 될 수 있다. 그러나 D 객체는 C 타입으로 변환될 수 없고, 마찬가지로 E 객체는 B타입으로 변환될 수 없다. 상속관계가 아니기 때문이다.

package TestPackage;
class A{}

class B extends A{}
class C extends A{}

class D extends B{}
class E extends C{}

public class Test {
	public static void main(String[] args) {
		B b = new B();
		C c = new C();
		D d = new D();
		E e = new E();		
		
		A a1 = b;
		A a2 = c;
		A a3 = d;
		A a4 = e;
		
		B b1 = d;
		C c1 = e;

		B b3 = e; //상속 관계가 아니므로 컴파일 에러 발생
		C c2 = d; //상속 관계가 아니므로 컴파일 에러 발생
	}
}

다형성과 관련있는 중요한 자동 타입 변환의 성질
부모 타입으로 자동 타입 변환된 이후에는 부모 클래스에 선언된 필드와 메소드만 접근이 가능하다. 변수는 자식 객체를 참조하지만 변수로 접근 가능한 멤버는 부모 클래스 멤버로만 한정된다. 그러나 예외가 있는데, 메소드가 자식 클래스에서 재정의되었다면 자식 클래스의 메소드가 대신 호출된다.

Parent.java

package TestPackage;
public class Parent {
	public void method1() {
		System.out.println("Parent-method1()");
	}
	
	public void method2() {
		System.out.println("Parent-method2()");
	}
}

Child.java

package TestPackage;
public class Child extends Parent {
	@Override
	public void method2() {
		System.out.println("Child-method2()");
	}
	
	public void method3() {
		System.out.println("Child-method3()");
	}
}

Test.java

package TestPackage;
public class Test {
	public static void main(String[] args) {
		Child child = new Child();

		  Parent parent = child;

		  parent.method1();

		  parent.method2();

		  //parent.method3();  (호출 불가능)
	}
}
/*
Parent-method1()
Child-method2()
*/

필드의 다형성

자동 타입 변환을 하는 이유는 다형성을 구현하기 위해서이다.

필드의 타입을 부모 타입으로 선언하면 다양한 자식 객체들이 저장될 수 있기 때문에 필드 사용 결과가 달라질 수 있다.

이것이 필드의 다형성이다.

예를 들어
자동차를 구성하는 부품은 언제든지 교체할 수 있다. 부품은 고장이 날 수도 있고 성능이 더 좋은 부품으로 교체되기도 한다. 객체지향 프로그래밍에서도 마찬가지이다.
이를 자동차 클래스에 포함된 타이어 클래스를 생각해보면 자동차 클래스를 처음 설계할 때 사용한 타이어 객체는 언제든지 성능이 좋은 타이어 객체로 교체할 수 있어야 한다. 새로 교체된 타이어 객체는 기존 타이어와 사용 방법은 동일하지만 실행결과는 더 우수하게 나와야 할 것이다. 이것을 프로그램으로 구현하기 위해서 상속과 오버라이딩, 타입 변환을 이용한다.

Tire.java(부모 클래스)

package TestPackage;
public class Tire {
	
		public int maxRotation; //최대 회전수(타이어 수명)
		public int accumulatedRotation;	//누적 회전수
		public String location; //타이어 위치

		//생성자
		public Tire(String location, int maxRotation) {
			this.location = location;
			this.maxRotation = maxRotation;
		}

		public boolean roll() {
			++accumulatedRotation;	//누적 회전수 1 증가
			if(accumulatedRotation<maxRotation) {
				System.out.println(location + " Tire 수명: " + (maxRotation-accumulatedRotation) + "회");
				return true;
			} else {
				System.out.println("*** " + location + " Tire 펑크 ***");
				return false;
			}
		}
}

HankookTire.java(자식 클래스)

package TestPackage;
public class HankookTire extends Tire{
		//생성자
		public HankookTire(String location, int maxRotation) {
			super(location, maxRotation);
		}	

		@Override
		public boolean roll() {
			++accumulatedRotation;		
			if(accumulatedRotation<maxRotation) {
				System.out.println(location + " HankookTire 수명: " + (maxRotation-accumulatedRotation) + "회");
				return true;
			} else {
				System.out.println("*** " + location + " HankookTire 펑크 ***");
				return false;
			}
		}
}

KumhoTire.java(자식 클래스)

package TestPackage;
public class KumhoTire extends Tire{
		//생성자
		public KumhoTire(String location, int maxRotation) {
			super(location, maxRotation);
		}	

		@Override
		public boolean roll() {
			++accumulatedRotation;		
			if(accumulatedRotation<maxRotation) {
				System.out.println(location + " KumhoTire 수명: " + (maxRotation-accumulatedRotation) + "회");
				return true;
			} else {
				System.out.println("*** " + location + " KumhoTire 펑크 ***");
				return false;
			}
		}
}

Car.java

package TestPackage;
public class Car {
		Tire frontLeftTire = new Tire("앞왼쪽", 6);
		Tire frontRightTire = new Tire("앞오른쪽", 2);
		Tire backLeftTire = new Tire("뒤왼쪽", 3);
		Tire backRightTire = new Tire("뒤오른쪽", 4);
		
		int run() {
			System.out.println("자동차 주행시작");
			if(frontLeftTire.roll()==false) { stop(); return 1; };
			if(frontRightTire.roll()==false) { stop(); return 2; };
			if(backLeftTire.roll()==false) { stop(); return 3; };
			if(backRightTire.roll()==false) { stop(); return 4; };
			return 0;
		}
		
		void stop() {
			System.out.println("자동차 정지");
		}
}

Test.java

package TestPackage;
public class Test {
	public static void main(String[] args) {
		Car car = new Car();
		
		for(int i=1; i<=5; i++) {
			int problemLocation = car.run();
			switch(problemLocation) {
				case 1:
					System.out.println("앞왼쪽 HankookTire로 교체");
					car.frontLeftTire = new HankookTire("앞왼쪽", 15);
					break;
				case 2:
					System.out.println("앞오른쪽 KumhoTire로 교체");
					car.frontRightTire = new KumhoTire("앞오른쪽", 13);	
					break;
				case 3:
					System.out.println("뒤왼쪽 HankookTire로 교체");
					car.backLeftTire = new HankookTire("뒤오른쪽", 14);	
					break;
				case 4:
					System.out.println("뒤오른쪽 KumhoTire로 교체");
					car.backRightTire = new KumhoTire("뒤오른쪽", 17);		
					break;
			}
			System.out.println("----------------------------------------");
		}
	}
}
/*
자동차 주행시작
앞왼쪽 Tire 수명: 5회
앞오른쪽 Tire 수명: 1회
뒤왼쪽 Tire 수명: 2회
뒤오른쪽 Tire 수명: 3회
----------------------------------------
자동차 주행시작
앞왼쪽 Tire 수명: 4회
*** 앞오른쪽 Tire 펑크 ***
자동차 정지
앞오른쪽 KumhoTire로 교체
----------------------------------------
자동차 주행시작
앞왼쪽 Tire 수명: 3회
앞오른쪽 KumhoTire 수명: 12회
뒤왼쪽 Tire 수명: 1회
뒤오른쪽 Tire 수명: 2회
----------------------------------------
자동차 주행시작
앞왼쪽 Tire 수명: 2회
앞오른쪽 KumhoTire 수명: 11회
*** 뒤왼쪽 Tire 펑크 ***
자동차 정지
뒤왼쪽 HankookTire로 교체
----------------------------------------
자동차 주행시작
앞왼쪽 Tire 수명: 1회
앞오른쪽 KumhoTire 수명: 10회
뒤오른쪽 HankookTire 수명: 13회
뒤오른쪽 Tire 수명: 1회
----------------------------------------
*/

매개 변수의 다형성

자동 타입 변환은 필드의 값을 대입할 때에도 발생하지만, 주로 메소드를 호출할 때 많이 발생한다.

메소드를 호출할 때에는 매개 변수의 타입과 동일한 매개값을 지정하는 것이 정석이지만, 매개값을 다양화하기 위해 매개 변수에 자식 객체를 지정할 수도 있다.

예를 들어 다음과 같이 Driver 클래스에는 drive() 메소드가 정의되어 있고 Vehicle 타입의 매개변수가 선언되어 있다.

public class Driver {
	void drive(Vehicle vehicle) {
		vehicle.run();
	}

dirve()메소드를 정상적으로 호출한다면 다음과 같다.

Driver driver = new Driver();
Vehicle vehicle = new Vehicle();
driver.drive(vihicle);

만약 Vehicle의 자식 클래스인 Bus 객체를 drive() 메소드의 매개값으로 넘겨주면

driver.drive(bus);

drive() 메소드는 Vehicle 타입을 매개 변수로 선언했지만, Vehicle을 상속받는 Bus 객체가 매개값으로 사용되면 자동 타입 변환이 발생한다.

매개 변수의 타입이 클래스일 경우, 해당 클래스의 객체뿐만 아니라 자식 객체까지도 매개값으로 사용할 수 있다는 것이다. 즉, 매개값으로 어떤 자식 객체가 제공되느냐에 따라 메소드의 실행결과는 다양해질 수 있다. 자식 객체가 부모의 메소드를 재정의했다면 메소드 내부에서 오버라이딩된 메소드를 호출함으로써 메소드의 실행결과는 다양해진다.

Vehicle.java(부모 클래스)

package TestPackage;
public class Vehicle {
	public void run() {
		System.out.println("차량 주행중");
	}
}

Bus.java(자식 클래스)

package TestPackage;
public class Bus extends Vehicle{
	@Override
	public void run() {
		System.out.println("버스 주행중");
	}
}

Taxi.java(자식 클래스)

package TestPackage;
public class Taxi extends Vehicle{
	@Override
	public void run() {
		System.out.println("택시 주행중");
	}
}

Driver.java

package TestPackage;
public class Driver {
	void drive(Vehicle vehicle) {
		vehicle.run();
	}
}

Test.java

package TestPackage;
public class Test {
	public static void main(String[] args) {
		Driver driver = new Driver();
		
		Bus bus = new Bus();
		Taxi taxi = new Taxi();
		
		driver.drive(bus);
		driver.drive(taxi);
	}
}
/*
버스 주행중
택시 주행중
*/

강제 타입 변환(Casting)

강제 타입 변환(Casting)은 부모 타입을 자식 타입으로 변환하는 것을 말한다.

강제 타입 변환의 조건은 자식 타입이 부모 타입으로 자동 타입 변환후 다시 자식 타입으로 변환할 때 강제 타입 변환을 할 수 있다.

Parent parent = new Child(); //자동 타입 변환
Child child = (Child)parent; //강제 타입 변환

자식 타입이 부모 타입으로 자동 타입 변환하면, 부모에 선언된 필드와 메소드만 사용가능하다는 제약 사항이 따른다.

만약 자식에 선언된 필드와 메소드를 꼭 사용해야 한다면 강제 타입 변환을 이용해서 다시 자식 타입으로 변환한 다음 자식의 필드와 메소드를 사용하면 된다.

Parent.java(부모 클래스)

package TestPackage;
public class Parent {
public String field1;
	
	public void method1() {
		System.out.println("Parent-method1()");
	}
	
	public void method2() {
		System.out.println("Parent-method2()");
	}
}

Child.java(자식 클래스)

package TestPackage;
public class Child extends Parent {
	public String field2;
	
	public void method3() {
		System.out.println("Child-method3()");
	}
}

Test.java

package TestPackage;
public class Test {
	public static void main(String[] args) {
		Parent parent = new Child();
		parent.field1 = "data1";
		parent.method1();
		parent.method2();
		/*
		parent.field2 = "data2";  //(불가능)
		parent.method3();         //(불가능)
		*/
		
		Child child = (Child) parent; //강제 타입 변환
		child.field2 = "yyy";  //(가능)
		child.method3();     //(가능)
	}
}
/*
Parent-method1()
Parent-method2()
Child-method3()
*/

객체 타입 확인

강제 타입 변환은 자식 타입이 부모 타입으로 변환되어 있는 상태에서만 가능하기 때문에 다음과 같이 처음부터 부모 타입으로 생성된 객체는 자식 타입으로 변환할 수 없다.

Parent parent = new Parent();
Child child = (Child)parent; //강제 타입 변환 불가능

실수로 이런식으로 강제 타입 변환을 하면 에러가 나기 때문에 타입 변환을 할 때 if문을 통해 예외를 처리해주는 것이 좋다.

부모 변수가 참조하는 객체가 부모 객체인지 자식 객체인지 확인하는 방법은 어떤 객체가 어떤 클래스의 인스턴스인지 확인하기 위해 instanceof 연산자를 사용한다.

좌항에는 객체가 오고 우항에는 타입이 오는데, 좌항의 객체가 우항의 인스턴스면, 즉 우항의 타입으로 객체가 생성되었다면 true를 리턴하고 그렇지 않으면 false를 리턴한다.

package TestPackage;
public class Test {
	public static void method1(Parent parent) {
		if(parent instanceof Child) { //예외처리를 한 메소드
			Child child = (Child) parent;
			System.out.println("method1 - Child로 변환 성공");
		} else {
			System.out.println("method1 - Child로 변환되지 않음");
		}
	}
	
	public static void method2(Parent parent) { //예외처리를 하지 않은 메소드
		Child child = (Child) parent;
		System.out.println("method2 - Child로 변환 성공");
	}
	
	public static void main(String[] args) {
		Parent parentA = new Child();
		method1(parentA);
		method2(parentA);
		
		Parent parentB = new Parent();
		method1(parentB);
		method2(parentB); //예외 발생
	}
}
/*
method1 - Child로 변환 성공
method2 - Child로 변환 성공
method1 - Child로 변환되지 않음
Exception in thread "main" java.lang.ClassCastException: class TestPackage.Parent cannot be cast to class TestPackage.Child (TestPackage.Parent and TestPackage.Child are in unnamed module of loader 'app')
	at TestPackage.Test.method2(Test.java:13)
	at TestPackage.Test.main(Test.java:24)
*/

java 12부터는 instanceof 연산의 결과가 true일 경우, 우측 타입 변수를 사용할 수 있기 때문에 강제 타입변환이 필요없다.

if(parent instanceof Child child){
	//child 변수 사용
}

Person.java

public class Person {
	//필드 선언
	public String name;

	//생성자 선언
	public Person(String name) {
		this.name = name;
	}

	//메소드 선언
	public void walk() {
		System.out.println("걷습니다.");
	}
}

Student.java

public class Student extends Person {
	//필드 선언
	public int studentNo;

	//생성자 선언
	public Student(String name, int studentNo) {
		super(name);
		this.studentNo = studentNo;
	}

	//메소드 선언
	public void study() {
		System.out.println("공부를 합니다.");
	}
}

Main.java

package ch07.sec09;

public class InstanceofExample {
	//main() 메소드에서 바로 호출하기 위해 정적 메소드 선언
	public static void personInfo(Person person) {
		System.out.println("name: " + person.name);
		person.walk();

		//person이 참조하는 객체가 Student 타입인지 확인
		/*if (person instanceof Student) {
 			//Student 객체일 경우 강제 타입 변환
 			Student student = (Student) person;
 			//Student 객체만 가지고 있는 필드 및 메소드 사용
 			System.out.println("studentNo: " + student.studentNo);
 			student.study();
 		}*/

		//person이 참조하는 객체가 Student 타입일 경우
		//student 변수에 대입(타입 변환 발생)
		if(person instanceof Student student) {
			System.out.println("studentNo: " + student.studentNo);
			student.study();
		}
	}

	public static void main(String[] args) {
		//Person 객체를 매개값으로 제공하고 personInfo() 메소드 호출
		Person p1 = new Person("홍길동");
		personInfo(p1);
		
		System.out.println();

		//Student 객체를 매개값으로 제공하고 personInfo() 메소드 호출
		Person p2 = new Student("김길동", 10);
		personInfo(p2);
	}
}
/*
name: 홍길동
걷습니다.

name: 김길동
걷습니다.
studentNo: 10
공부를 합니다.
*/

본 게시글은 유튜브 : 경제 TV 너무경 : 너무 쉬운 경제 윤성종 님의 유튜브 영상을 참고하였습니다. 개인적으로 정리하는  글임을 알립니다.

금융용어정리 - 원천징수, 연말정산

원천징수

미리 내는 부정확한 세금을 원천징수라 고한다.

원천징수의 사전적 정의
소득 또는 수입 금액을 지급하는 자(원천징수의무자)가 그 금액을 지급할 때, 상대방(원천납세의무자)이 내야 할 세금을 미리 징수하여 국가에 납부하는 조세 징수 방법 중의 하나이다.

'원천징수'란 소득 또는 수입 금액을 지급하는 자(원천징수의무자)가 그 대가를 지불할 때, 상대방(원천납세의무자)이 내야 할 세금을 미리 징수하여 국가에 납부하는 것이다. 이를 통해 국가는 세금이 누락되는 것을 방지하고, 세금 수입을 조기에 확보할 수 있다. 또한, 납세의무자 입장에서는 세금을 분할 납부함으로써 조세 부담을 완화하는 효과가 있다.
[네이버 지식백과] 원천징수 [Withholding tax] (두산백과 두피디아, 두산백과)

정확하게 세금을 계산하려면, 매월마다 월급에서 소득공제, 세액공제, 비과세소득 등을 계산해야 한다

이러한 과정을 매월마다 하는 것은 상당히 까다롭다.

그리하여 미리 월급에서 부정확한 세금을 지불하고 연말정산에서 제대로 된 세금을 계산하는 것이다.

예를 들어
A는 월급에서 원천징수로 10만 원씩을 지불하면, 1년이 지나면 120만 원을 지불하게 된다.
1년 동안 지불한 120만 원은 부정확한 세금이므로 연말정산에서 제대로 내야 할 세금을 계산하고
실제로 내야하는 세금이 90만원이면 30만원을 환급받고, 실제로 내야하는 세금이 130만원이면 10만원을 추징한다.

연말정산

원천징수 때 냈던 세금보다 실제로 내야 하는 세금이 더 있는지 아니면 환급을 받아야 하는지 정산하는 것이다.

또한 이름은 연말정산이지만 연말때 하는 것이 아니다. 올해 냈던 세금을 내년 연초에 정산하는 것이다.

연말정산의 사전적 정의
국세청에서 1년 동안 간이세액표에 따라 거둬들인 근로소득세를 연말에 다시 따져보고, 실소득보다 많은 세금을 냈으면 그만큼을 돌려주고 적게 거뒀으면 더 징수하는 절차를 말한다.

근로자의 봉급에 대한 세금은 매월 월급을 줄 때 그 소속기관이나 사업자(원천징수의무자)가 우선 원천징수하고, 전년도 1년분의 정확한 세금을 따져 다음 해 2월에 실제 부담할 세액을 정산하게 된다. 근로자는 연말정산을 하려면 소득ㆍ세액 공제 항목 관련 영수증과 증빙서류를 미리 준비하여 '소득공제 신고서'와 함께 사업자(원천징수의무자)에게 제출하여야 한다.
[네이버 지식백과] 연말정산 (시사상식사전, pmg 지식엔진연구소)

예를 들어
현재 이 글을 쓰고 있는 시기는 23년(올해) 연초이다.
22년(작년)에 지불했던 원천징수 금액과 실제로 내야 하는 세금을 계산해서 따져보고, 내가 세금을 더 냈다면 환급을 받고, 덜 냈다면 추가로 내야 한다.
대략 연초(1~3월)에 연말정산을 하고, 4월 즈음에 환급 또는 추징을 한다.
보통 근로자들은 추징보다 환급을 많이 받는다.

본 게시글은 유튜브 : 경제 TV 너무경 : 너무 쉬운 경제 윤성종 님의 유튜브 영상을 참고하였습니다. 개인적으로 정리하는  글임을 알립니다.

금융용어정리 - 소득공제, 세액공제

아래의 글을 먼저 읽고 오시는 것을 추천합니다.

2022.12.29 - [경제/금융용어] - 금융용어정리 - 소득공제, 과세표준, 세율, 세액

소득공제

소득 공제는 소득액을 산출하기 위해 총소득액에서 법으로 정해진 금액을 빼는 것을 말한다. 

소득 공제에는 기초 공제, 부양가족 공제, 의료비 공제 등이 있다
A와 B씨는 둘 다 연 소득이 3000만 원이라고 하면, 생활을 하는데 기본적으로 필요한 돈이 있을 것이다.
이러한 기본적으로 필요한 돈을 소득액에서 빼주는 것을 기초 공제라고 한다.
A씨는 혼자 살고, B씨는 부양하는 가족이 있는데 A, B 씨 모두 같은 세액을 부과하면 부당할 것이다.
그래서 그 만큼의 돈을 소득액에서 빼주는 것을 부양가족 공제라고 한다.
A, B 씨 모두 의료비로 지출한 돈이 있을 것이다. 이러한 의료비에 필요한 돈은 소득액에서
빼주는 것을 의료비 공제라고 한다.

공제의 목적

• 세금을 계산할 때 "필요경비"를 빼주기 위해서
• 저축, 기부, 투자를 유도하기 위해

어떤 기업이 연매출 100억이라고 하자

원가, 임대료, 유지관리비 등 회사 운영에 필요한 돈이 연 74억이라고 하면

연 매출 100억에 세금을 부과하는 것이 아니라 100억에서 필요 경비를 뺀 26억에 세금을 부과하는 것이다.

74억이 소득공제액이고, 26억이 과세표준이다.

이렇게 필요 경비를 빼주는 것은 기업뿐만 아니라 근로자에게도 마찬가지이다.

연소득에서 필요경비를 빼는 것이 소득공제이다.

소득공제도 종류가 매우 많다.

세액공제

과세 표준에 세율을 곱한 산출 세액에서 일정 금액을 아예 빼주는 것을 말한다.

세액공제종류는 매우 많다.(자녀세액공제, 연금계좌세액공제 등등)

소득공제 VS 세액공제

세액공제 금액이 50만 원이라고 하면

A씨는 연소득 1100만 원이고 산출 세액이 60만 원이다. 여기서 세액공제를 하면 납부 세액이 10만 원이다.

B씨는 연소득 1억 원이고 산출 세액이 2000만 원이다. 여기서 세액공제를 하면 납부 세액이 1950만 원이다.

->상대적으로 저소득층에 유리함

소득공제 금액이 1000만 원이라고 하면

A씨는 연소득 1100만 원이면 누진세율표에 의해 

1000만 원 X 0.06 = 60만 원의 세금이 감소된다.

자세한 설명
1100만 원(소득공제 전)을 누진세율 표에 의해 산출 세액을 계산하면
1100만 X 0.06 = 66만 원
100만 원(소득공제 후)을 누진세율 표에 의해 산출 세액을 계산하면
100만 X 0.06 = 6만 원
66만 - 6만 = 60만 원

B씨는 연소득 1억 원이면 누진세율표에 의해

1000만 원 X 0.35 = 350만 원의 세금이 감소된다.

자세한 설명
1억 원(소득공제 전)을 누진세율 표에 의해 산출 세액을 계산하면
1억 X 0.35 - 1490만 = 2010 만원
9천만 원(소득공제 후)을 누진세율 표에 의해 산출 세액을 계산하면
9천만 X 0.35 - 1490만 = 1660만 원
2010만 - 1660만 = 350만 원

->상대적으로 고소득층에 유리함

위의 설명이 이해가 안 간다면 누진세 계산방법을 참고하는 것이 좋다

2022.12.30 - [경제/금융용어] - 금융용어정리 - 비례세, 누진세

본 게시글은 유튜브 : 경제 TV 너무경 : 너무 쉬운 경제 윤성종 님의 유튜브 영상을 참고하였습니다. 개인적으로 정리하는  글임을 알립니다.

금융용어정리 - 취득세, 보유세, 거래세(+양도소득세), 동결효과

취득세

부동산, 차량, 기계장비, 항공기, 선박 등을 취득한 자에게 부과하는 세금을 말한다.

즉, 처음 부동산이나 차량 등을 처음으로 구매했을 때 내는 세금이다.

취득세는 거래세에 포함된다.

보유세

납세의무자가 보유하고 있는 부동산에 부과하는 조세를 말하며 토지, 주택 등을 보유한 사람이 내는 세금으로 재산세와 종합부동산세를 총칭하는 말이다.

즉, 부동산을 보유만 해도 생기는 세금이다.

거래세(+양도소득세)

일정한 거래에 대하여 부과되는 세금

거래세는 재화 또는 용역이나 유가증권의 거래에 의하여 성립하는 과세대상에 대하여 부과되며, 취득세·등록세·인지세·증권거래세 등이 이에 속한다. 특별소비세·부가가치세 등의 소비세도 넓은 의미에서는 거래세라고 할 수도 있으나, 거래세는 거래 자체에 중점을 두고 과세되는 조세이나, 소비세는 거래에 의한 소비에 중점을 두고 과세되는 조세라는 차이가 있다.
[네이버 지식백과] 거래세 [transfer tax] (두산백과 두피디아, 두산백과)

부동산을 팔 때 거래세는 양도소득세가 있다. 양도소득세를 양도세라고 줄여서 말하기도 하며, 양도소득세는 무조건 부동산을 거래할 때 발생하는 세금이 아니다.

양도소득세는 소득세이므로 양도차익이 있어야 과세 대상이된다.

예를 들어, 1억 인 부동산을 9천만 원에 판매하면 양도소득세가 붙지 않는다. 하지만 1억 원 보다 높은 금액이 발생하면 즉, 양도차익이 발생하면 양도소득세가 붙는다.

동결효과

정부에서 양도소득세를 증세시키면 부동산을 보유한 사람들은 부동산을 판매하기가 매우 껄끄러워진다.

그래서 부동산을 팔지 않고 양도소득세가 내릴 때까지 기다리게 된다.

부동산을 팔지 않고 기다리는 것은 공급의 감소이다.

공급의 감소는 부동산 가격의 상승으로 이어진다.

이를 동결효과라고 한다.

부동산 시장의 안정을 위해서 보유세를 늘리고 거래세를 낮춰야...
위 문구를 기사에서 본다면, 공급의 증가를 해야 한다는 뜻이다.
보유세를 늘리면 부동산 보유자들은 보유세 때문에 판매하고 싶을 것이고, 거래세가 낮아져서 판매도 수월할 것이다.
공급이 증가하면 부동산의 가격도 내려간다.