[자바] 7일차 - 클래스의 특징, 멤버, 접근지정자, 생성자, 정적멤버 vs 객체멤버

7일차

 

클래스, Class
 - 코드의 집합
 - 데이터 + 행동

 

public class Ex73_Class 
{
	public static void main(String[] args)
	{
		//Ex73_Class.java

		//자바에서..
		//	- 1개의 파일에 1개의 클래스를 선언 (일반적)
		//	- 1개의 파일에 1개 이상의 클래스를 선언
		//		a. public 접근 지정자를 단 1개의 클래스에게 지정
		//		b. 그외의 나머지 클래스는 접근 지정자를 생략
		//		c. main메서드를 갖는 클래스를 public을 준다.

		//클래스
		// - 코드의 집합
		// - 데이터 + 행동
		// - 객체의 틀(설계도)
		// => 클래스는 자료형 => 변수	+ 데이터 생성

		// 클래스의 인스턴스 생성 방법
		// 자료셩 객체변수명 = new 자료형();

		Size s1;

		int ni;

		n1 = 10;
		s1 = new Size;//new Sizs() <=붕어빵 1개를 만들어라

		//s1[0]

}

class Size
{
	public int width;
	public int height;
}


/*
접근지정자 class 클래스명
{
	멤버;
}
*/
///////////////////////////////////////////////////////////////////////////////////////////////////////////
public class Ex74_Class 
{
	public static void main(String[] args)
	{
		//Ex73_Class.java

		// 클래스의 용도
		//1. 자료형(데이터의 집합 역할)
		//	- 멤버 변수만 선언
		//2. 가능의 집합(데이터는 포함x)
		//	- 메서드만 선언
		// 3. 데이터 + 기능


		// 학생의 정보 -> 3명분량
		// A. 변수를 각각 생성
		String name1 = "홍길동";
		String name2 = "아무게";
		
		int num1 = 1;
		int num2 = 2;

		int kor1 = 100;
		int kor2 = 90;

		//B. 배열 사용
		String[] names = new String[3];
		int[] nums = new int[3];

		//C. 클래스 사용
		Student s1 = new Student();
		s1.name = "홍길동";
		s1.num = 2;
		s1.kor = 100;
		s1.eng = 90;
		s1.math = 80;
		s1.total = s1.kor + s1.eng + s1.math;
		s1.avg = s1.total / 3.0;

		System.out.println(s1.name);

//		UserMath um = new UserMath();
		System.out.println(UserMath.plus(10,20));
		System.out.println(UserMath.minus(10,20));


		Pen p1 = new Pen();
		p1.color = "빨강";
		p1.ink = 100;
		p1.size = 5;

		Pen p2 = new Pen();
		p2.color = "노랑";
		p2.ink = 50;
		p2.size = 1;

		p1.drawLine();
		p1.drawEllipse();
		p1.checkInk();

		p2.drawEllipse();
		p2.checkInk();

	}
}

//3. 데이터 + 기능
class Pen
{
	public String color;//색상
	public int ink;		//잉크량
	public int size;	//선의 두께

	public void drawLine(){
		System.out.printf("%s색으로 선을 그립니다.%n",color);
		ink--;
	}

	public void drawEllipse(){
		System.out.printf("%s색으로 원을 그립니다.%n",color);
		ink-=3;
	}

	public void checkInk() {
		System.out.printf("현재 펜의 잉크는 %dcc 남았습니다.%n",ink);
	}
}





//2.기능의 집합
//	- 기능성 클래스
class UserMath
{
	public static int plus(int a, int b) {
		return a + b;
	}

	public static int minus(int a, int b) {
		return a - b;
	}
}


// 1. 자료형
//		- 학생정보
//		- 이름, 번호, 성적
class Student
{
	public String name;
	public int num;
	public int kor;
	public int eng;
	public int math;
	public int total;
	public double avg;
}

 

 

클래스의 특징
 - 캡슐화 : 내부의 데이터를 외부와 단절하여 보호
 - 정보은닉 :
 - 상속성/다형성/추상화

 

클래스(Class) / 객체(Object) / 인스턴스(Instance)
 - 클래스는 객체(인스턴스)의 설계도다.
 - 객체는 존재하는 것
 - 인스턴스는 프로그램 메모리에 실체화된 객체라 할 수 있다.
 - 모든 객체는 데이터를 반드시 가지며 동일한 정보를 가질 수 있지만 유일해야 한다.

 

클래스 멤버
 1. 필드(Field)
  - 변수
  - 멤버변수
  - 클래스(객체)의 데이터 역할

 2. 메서드(Method)
  - 클래스(객체)의 행동 역할

 

public class Ex76_Property 
{
	public static void main(String[] args)
	{
		//Ex76_Property.java
		Test t1 = new Test();
		t1.setA(10);
		System.out.println(t1.getA());

		Test t2 = new Test();
		t2.setA(20);
	}
}

class Test
{
	private int a;
	private int b;
	private int c;

	//멤버변수 -> private : 멤버가 무분별하게 제어되는것을 방지

	//a. set메서드, get 메서드 : 읽기 쓰기 지원
	public void setA(int a) {
		//a = a;//*** 매개변수 = 매개변수
		this.a = a;//this 객체 연산자(현재 메서드를 실행중인 객체 자신을 표현)
	}

	public int getA() {
		return this.a;	//생략가능하지만 여러모로 this를 표기해주는것이 좋다.
	}

	//b. 쓰기전용 인터페이스
	public void setB(int b) {
		this.b= b;
	}

	//c. 읽기전용 인터페이스
	public int getC() {
		return this.c;
	}

	//d. 가상 인터페이스
	public int getD() {
		int d = 30;
		return d;
	}
}

 

클래스 멤버의 접근 지정자
 - 클래스 영역을 기준으로 외부에서 내부에 있는 멤버를 접근할 수 있는
  수준 정의(보안)
 1. public
  : 멤버를 100% 공개
 2. private
  : 멤버를 100% 비공개
// 3. protected
// 4. friendly

 

public class Ex75_AccessMember 
{
	public static void main(String[] args)
	{
		//Ex75_AccessMember.java
		
		Test t1 = new Test();
//		System.out.println(t1.a);
//		System.out.println(t1.b);
		t1.check();	
//		t1.check2();

		Student s = new Student();

//		s.kor = 90;
		s.setKor(90);
		s.check();
	}
}

class Student
{
	//....
	private int kor;
	
	public void setKor(int score) {
		if(score>=0&&score<=100) {
			kor = score;
		}else{
			System.out.println("0~100점 사이의 점수를 입력하시오.");}
	}


	public void check() {
		System.out.printf("학생의 국어점수는 %d점입니다.%n",kor);
	}
}
class Test
{
	//1. 멤버 변수는 무조건 private
	//2. 메서드도 되도록 private
	//3. 단, 외부로 노출이 되야할 메서드만 public

	public int a = 10;		//100% 공개
	private int b = 20;		//100% 비공개

	public void check() {
		System.out.println(a);
		System.out.println(b);
	}

	//내부 전용 메서드
	private void check2() {
		System.out.println(a + b);
	}
}

 

클래스 정적 멤버 vs 객체 멤버
 - 정적멤버는 항상 static 키워드가 추가됨
 - 정적변수 및 정적메서드 호출시에는 항상 클래스명을 입력한다.

 

public class Ex77_static 
{
	public static void main(String[] args)
	{
		//Ex77_static.java
		Student stu1 = new Student();
		Student stu2 = new Student();
		Student stu3 = new Student();

		stu1.init("홍길동","경희중학교");
		stu2.init("아무게","경희중학교");
		stu3.init("하하하","경희중학교");

		stu1.init2("홍길동");
//		Student.school = "경희중학교";
		Student.init3("OO학교");

		stu1.hello();
		stu2.hello();
		stu3.hello();
	}
}

class Student 
{
	//멤버변수
	private String name;
//	private String school;
	private static String school;	// 정적변수(공용변수)

	//초기화 set메서드
	public void init(String name, String school)
	{
		this.name = name;
		Student.school = school;
	}
	
	//객체메서드
	public void init2(String name)
	{
		this.name = name;
	}

	//정적메서드
	public static void init3(String school)
	{
		Student.school = school;
	}

	//get메서드
	public void hello() {
		System.out.printf("안녕하세요~ 저는 %s에 다니는 %s입니다.\n",Student.school,this.name);
	}
}

 1. 객체변수 vs 정적변수
  - 객체변수 : 각각의 개인(인스턴스)이 별도로 저장, 관리해야 하는 데이터(학생명)
  - 객체변수수명 : 인스턴스 생성될때 생성 ~ 인스턴스가 소멸될때 소멸
  - 정적변수 : 모든 개인(인스턴스)이 공통으로 저장, 관리해야 하는 데이터(학교명)
  - 정적변수수명 : 프로그램이 시작하기 직전에 생성 ~ 프로그램이 종료될떄 소멸

 

 2. 객체메서드 vs 정적메서드
  - 객체 메서드 : 각각의 개인(인스턴스)이 독립적인 행동을 취할때
   (+ 개인데이터 활용)
  - 정적 메서드 : 각 개인(인스턴스)하고 상관없는 일반적인 행동을 취할때
   (+ 공용데이터 활용)

 

 3. 객체 vs 정적
  - 객체멤버는 항상 객체명.변수 or 객체명.메서드()
  - 정적멤버는 항상 클래스명.변수 or 클래스명.메서드()

 

 4. 생명주기
  - 객체멤버가 소멸, 참조가 끊기면 Garbage발생 -> Garbage Collector호출
   -> 참조를 잃어버린 객체를 수거(메모리 환원)

 

class Ex78_Class_lifeCycle 
{
	public static void main(String[] args)
	{
		//Ex78_Class_lifeCycle.java

		//생명주기(지역변수)
		int n;	//이때생성 -> main()의 {}을 제어가 벗어날때 소멸
		
		Test t = new Test();	//이때 내부의 멤버변수 n이 생성
		// t가 죽으면서 Test의 인스턴스가 소멸될때 n이 소멸
		t = null;	// 객체소멸, 임의로 참조값을 끊어버림

	}//end main
}

class Test
{
	public int n;	//
}

 

생성자, Constructor
 - 클래스릐 객체 생성 -> new 연산자 + 생성자();
 - 객체가 생성될때 호출되는 메서드
 - 객체내부의 멤버를 초기화 하는 역할
 - 특징
      a. 클래스이름과 동일한 이름을 가진다.
      b, 반환값이 존재하지 않는다.
      c. 오버로딩이 가능하다.
      d. 명시적으로 생성자를 정의하지 않으면 기본생성자가 자동으로 만들어진다.

 

public class Ex79_Constructor 
{
	public static void main(String[] args)
	{
		//Ex79_Constructor.java
		Test t1 = new Test();
//		t1.setN(10);
//		t1.setB(true);
		System.out.println(t1.getN());
		System.out.println(t1.getB());

		int[] ns = new int[3];
		System.out.println(ns[0]);

		boolean[] bs = new boolean[3];
		System.out.println(bs[0]);

		Size s1 = new Size();
		s1.setSize(20,30);

		Size s2 = new Size(10,20);
	}
}

class Size
{
	private int width;
	private int height;


	//생성자 오버로딩
	//기본생성자
	public Size() {
		this.width = 0;
		this.height = 0;
	}

	//오버로딩생성자
	public Size(int width, int height) {
		this.width = width;
		this.height = height;
	}

	public void setSize(int width, int height) {
		this.width = width;
		this.height = height;
	}
}

class Test
{
	private int n;
	private boolean b;

	//기본 생성자
	public Test() {
		this.n = 0;
		this.b = false;
	}

	public void setN(int n) {
		this.n = n;
	}

	public int getN() {
		return this.n;
	}

	public void setB(boolean b) {
		this.b = b;
	}

	public boolean getB() {
		return this.b;
	}
}