package day7;
public class Car { >이곳을 "생성자"라고 합니다
====================================
String name;
String tire;
String color; >여기까지를 "필드" 라고 합니다
int speed; >클래스는 3가지로 나눕니다
=====================================
>"메소드"의 구조를 알아보겠습니다
▼접근제한자 ▼리턴타입 ▼메소드이름 ▼매개변수
public void run () {
speed = speed + 1;
// 메소드
}
▼접근제한자 ▼리턴타입 ▼메소드이름 ▼매개변수
public void speedRun () {
speed = speed+2;
}
!!중요합니다!!
▼접근제한자 ▼리턴타입 ▼메소드이름 ▼매개변수
public String speedUp (int speed) {
String str = "스피드는"+speed;
return str; >여기까지를 "메소드"라고 합니다
>리턴 타입이 없는 경우 void를 사용합니다
>리턴 타입은 메소드를 통해 출력받는 변수의 형식을말합니다
}
> 문제) 메서드 print만들기
> 기능 : 이름 , 타이어 , 컬러 ,스피드
public void print() {
System.out.println(name+"/"+tire+"/"+color+"/"+speed);
}
=================================================================
메소드를 불러오기 위한 사용 예시)
>예시를 위한 메서드입니다<
public String speedUp (int speed) {
String str = "스피드는"+speed;
return str
>리턴 타입이 String이기 때문에 변수 선언으로 담을때도 String으로
>예시를 위한 메서드입니다<
System.out.println(str);
String s = speedUp(14); < 매개변수를 넣었기 때문에 에러x
> 출력 예시 ) 스피드는14
System.out.println(str);
String s = speedUp(); < 매개변수를 넣지 않았기 때문에 에러
예시 메소드에서 int speed 를 매개 변수로 사용했습니다
그렇기에 매개변수를 넣지 않는다면 java에서는 오류로 실행하지 않습니다
package day7;
public class Calculator {
int num1;
int num2;
>응용 문제입니다
>문제를 풀어보며 메소드의 작성 양식을 익혀보는 시간입니다
// 문제)
// 접근제한자 : public
// 리턴타입 : 없음
// 메소드명 : sum
// 매개변수 : 없음
// 실행문구 : 필드 두개를 더한값 출력
public void sum() {
System.out.println(num1 + num2);
}
// 문제)
// 접근제한자 : public
// 리턴타입 : 없음
// 메소드명 : sub
// 매개변수 : int 두개
// 실행문구 : 매개변수로 받은 두수를 뺀값 출력
>"메소드"안에서도 조건문if를 사용 가능하다는 예시<
>받은 개채 변수에서 더 큰수에 작은수를 빼게 하는 조건문<
public void sub(int num1, int num2) {
if(num1 < num2) {
System.out.println(num2 - num1);
}else {
System.out.println(num1 - num2);
}
}
// 문제)
// 접근제한자 : public
// 리턴타입 : int
// 메소드명 : mul
// 매개변수 : int 두개
// 실행문구 : 매개변수로 받은 두수를 곱한값 리턴
public int mul(int num1, int num2) {
return num1*num2;
}
// 문제)
// 접근제한자 : public
// 리턴타입 : ?
// 메소드명 : div
// 매개변수 : int 두개
// 실행문구 : 매개변수로 받은 두수를 나눈값 리턴
public double div(int num1, int num2) {
return num1 / (double)num2;
}
}
===================================================================
package day7;
public class Calculator_Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
> 다른 클래스에서 만든 Calculator를 cal로 지정하고 가져오고,넘겨주기가 가능하게 만듬
Calculator cal = new Calculator();
cal.num1 = 15;
cal.num2 = 5;
> cla.xxx 을 이용하여 다른 클래스 Calculator에 있는 변수를 가져온 모습
// 메소드를 이용하여 더하기 , 빼기 , 곱하기 , 나누기 값 출력
cal.sum();
cal.sub(cal.num1,cal.num2);
System.out.println(cal.mul());
System.out.println(cal.div());
> 다른 클래스에서 "메소드"를 만들고 사용할 클래스에서 가져와 출력한 모습
}
}
package day7;
public class Animal {
String test;
private String name;
private String sound;
private int leg;
>private는 다른 클래스에서 메소드를 생성한 클래스의 정보를 변경하지 못하게 합니다
>하지만 이런경우 메소드에 정보를 넘기거나 받아오는 방법이 달라지게됩니다.
>아래는 priavte를 사용한 경우 정보를 넘겨받고 넘겨주는 "메소드" 예시 구조입니다
public String getName() {
return name;
}
>필드에 저장된 값을 출력하는 "메소드"입니다
>"메소드"의 이름은 getName으로 설정했습니다
>실행문에는 retrun name;을 이용해 필드의 name안에 저장된 값을 리턴하게 하였습니다
public void setName(String name) {
this.name = name; < 여기서 this.name에 입력받은 name을 대입한 이유는
<필드의 name에 대입하도록 지정해주기 위해서입니다 this를 붙인경우 필드의 name을 뜻합니다
}
>"메소드"의 이름을 setName으로 설정하고 매개 변수로 받아와 필드에 저장할 수 있게하였습니다
>이 "메소드"는 매개 변수로 받은 값을 저장하기 위한 "메소드"이기 떄문에
>값을 전달해 줄 필요가 없음으로 리턴 타입을 void로 설정했습니다
>이제부터는 "메소드"의 이름만 다를뿐 형식은 같기 때문에
>읽어보며 형식을 익혀보도록 하겠습니다
public String getSound() {
return sound;
}
public void setSound(String sound) {
this.sound = sound;
}
public int getLeg() {
return leg;
}
public void setLeg(int leg) {
this.leg = leg;
}
>출력을 "메소드"를 만든 클래스에서 지정해도 상관없습니다
>이런경우 메인 클래스에서 사용을 필요로할때 편하게 사용 가능합니다
public void println() {
System.out.println("다리가 "+getLeg()+"개인 "+getName()+"는 "+getSound()+"입니다");
}
}
===========================================================================================
package day7;
public class Animal_Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
>예시문) 애니멀이라는 클래스를 a로 선언하고 저장하고 가져올 수 있게하였습니다
Animal a = new Animal();
a.test = "테스트입니다";
System.out.println(a.test);
>private을 걸지 않았기 때문에 "메소드"를 이용하지 않고
>변수를 불러와 "테스트입니다"를 대입해 출력이 된다는걸 보여주는 예시입니다
!! 다른 클래스를 다른 이름으로 선언하여 사용하는 경우
!! 저장값이 덮어씌워지지 않는다는 사실을 알려주는 예시문입니다
>예시문) 애니멀이라는 클래스를 dog으로 선언하고 저장하고 가져올 수 있게하였습니다
Animal dog = new Animal();
dog.setName("강아지"); >dog.setName으로 다른 클래스의 메소드를 실행시켜 다른 클래스의 변수에 저장하였습니다
dog.setSound("멍멍"); >dog.setSound으로 다른 클래스의 메소드를 실행시켜 다른 클래스의 변수에 저장하였습니다
dog.setLeg(4); >dog.setLeg으로 다른 클래스의 메소드를 실행시켜 다른 클래스의 변수에 저장하였습니다
System.out.println(dog.getName()+"/"+dog.getSound()+"/"+dog.getLeg());
>이렇게 저장된 정보를 dog.getName , dog.getSound , dog.getLeg를 이용하여 출력한 모습입니다
>예시문) 애니멀이라는 클래스를 cat으로 선언하고 저장하고 가져올 수 있게하였습니다
Animal cat = new Animal();
cat.setName("고양이");
cat.setSound("야옹");
cat.setLeg(4);
System.out.println(cat.getName()+"/"+cat.getSound()+"/"+cat.getLeg());
>예시문) 애니멀이라는 클래스를 chicken으로 선언하고 저장하고 가져올 수 있게하였습니다
Animal chicken = new Animal();
chicken.setName("닭");
chicken.setSound("꼬끼오");
chicken.setLeg(2);
chicken.println();
>예시문) 애니멀이라는 클래스를 elephant으로 선언하고 저장하고 가져올 수 있게하였습니다
Animal elephant = new Animal();
elephant.setName("코끼리");
elephant.setSound("뿌우");
elephant.setLeg(4);
elephant.println();
}
}
package day7;
public class Fruit {
private String name;
String color;
boolean isSeed;
>클래스를 형성하는 3가지 요소중 하나인 기본 생성자를 알아보는 시간입니다
public Fruit() {
System.out.println("기본 생성자");
}
생성자 특징
1. 리턴타입이 없다
2.생성자 명이 클래스 이름과 동일하다.
3.기본생성자는 작성하지 않아도 자동으로 숨겨져 만들어진다
!!하지만 생성자를 사용하는 경우가 있기에 알아보자면!!
>필드에 값을 넣음과 동시에 생성하고 싶을때 생성자를 사용합니다
public Fruit() {
>이런경우 기본 생성자를 수동으로 생성해주어야 합니다
}
▼접근제한자 ▼리턴타입x ▼메소드의 이름을 클래스와 같게 ▼매개 변수
public Fruit (String name, String color, boolean isSeed) {
System.out.println("생성자1");
>생성자를 이용하여 개채 변수로 입력 받아 바로 필드의 변수에 대입함
this.name = name;
this.color = color;
this.isSeed = isSeed;
}
> 이후 사용할 생성자를 형식에 맞게 작성합니다
알아두자!!
생성자 오버로딩 : 매개 변수를 다르게 하는 생성자를 여러 개 선언 하는것
public Fruit (String name){
this.name = name;
}
public Fruit (String name,String color){
this.name = name;
this.color = color;
}
>매개변수를 같게하거나 순서를 같게하면 오류로 실행되지 않습니다<
==============일반 메소드======================
public void setIsseed Fruit (boolean isSeed){
this.isSeed = isSeed;
}
public boolean getIsseed Fruit (){
return isSeed;
}
public void setName Fruit (String name){
this.name = name;
}
public boolean getName Fruit (){
return name;
}
public void setColor Fruit (String color){
this.color = color;
}
public boolean getColor Fruit (){
return color;
}
======================================================================================
>출력 예시문입니다<
package day7;
public class Fruit_main {
public static void main(String[] args) {
// TODO Auto-generated method stub
>생성자 메소드와 일반메소드의 차이점을 알려주는 예시 문입니다
Fruit apple = new Fruit();
> 생성자
apple.setName("사과");
apple.setColor = "빨강";
apple.setIsSeed = true;
System.out.println(apple.getName()+apple.getColor+apple.getIsSeed);
>일반 메소드를 이용하는 경우 하나씩 대입문을 작성해주어야합니다
>생성자 메소드를 이용하는 경우
Fruit apple1 = new Fruit("사과","빨강",true);
System.out.println(apple1.getName()+apple1.color+apple1.isSeed);
>생성자 메소드에서 이미 대입 실행문을 작성하였기 때문에
>한번에 대입하여 코드가 짧아진 모습입니다
>생성자 메소드와 일반메소드를 한번에 사용 가능하다는걸 알려주는 예시문입니다
Fruit banana = new Fruit();
생성자
banana.setName("바나나");
// System.out.println(banana.getName());
banana.color = "노랑";
banana.isSeed = false;
Fruit melon = new Fruit("멜론","초록",true);
System.out.println(melon.getName()+melon.color+melon.isSeed);
Fruit orange = new Fruit();
// 생성자
orange.setName("오렌지");
orange.color = "주황";
orange.isSeed = true;
System.out.println(orange.getName()+orange.color+orange.isSeed);
}
}
!! 지금까지 배운 생성자메소드와 메소드를 만들어봤습니다!!
!! 한번 쭉 읽어보고 이해를 못하는 부분이 있다면 글을 처음부터 읽어보는걸 추천함!!
package day7;
public class People {
private String name;
private int age;
// 생성자 만들기
// 1.기본생성자
// 2.매개변수(String)생성자
// 3. 매개변수 (String,int)생성자
public People() {
}
public People(String name) {
this.name = name;
}
public People(String name, int age) {
this.name = name;
this.age = age;
}
// 메소드 만들기
// 1.name의 get,set메소드
// 2.age의 get,set메소드
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public void print() {
System.out.printf("%s의 나이는 %d입니다\n", name, age);
}
public void print1() {
System.out.printf("%s의 나이는 %d입니다\n",name,age);
}
public void print2() {
System.out.printf("%s의 나이는 %d입니다\n",name,age);
}
}
===================================================================================
package day7;
public class People_Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
People op1 = new People();
op1.setName("홍길동");
op1.setAge(17);
op1.print();
People op2 = new People("이몽룡");
op2.setAge(18);
op2.print1();
People op3 = new People("심청이",19);
op3.print2();
}
}
!!지금까지 배운 클래스 메소드를 이용하여 로그인 기능을 만들어보는 시간입니다!!
package day7;
public class Ex01_User {
> 클래스에 설정해둔 변수와 메소드 목록입니다 <
private String name;
private String id;
private String pw;
public Ex01_User() {
}
public Ex01_User(String name , String id , String pw) {
this.name = name;
this.id = id;
this.pw = pw;
}
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
public String getId() {
return this.id;
}
public void setId(String id) {
this.id = id;
}
public String getPw() {
return this.pw;
}
public void setPw(String pw) {
this.pw = pw;
}
public void print() {
System.out.printf("%s\t%s\t%s\n",name,id,pw);
}
}
=====================================================================================
>클래스에 설정한 메소드와 변수를 이용하여 만들어본 메인입니다<
package day7;
import java.util.Scanner;
public class Ex01_User_Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
Ex01_User[] userList = new Ex01_User[100]; << 클래스를 배열로 만든모습
int cnt = 0; < 배열 번호역활을하는 변수 cnt를 만듬
while (true) { < 반복문을 이용하여 기능을 계속 출력할 수 있게함
System.out.println("====회원가입====");
System.out.println("1.회원가입 2.로그인 3.리스트 0.종료");
System.out.print("메뉴 선택 >");
int menu = sc.nextInt();
if (menu == 1) { < 조건문을 이용하여 메뉴1번을 입력하는 경우 실행하게 만듬
Ex01_User user = new Ex01_User(); < Ex01_User 클래스의 메소를 사용 가능하게함
System.out.print("이름 입력 >");
user.setName(sc.next()); // 객체로 입력받음 < 입력 정보를 메소드의 매개변수 자리에 입력되게함
System.out.print("아이디 입력 >");
user.setId(sc.next()); // 객체로 입력받음
System.out.print("비밀번호 입력 >");
user.setPw(sc.next()); // 객체로 입력받음
userList[cnt] = user; < 처음 배열로 만든 클래스에 입력받은 정보를 넣음
System.out.println("회원가입 성공!");
cnt++; < 마지막에 방번호를 1증가시키기 위해 조건문을 빠져나가기 전 cnt를 1증가시킨 모습
} else if (menu == 2) {
System.out.print("로그인 아이디 >");
String loginId = sc.next(); < 로그인 아이디 , 비밀번호 입력받아 각 변수에 대입
System.out.print("로그인 비밀번호 >");
String loginPw = sc.next();
for(int i = 0 ; i <cnt ; i++) { < 반복문 for을 이용하여 i를 1씩 증가시킴
if(loginId.equals(userList[i].getId())&&loginPw.equals(userList[i].getPw())) {
System.out.println(userList[i].getName()+"님 로그인 성공!");
break;
>입력받은 정보를 저장한 변수와 배열로 만든 클래스의 정보가 맞는지 조건문if를 이용하여 확인함
>입력받은 정보와 맞는 클래스 배열이 있다면 로그인 성공을 출력하고 반복문을 break로 빠져나감
}else if(i == cnt-1) { <i가 cnt-1과 같아진다면 로그인 실패를 출력하게 만듬
System.out.println("로그인 실패");
}
}
} else if (menu == 3) {
System.out.println("이름\t아이디\t비밀번호");
System.out.println("------------------------");
for(int i = 0 ; i <cnt ; i++) {
userList[i].print();
}
} else if (menu == 0) {
break;
}else {
System.out.println("없는 메뉴");
}
}
System.out.println("시스템 종료");
}
}
