# Student_Run
package com.kh.chap02.encapsulation.run;
import com.kh.chap02.encapsulation.mode.vo.Student;
public class Run {
/*
* 캡슐화 과정을 통한 완벽한 클래스 형태를 갖추게 하자
*
* 캡슐화하지 않으면 : 외부로부터 직접 접근이 가능하기 때문에
* 함부로 값이 변질되거나 조회를 막지 못하는 문제가 발생
*
* 정보보안의 3요소 : 기밀성(외부로 안보이게), 무결성(외부로부터 결함이 생기지 않고 데이터 그대로), 가용성(사용가능한 상태)
*
* => 캡슐화 작업: 정보은닉 기술 중 하나
*
* 데이터의 "접근 제한"을 원칙으로 하여 외부로부터 직접접근을 막는 방법
* 단, 대신에 간접적으로나마 처리(값대입, 조회)할 수 있게끔 만들어줘야 함.
*
* => 캡슐화 작업의 2단계
* 1. 값을 숨긴다. : public 대신 private으로 접근제한자를 바꿔준다.
* 2. 간접적으로나마 값을 처리할 수 있는 메소드를 만든다. (getter / setter)
*
*/
//접근제한자 (예약어) 반환형 메소드이름 (매개변수:String배열)
public static void main(String[] args) { //실행 class의 main method
Student kim = new Student();
/*
kim.name = "김**";
kim.gender = 'M';
kim.age = -20;
System.out.println(kim.name); //필드에 직접 접근
System.out.println(kim.gender);
System.out.println(kim.age);
*/
// 필드가 보이지 않아서 오류가 발생 => private로 변경했기 때문에
// 위와 같이 직접 접근이 불가능.(외부에서)
// 직접접근을 막았으니 간접적으로나마 접근을 할 수 있게끔해주기 => getter/setter 메소드 만들기
kim.setName("김**"); //괄호 안에 값을 입력함 //name필드에 셋팅하고 싶어서 보냄.
kim.setAge(20);
kim.setGender('M');
/*
System.out.println(kim.name);
System.out.println(kim.gender);
System.out.println(kim.age);
*/
//조회할 수 있는 기능도 만들어 줘야함
kim.getName(); //따로 전달할 값 없이 호출만 해주면 됨. //setName을 돌려줌
kim.getAge();
kim.getGender();
//출력시,
System.out.println(kim.getName());
System.out.println(kim.getAge());
System.out.println(kim.getGender());
kim.information();
System.out.println(kim.information());
}
}
# Student_class
package com.kh.chap02.encapsulation.mode.vo;
//필드부, 생성자부, 매소드부
public class Student {
//필드부
/*
* 정보를 담는 부분
*
* 필드 == 멤버변수 == 클래스 변수
*
* 접근제한자 자료형 필드명;
*
*/
private String name;
private char gender;
private int age;
//public int b;//클래스영역내 가용범위 [필드]
//생성자부
//메서드부
/*
* 기능을 구현하는 부분
*
* 접근제한자 반환형 메소드식별자(매개변수) {
* 메소드 호출 시 실행할 코드;
* }
*
* 접근제한자: 호출할 수 있는 범위를 제한
* 반환형: 매소드의 결과값의 자료형을 지정해준다. //void -> 돌려줄 값이 없다.
* 매개변수: 매소드 호출 시 입력값으로 넣어주는 값을 받아주는 변수. 해당 메소드 실행 중에만 사용이 가능하다. 생략가능
*
*/
//public void method1() {
// int a = 0;
// }
//데이터를 기록 및 수정하는 기능의 메소드 : setter 메소드(필드에 값을 seting)
/*
* 규칙
*
* 1. setter 메소드는 접근 가능하도록 만들어야하기 때문에 public 접근 제한자를 이용.
* 2. set필드명으로 이름을 짓되 낙타봉표기법(camelCase)을 지키도록 한다.
* ex) setName, setAge, setGender
* 3. 모든 필드에 대해서 반드시 전부 다 작성을 해줘야한다.
*
*/
//+void: 내가 뭐 마땅히 돌려줄게 없다.반환형
//이름을 기록 및 수정할 수 있는 메소드
public void setName(String name) { //String name을 매개변수라고 함. name은 임의로 지정가능.
this.name = name; //받아온 값을 대입
//this는 heap영역의 주소값을 가지고 있음.
//특정 영역 안에서는 해당 영역 안에 있는 지역변수 우선권이 있음.
//this.를 붙이지 않으면 '매개변수 name = 매개변수 name'으로 인식함.
}
//나이를 기록 및 수정할 수 있는 메소드
public void setAge(int age) { //보편적으로 매개변수는 필드명과 동일한 네임을 사용함.
if(age<0) {
System.out.println("말도안됨");
}else {this.age = age;}
}
//성별을 기록 및 수정할 수 있는 메소드
public void setGender(char gender) {
this.gender = gender;
}
//데이터를 반환해주는 기능의 메소드: getter 메소드(값을 get할 수 있는 메소드)
/*
* 1. getter메소드는 접근제한자 public을 사용한다.
* 2. get필드명으로 짓되, 낙타봉표기법(camelCase)를 사용한다.
* 3. 모든 필드에 대해서 반드시 다 작성해줘야 함.
*/
//이름을 반환해주는 메소드
public String getName() {
//this.name; //나를 부른 곳으로 이것을 반환해주고 싶다. this는 붙여도되고 안붙여도 되나, 명확한 구분을 위해 붙이는게 좋음.
return this.name; //돌아가는데, this.name을 가져감
//return 결과값 => 결과값을 나를 부른 곳으로 돌려줌.
//메소드의 반환형(void자리)과 반환값의 반환형이 동일한 지 확인해야함.
}
//나이를 반환해주는 메소드
public int getAge() {
return this.age;
}
//성별을 반환해주는 메소드
public char getGender() {
return this.gender;
}
//setter와 getter메소드 다 만들어줬으면 캡슐화 끝!
//예쁘게 메소드를 보고 싶을 때
public String information() {
//return name, age, gender;
//결과값은 return당 한 개여야 함.
//String info = name + "님의 나이는 " + age + "살이고 성별은 " + gender + "입니다.";
//return info; //변수를 쓰는 이유는 재사용하기 위해.
return name + "님의 나이는 " + age + "살이고 성별은 " + gender + "입니다."; //재사용이 딱히 없을 땐 변수를 사용하지 않음.
//앞으로 만드는 vo class는 private, getter, setter, information까지 해야함.
}
}
# Person&Product_Run
package com.kh.chap03.run;
import com.kh.chap03.model.vo.Person;
import com.kh.chap03.model.vo.Product;
public class Run {
//main + ctrl + space : 메인메서드
public static void main(String[] args) {
// Person(참조자료형) ==내가 만든 나만의 자료형(1.참조자료형, 2.주소값 저장, 3.(기본자료형과 차이점)여러개의 자료형에 여러개의 값 보관 + 기능)
// ==사용자 정의 자료형
//Person이라는 클래스를 통해 객체 생성
Person park = new Person(); //4byte //인스턴스화 (=오브젝트)
// 참조자료형 식별자 = new(heap영역의 할당)
park.setName("박*진");
System.out.println(park.information());//배열
//기본값이 들어있음 => 기본형은 0, 0.0, null, 공백 // 참조형은 null
//값 대입 => setter 기능 이용
park.setAge(25);
park.setGender('F');
park.setNumId("900000-2000000");
park.setPhoneNum("010-1111-2222");
park.setEmail("aaa@naver.com");
System.out.println(park);//참조자료형이기 때문에 주소값이 출력되게 됨.
park.getName();
park.getAge();
park.getGender();
park.getNumId();
park.getPhoneNum();
park.getEmail();
park.information();
System.out.println(park.getName());
System.out.println(park.getAge());
System.out.println(park.getGender());
System.out.println(park.getNumId());
System.out.println(park.getPhoneNum());
System.out.println(park.getEmail());
System.out.println(park.information());
Product pd = new Product();
pd.setProductName("가방");
pd.setPrice(4600000);
pd.brand("KH"); //이미 지정했지만 바꾸는 것도 가능
System.out.println(pd.information());
}
}
# Person
package com.kh.chap03.model.vo;
public class Person {
//vo란? 객체정보, 데이터를 담을 곳
//사람의 인적정보
//이름, 나이, 성별, 주민번호, 핸드폰번호, 이메일주소
//[필드부]
//필드 == 멤버변수 == 클래스변수 == 인스턴스변수
private String name;
private int age;
private char gender;
private String numId;
private String phoneNum;
private String email;
//--------------------------------[생성자부]
//[메소드부]
//setter메소드 : set필드명
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public void setGender(char gender) {
this.gender = gender;
}
public void setNumId(String numId) {
this.numId = numId;
}
public void setPhoneNum(String phoneNum) {
this.phoneNum = phoneNum;
}
public void setEmail(String email) {
this.email = email;
}
//getter메소드 : get필드명
public String getName() {
return name;
}
public int getAge() {
return age;
}
public char getGender() {
return gender;
}
public String getNumId() {
return numId;
}
public String getPhoneNum() {
return phoneNum;
}
public String getEmail() {
return email;
}
//information()
public String information() {
return name + "님의 나이는 " + age+ "세이고, 성별은 " + gender + "이며, 주민등록번호는 " + numId + "이고, 핸드폰 번호는 " + phoneNum + "이며, 이메일주소는 " + email + "입니다.";
}
}
# Product
package com.kh.chap03.model.vo;
public class Product {
//상품가격, 상품명, 브랜드명
//[필드부]
private int price;
private String productName;
private String brand = "샤넬";//초기값 설정까지 한 번에
//[생성자부]
//[메소드부]
public void setPrice(int price) {
this.price = price;
}
public void setProductName(String productName) {
this.productName = productName;
}
public void brand(String brand) {
this.brand = brand;
}
public int getPrice() {
return price;
}
public String gerProductName() {
return productName;
}
public String getBrand() {
return brand;
}
public String information() {
return "상품명: " + productName + ", 상품가격: " + price + ", 브랜드: " + brand;
}
}
# FiledTest 1
package com.kh.chap04.model.vo;
/*
* 필드(field): 클래스를 구성하는 요소 중 하나!
* 어떠한 데이터를 저장하기 위한 역할 (변수)
* 클래스 내부지만, 메소드 밖 영역에 정의함.
*
* 변수 구분
* - 필드 : 클래스 영역에 바로 선언하는 변수
* - 지역변수 : 클래스 영역 내에 특정한 구역 ({ })=>메소드, for문 등
* ex) for(int i = 0; 조건식; 증감식){} =>초기식에서 선언된 변수 : 지역변수
*
* 1. 전역 변수
*
* - 클래스 변수 (static 변수) : static이라는 예약어가 붙은 변수
* 생성시점: 프로그램 시작과 동시에 static영역에 할당됨.
* =>해당객체가 생성되지 않더라도 무조건 프로그램 실행과 동시에 할당이 됨.
* 소멸시점: 프로그램이 끝날 때 소멸
* - 멤버변수(필드, 인스턴스 변수) :
* 생성시점: new 키워드를 사용하면 해당 객체를 생성하는 순간 메모리 영역에 할당 => heap 영역에
* 소멸시점: 객체가 소멸될 때 => 가비지컬렉터
*
* 2. 지역 변수
* 생성시점: 특정한 구역({ })이 실행 시 메모리 영역에 할당 => stack영역
* 소멸시점: 특정한 구역({ })이 종료 시 소멸
*/
public class FieldTest1 {
// 필드(멤버변수, 인스턴스변수)
public int global;
public void test(int num) { //test메소드 시작
//지역변수 사용
int local = 0; //지역변수: 초기화를 반드시 해줘야 함!
System.out.println(global);//필드, 멤버변수
System.out.println(local);//지역변수
System.out.println(num);//매개변수(지역변수)
}//test메소드 끝
}
# FiledTest 2
package com.kh.chap04.model.vo;
//필드에서 사용가능한 접근제한자 4가지
public class FieldTest2 {
/*
* (+)public => 어디서든(같은 패키지, 다른패키지 모두~) 접근 가능하게 하고싶다. (대표적으로getter, setter, 생성자)
* (#)protected => 같은 패키지면 무조건 접근 가능
* 다른패키지면 상속구조인 클래스에서만 접근 가능
* 상속이라는 개념은 다다다음시간에 다뤄볼 것!
* (~)default => 오로지 같은 패키지에서만 접근 가능, 생략 가능
* (-)private => 오직 해당 클래스 안에서만 접근 가능하게 하고 싶다. (대표적으로 필드)
*
* ==> 위에서부터 아래로 내려갈수록 접근할 수 있는 범위가 좁아진다.
* => public(+) protected(#) default(~) private(-) : 클래스 다이어그램 표기방법
*
*/
}
# FiledTest 3
package com.kh.chap04.model.vo;
//클래스변수(static 변수)와 상수 필드(static final)에 대해
public class FieldTest3 {
//필드(field)
//[표현법] 접근제한자 (예약어:생략가능) 자료형 필드식별자;
//클래스 변수(static 변수)
public static String str = "static 변수";
//생성시점:프로그램 실행과 동시에 메모리의 static 영역에 할당됨.
//소멸시점:프로그램 종료 시 소멸됨.
//=> 객체를 생성(new)하지 않고 static영역에 할당됨.
//static "공유"의 개념이 강함
//프로그램 실행과 동시에 메모리 영역에 공간을 만들어두고 그 안에 값을 공유해서 쓰자
/*
* 상수필드
*
* [표현법]
* public static final 자료형 상수필드이름 = 값;
* => 예약어 순서는 상관 없음. public final static으로 써도 됨.
* => 한 번 지정된 값을 고정해서 쓰겠다. 그래서 무조건 초기화를 해줘야 함.
*
* static : 공유의 개념(재사용성)
* final: 한 번 지정해놓고 변경하지 않겠다(상수선언)
*
* 값이 변경되어서는 안되는 고정적인 값들을 메모리상(static)에 올려놓고
* (프로그램 시작과 동시에 메모리 영역에 할당, 값이 변하지도 않음)
* 공유할 목적으로 사용
*
* 상수필드 이름도 반드시 항상 모두 대문자여야함.
*
*/
public static final int NUM = 10;
/*
*
* Math클래스 random() 객체생성x
* 이유는? random() static메소드이기 때문에
*
* Math클래스에 PI
*/
//Math.random(); //static영역에 올라가기 때문에 객체 생성할 필요 x
}
# FiledTest 1~3_Run
package com.kh.chap04.run;
import com.kh.chap04.model.vo.FieldTest1;
import com.kh.chap04.model.vo.FieldTest3;
public class Run {
public static void main(String[] args) {
//------------------1. filed test1--------------------
FieldTest1 f1 = new FieldTest1();
//객체 생성시 (new키워드 사용 시) global 멤버변수 할당!
System.out.println(f1.global);
f1.test(10);//test메소드를 호출해야만 num, local 지역변수 할당(stack에 생성)
//test메소드 호출 종료 시 num, local 지역변수 소멸
System.out.println(f1.global); // test메소드 종료시에도 소멸되지 않음. 객체가 소멸될 때까지 존재
System.out.println(f1); //주소값 출력
f1 = null; //global 멤버변수 소멸 //연결해제
//System.out.println(f1.global); //NullPointerException에런
//------------------3. filed test3---------------------
System.out.println(FieldTest3.str);//heap에 올리지 않아도 사용 가능
System.out.println(FieldTest3.NUM);
System.out.println(Math.PI);
//static 클래스변수(static변수) static붙은 모두
//stack에는 메소드, 변수 => 지역변수
//heap 인스턴스(객체), 필드 (new) => 멤버변수
}
}
# User
package com.kh.chap05.model.vo;
public class User {
//User u = new User();
//[필드부]
//회원아이디, 비밀번호, 이름, 나이, 성별
private String id;
private String pw;
private String name;
private int age;
private char gender;
//[생성자부]
/*
* 생성자 (Constructor) : 메소드(생성자) 이름이 클래스이름과 동일하고 return 자료형이 없는 메소드(반환형이 없다)
*
* 참고) 메소드의 표현법
* 접근제한자 반환형 메소드이름(매개변수(생략가능)) {
* 실행하려는 코드
* }
*
* [표현법]
* public 클래스이름 (매개변수(생략가능)) {
* 해당 생성자를 통해서 객체 생성 시 실행하고자 하는 코드
* }
*
* 생성자를 작성하는 목적?
* 1. 객체를 생성해주기 위한 목적
* 2. 객체를 생성뿐만 아니라 매개변수로 전달된 값들을 바로 필드에 초기화할 목적
*
* 생성자의 종류
* 1. 매개변수가 없는 생성자 => 기본 생성자
* 2. 매개변수가 있는 생성자
* -> 차이점: 필드에 값을 초기화 할 수 있느냐 없느냐 차이
*
* 생성자 작성 시 주의사항!
* 1. 반드시! 생성자의 이름은 클래스의 이름과 동일해야한다. (대/소문자)
* 2. 반환형은 존재하지 않음 (메소드와 유사하게 생겨서 헷갈릴 수 있음)
* 3. 생성자가 여러 개 생성이 가능하지만, 매개변수가 중복되어서는 안됨.=>오버로딩
* (ex.public User(String id, String pw)
* (ex.public User(String id, String pw)(x) -> 만약 자료형이 다르면 가능.
* 4. 매개변수생성자를 명시적으로 작성해버리면 기본생성자를 JVM이 안만들어줌.
*
* => 기본생성자를 반드시 만드는 습관을 들이는 게 좋음.
*/
//public User() {
//1. 기본생성자(매개변수가 없음)
/*
* 단지 객체를 생성하기 위해서 사용 => 메모리 공간 할당 될 때, 공간을 확보할 때
* 기본생성자는 생략해도 오류가 나지 않음.
* 생성자를 하나도 안 만들면 JVM이 기본생성자를 만들어줌.
* => 기본생성자는 "항상" 작성하자.
*
*/
//System.out.println("안녕?");}
public User() {} // 기본생성자는 꼭 만들기!!!!
//2. 매개변수 있는 생성자
//3개짜리
public User(String id, String pw, String name) {
this.id = id;
this.pw = pw;
this.name = name; //초기화 한 번에 하기
}// 매개변수 3개를 가지고 있는 생성자, 이미 만들어서 JVM이 기본생성자를 만들어주지 않음.
//5개짜리
public User(String id, String pw, String name, int age, char gender) {
this.id = id;
this.pw = pw;
this.name = name;
this.age = age;
this.gender = gender;
}
//[메소드부]
public void setId(String id) {
this.id = id;
}
public void setPw(String pw) {
this.pw = pw;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public void setGender(char gender) {
this.gender = gender;
}
//------------------------------------
public String getId() {
return id;
}
public String getPw() {
return pw;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public char getGender() {
return gender;
}
public String information() {
return name + "님의 아이디는 " + id + " 비밀번호는 " + pw +
" 나이는 " + age + " 성별은 " + gender + "입니다.";
}
}
# User_Run
package com.kh.chap05.run;
import com.kh.chap05.model.vo.User;
public class Run {
public static void main(String[] args) {
//1. 기본생성자를 사용해서 객체를 생성 후 setter이용해서 필드값 초기화
User user01 = new User(); //User(); ==기본생성자
user01.setName("유저1");
user01.setId("user01id");
user01.setPw("user01pw");
user01.setAge(25);
user01.setGender('F');
user01.getName();
user01.getId();
user01.getPw();
user01.getAge();
user01.getGender();
user01.information();
System.out.println(user01.information());
//2. 객체생성과 동시에 필드값을 초기화
//아이디, 비번, 이름
User user02 = // 매개변수 3개를 가지고 있는 생성자호출
new User("user02",
"pass02",
"유저2");//순서 중요
//3. 생성자로 모든 필드값 초기화
User user03 = new User("user03", "pass03", "유저3", 21, 'M');
System.out.println(user03.information());
}
}
# MethodTest1
package com.kh.chap06.controller;
public class MethodTest1 {
//클래스 안에 있어서 메소드라는 이름.
//다른 곳에서는 함수라고 부름. 본질은 함수와 같음
/*
* 메소드(Method) : 입력을 가지고 어떤 일을 수행한 다음에 결과물을 내놓음.
*
* [표현법]
* 접근제한자 (예약어) **반환형** 메소드식별자(매개변수의자료형 매개변수식별자=> 입력값) {
*
* 수행할 코드;
*
* return 반환값;//결과값
* }
* 생략가능한 것: 예약어, 매개변수, return문 부분(반환형이 void일 경우)
*
* 반환형: 반환할 값의 자료형
* 호출할 때 인자값 => 매개변수의 자료형과 갯수가 일치해야함 반드시 **********
* == 메소드 호출할 때 전달하려는 자료형과 매개변수의 자료형이 같아야 에러가 안남
*
* 한 번 정의해두고 필요할 때마다 호출 사용 언제든!
*
*/
//1. 매개변수도 없고 반환값도 없는 메소드
public void method1() {
System.out.println("매개변수와 반환값이 둘 다 없는 메소드입니다.");
int sum = 0;
for(int i = 1; i<=10; i++ ) {
sum += i; //sum = sum + i
}
System.out.println(sum);
//return; -> 자동 생략
//void일 경우 return이 생략 JVM이 자동으로 만들어줌.
}
//2. 매개변수는 없고 반환값은 있는 메소드
public int method2() {
System.out.println("매개변수는 없고 반환값은 있는 메소드입니다.");
//1에서부터 100까지의 랜덥값을 발생시켜셔 돌려주고 싶다.
return (int)(Math.random() * 100) + 1;
}
# MethodTest1_Run
package com.kh.chap06.run;
import com.kh.chap06.controller.MethodTest1;
public class Run {
public static void main(String[] args) {
MethodTest1 mt1 = new MethodTest1(); //메모리에 할당
mt1.method1();//mt1에 접근해 메소드 호출
int a = mt1.method2(); //1~100사이의 정수'값' => 재사용하고 싶으면 변수선언 해 대입해주기
System.out.println("랜덤값: " + a);
System.out.println("랜덤값: " + mt1.method2()); //=> 재사용을 안해도 되면 값 그자체를 출력 //호출한 메소드로 가서 시작점부터 진행
}
}
'클라우드 융합 Full-stack 웹 개발자 양성과정 > Java' 카테고리의 다른 글
| 프로그래밍 언어응용-상속 (1) | 2022.09.25 |
|---|---|
| 프로그래밍 언어응용-객체5 (1) | 2022.09.25 |
| 프로그래밍 언어응용-배열, 객체1(캡슐화) (1) | 2022.09.25 |
| 프로그래밍 언어응용-while-do, while-break, continue, Array (1) | 2022.09.25 |
| 프로그래밍 언어응용-if else문, switch, for, while (1) | 2022.09.25 |