ArgsTest
명령행매개변수 : 프로그램이 실행될때 외부에서 값을 입력받아서 사용할 수 있도록 제공(jdk의 초창기 버전)
- 만드는 법 : 상단바 Run - Run configurations - 파일선택, argument들어가서 string prompt 적용
- 프로그램을 실행하면서 값을 입력하면,
인터프리터가 클래스명 다음에 몇개를 입력했는지 공백문자로 구분해서 확인하고
그 갯수만큼 String배열을 만들어서 args에 할당 - [command창에서 실행하는 경우]
java 클래스명 매개변수1 매개변수2 ...
package array;
public class ArgsTest {
public static void main(String[] args) {
System.out.println(args.length);
System.out.println(args[0]+":"+args[1]);
int val2 = Integer.parseInt(args[1]);
//String -> int로 변환
System.out.println(Integer.parseInt(args[0])+ val2);
}
}Integer in = new Interger();
in.parseInt() //일반적인 클래스의 메소드를 사용하는 방법이나
static이 추가된 메소드는 클래스명.메소드명()
ArgsExam
명령행매개변수로 값을 5개 입력받아 총점과 평균을 출력할 수 있도록 작업
package array;
public class ArgsExam {
public static void main(String[] args) {
int sum = 0;
for(int i=0;i<args.length;i++) {
sum = sum+ Integer.parseInt(args[i]);
}
System.out.println("총점:"+sum);
System.out.println("평균:"+(sum/args.length));
//향상된 for문 ver
int sum2 = 0;
for(String val:args) {
sum2 = sum2 + Integer.parseInt(val);
}
System.out.println("총점:"+sum2);
System.out.println("평균:"+(sum2/args.length));
}
}Constructor
생성자 추가
- 기본생성자
: 생성자내부에서 객체가 생성될때 실행될 코드를 정의
public Constructor() {
}- 매개변수가 있는 생성자
: 각각 다른 갯수의 매개변수를 각 멤버변수에 할당
super와 this랑 같이쓸수없음
super는 부모의 생성자 호출하는거
생성자메소드의 호출은 한가지 종류만 호출
this가 있으면 super()는 없어야 한다
같은 클래스 내부에서 정의된 생성.. 내안에서만 호출가능-this 키워드 자체가 그럼
public Constructor(String name, String id, String pass, String addr) {
this.name = name;
this.id = id;
this.pass = pass;
this.addr = addr;
System.out.println("매개변수4개 생성자");
}public Constructor(String name, String id, String pass, String addr, String telNem, String ssn, String nickName) {
this(name, id, pass, addr);
this.telNem = telNem;
this.ssn = ssn;
this.nickName = nickName;
System.out.println("매개변수7개 생성자");
}public Constructor(String name, String id, String pass, String addr, String telNem, String ssn, String nickName,
int point) {
this(name, id, pass, addr, telNem, ssn, nickName);
this.point = point;
System.out.println("매개변수8개 생성자");
}package oop.basic.constructor;
public class Constructor {
private String name;
private String id;
private String pass;
private String addr;
private String telNem;
private String ssn;
private String nickName;
private int point;
// 기본생성자
public Constructor() {
//생성자내부에서 객체가 생성될때 실행될 코드를 정의
System.out.println("Constructor 기본생성자");
}
// 매개변수가 있는 생성자
public Constructor(String name, String id, String pass, String addr) {
//4개의 매개변수를 각 멤버변수에 할당
this.name = name;
this.id = id;
this.pass = pass;
this.addr = addr;
System.out.println("매개변수4개 생성자");
}
//insert용
public Constructor(String name, String id, String pass, String addr, String telNem, String ssn, String nickName) {
this(name, id, pass, addr);
this.telNem = telNem;
this.ssn = ssn;
this.nickName = nickName;
System.out.println("매개변수7개 생성자");
}
//select용
public Constructor(String name, String id, String pass, String addr, String telNem, String ssn, String nickName,
int point) {
this(name, id, pass, addr, telNem, ssn, nickName);
this.point = point;
System.out.println("매개변수8개 생성자");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getPass() {
return pass;
}
public void setPass(String pass) {
this.pass = pass;
}
public String getAddr() {
return addr;
}
public void setAddr(String addr) {
this.addr = addr;
}
public String getTelNem() {
return telNem;
}
public void setTelNem(String telNem) {
this.telNem = telNem;
}
public String getSsn() {
return ssn;
}
public void setSsn(String ssn) {
this.ssn = ssn;
}
public String getNickName() {
return nickName;
}
public void setNickName(String nickName) {
this.nickName = nickName;
}
public int getPoint() {
return point;
}
public void setPoint(int point) {
this.point = point;
}
}
Prob / Rectangle : exam
package oop.basic.constructor;
public class Prob {
public static void main(String[] args){
Rectangle rectangle01 = new Rectangle(10, 20, "청색");
rectangle01.calculateArea();
System.out.println("1 : "+rectangle01.getColor()+" 직사각형 면적 : "+rectangle01.getArea());
Rectangle rectangle02 = new Rectangle(20, 20);
rectangle02.calculateArea();
System.out.println("2 : "+rectangle02.getColor()+" 직사각형 면적 : "+rectangle02.getArea());
Rectangle rectangle03 = new Rectangle();
rectangle03.setHeight(10);
rectangle03.setWidth(10);
rectangle03.setColor("녹색");
rectangle03.calculateArea();
System.out.println("3 : "+rectangle03.getColor()+" 직사각형 면적 : "+rectangle03.getArea());
}
}package oop.basic.constructor;
public class Rectangle {
private int height;
private int width;
private String color;
private int area;
public Rectangle() {
//매개변수없는 기본생성자 하나 있어야함
}
public Rectangle(int height, int width) {
this.height = height;
this.width = width;
this.color = "흰색";
//멤버변수에 웬만하면 값을 안주는게 나아서 여기에 주기
}
public Rectangle(int height, int width, String color) {
this(height,width);
this.color = color;
}
public Rectangle(int height, int width, String color, int area) {
this(height,width,color);
this.area = area;
}
public int getHeight() {
return height;
}
public void setHeight(int height) {
this.height = height;
}
public int getWidth() {
return width;
}
public void setWidth(int width) {
this.width = width;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public void calculateArea() {
area = width * height;
}
public int getArea() {
return area;
}
}package oop.basic.constructor;
import java.util.Scanner;
public class TestRectangle {
public static void main(String s[]){
Scanner keyboard = new Scanner(System.in);
Rectangle2 rec1 = new Rectangle2();
System.out.println("첫번째 직사각형의 색깔: ");
rec1.setColor(keyboard.next());
System.out.println("첫번째 직사각형의 가로: ");
rec1.setWidth(keyboard.nextInt());
System.out.println("첫번째 직사각형의 세로: ");
rec1.setLength(keyboard.nextInt());
Rectangle2 rec2 = new Rectangle2();
System.out.println("두번째 직사각형의 색깔: ");
rec2.setColor(keyboard.next());
System.out.println("두번째 직사각형의 가로: ");
rec2.setWidth(keyboard.nextInt());
System.out.println("두번째 직사각형의 세로: ");
rec2.setLength(keyboard.nextInt());
System.out.println(rec1.getColor() + " 직사각형의 넓이는 " + rec1.area() + "이고 둘레는 " + rec1.perimeter() + "입니다.");
System.out.println(rec2.getColor() + " 직사각형의 넓이는 " + rec2.area() + "이고 둘레는 " + rec2.perimeter() + "입니다.");
// TODO 1) 두 직사각형의 넓이를 비교하십시오.
if(rec1.area()>rec2.area()) {
System.out.println("넓이는 "+rec1.getColor()+" 직사각형이 더 큽니다.");
}else if(rec1.area()<rec2.area()) {
System.out.println("넓이는 "+rec2.getColor()+" 직사각형이 더 큽니다.");
}else {
System.out.println("넓이는 같습니다.");
}
// TODO 2) 두 직사각형의 둘레를 비교하십시오.
if(rec1.perimeter()>rec2.perimeter()) {
System.out.println("둘레는 "+rec1.getColor()+" 직사각형이 더 큽니다.");
}else if(rec1.perimeter()<rec2.perimeter()) {
System.out.println("둘레는 "+rec2.getColor()+" 직사각형이 더 큽니다.");
}else {
System.out.println("둘레는 같습니다.");
}
}
}package oop.basic.constructor;
public class Rectangle2 {
private String color;
private int width;
private int length;
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public int getWidth() {
return width;
}
public void setWidth(int width) {
this.width = width;
}
public int getLength() {
return length;
}
public void setLength(int length) {
this.length = length;
}
//면적계산- 조건만족을 위해 위에 변수정의하지않고 바로하기
public int area() {
int result = width * length;
return result;
}
//둘레계산
public int perimeter() {
return (width + length)*2;
}
}StaticDemo, StaticDemoTest
인스턴스변수와 클래스변수의 비교
- 인스턴스변수 : 객체가 소유하는 변수(객체변수 : 객체가 고유한 값을 갖는 경우)
- 클래스변수(정적변수):모든 객체가 공유해서 사용하는 변수
인스턴스 변수에 static이 추가된 변수를 클래스변수라 한다.
상수는 변하지 않는 값으로 모든객체가 공유해서 사용해야하므로 상수를 정의할때 final과 static을 같이 사용
package oop.basic;
public class StaticDemo {
int num; //인스턴스 변수
static int staticNum;//모든객체가 공통으로 사용하는 값이나 누적된 값을 저장하기 위해서
public StaticDemo() {
num++;
staticNum++;
}
public void display() {
System.out.println("num=>"+num+", staticNum=>"+staticNum);
}
}- num인스턴스변수(객체변수)와 staticNum클래스변수가 다르므로 외부에서 접근하는 방법도 다르다.
- num은 인스턴스변수이므로 객체참조변수를 통해서 사용
-> obj1.num - staticNum은 객체의 소유가 아니라 클래스에 정의된 공유변수이고 메모리 공통으로 사용하는 영역에 할당되므로 어떤 객체의 소유도 아님
- static이 추가된 변수나 메소드
클래스명.변수
클래스명.메소드()
package oop.basic;
public class StaticDemoTest {
public static void main(String[] args) {
StaticDemo obj1 = new StaticDemo();
obj1.display();
System.out.println("인스턴스변수=>"+obj1.num+",클래스변수=>"+StaticDemo.staticNum);
StaticDemo obj2 = new StaticDemo();
obj2.display();
System.out.println("인스턴스변수=>"+obj2.num+",클래스변수=>"+StaticDemo.staticNum);
StaticDemo obj3 = new StaticDemo();
obj3.display();
System.out.println("인스턴스변수=>"+obj3.num+",클래스변수=>"+StaticDemo.staticNum);
//API에서 제공되는 static변수도 동일한 방법으로 접근
System.out.println(Math.random());
System.out.println(Math.PI);
}
}
StaticMethodDemo &Test
- static 메소드와 non-static 메소드의 차이점과 사용방법
static 메소드는 static 멤버의 값을 조작하거나 유틸리티처럼 메소드를 편하게 사용하기 위한 목적
자원을 엑세스하거나 모든 객체에서 공통으로 사용하는 기능을 static 메소드로 표현
public class StaticMethodDemo {
static int staticNum;//클래스변수
int num;//인스턴스변수
//static블럭 - 클래스 로더에 의해서 클래스에 대한 정보가 메소드 영역에 올라갈때 한번 실행되는 영역
static {
//static멤버변수의 값을 초기화할때 여기서
staticNum = 1000;
System.out.println("static블럭 - 클래스가 로딩될때 한번실행되는 코드를 정의할 목적");
System.out.println("static블럭 - 자원에 대한 엑세스");
System.out.println("static블럭 - static멤버를 초기화할 목적으로 사용");
}
//객체의 고유한 값을 제어하는 기능이 아니라 일반적인 기능들도 static을 추가할지 고려해봐야함
public static void printSize(String str) { //-------정적메소드
//매개변수로 전달되는 문자열의 사이즈를 출력하는 기능
System.out.println("사이즈=>"+str.length());
}
public static void print() {//-------정적메소드
System.out.println("===================================");
//1.static메소드에서 static메소드를 호출하기
//=>일반적인 접근방식
display();
}
//static멤버를 제어하는 메소드는 static을 추가
public static void display() {//-------정적메소드
System.out.println(staticNum);
}
public void show() {//-------인스턴스 메소드
//2.non-static메소드에서 non-static메소드를 호출
//=>일반적인 접근방식
test();
System.out.println(num);
}
public void test() {//-------인스턴스 메소드
//non-static메소드에서 static메소드호출
//=>일반적인 접근방식
//메소드에 할당되는 메모리가 다른데 가능한 이유? -> 이해못함..
change();
System.out.println("테스트");
}
public static void change() {//-------정적메소드
//4. static메소드에서 non-static메소드를 호출 280p 참고
//=>change가 메모리에 있는 상태에 바로 examtest를 확인할 수 없으므로 에러발생
//=>같은 클래스에서 선언된 메소드라 해도 static메소드 안에서 non-static메소드를 호출하는경우
// 객체생성후 참조변수를 통해서 호출
//static메소드-static멤버변수를 제어, 객체에 속한 기능이 아닌 메소드를 정의
StaticMethodDemo obj = new StaticMethodDemo();
obj.examtest();
System.out.println("change");
}
public void examtest() {//-------인스턴스 메소드
System.out.println("examtest");
}
}
밑에서부터 올라옴
StaticMethodTest
package oop.basic;
public class StaticMethodTest {
//main은 자바인터프리터(java.exe)에서 호출되는 메서드
public static void main(String[] args) {
StaticMethodDemo.print();//프린트가 시작될때 스태틱블럭이 먼저 실행되는거 확인!
StaticMethodTest obj = new StaticMethodTest();
obj.show();//static 안에서 non-static호출
display();//static안에서 static호출
}
public static void display() {
System.out.println("display");
}
public void show() {
System.out.println("show");
}
}
inheritance - 상속
public class 동물after{
public static void main(String[] args) {
//상속관계에서 생성해서 사용하는 객체는 주로 하위클래스
뱀after obj = new 뱀after();
obj.이동방법 = "기어서";
obj.이동하다();
}
}
//일반화시킨다.= 상속관계를 만들기
class 동물{//상위클래스
String 이름;
String 이동방법;
public void 몸무게출력하기(int 몸무게, String 이름) {
System.out.println("몸무게: "+몸무게);
}
public void 이동하다(){
System.out.println(이동방법+"으로 이동함");
}
}
//일반화시키기후
class 뱀after extends 동물{
int 몸길이;
public void set몸길이(int 몸길이){
this.몸길이 = 몸길이;
}
}
class 독수리after extends 동물{
int 날개길이;
public void set날개길이(int 날개길이){
this.날개길이 = 날개길이;
}
}
class 코끼리after extends 동물{
int 귀크기;
public void set귀크기(int 귀크기){
this.귀크기 = 귀크기;
}
}
class 고래after extends 동물{
int 지느러미길이;
public void set지느러미길이(int 지느러미길이){
this.지느러미길이 = 지느러미길이;
}
}
상속 예시
상위클래스 정의
package oop.inheritance;
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
하위클래스
package oop.inheritance;
public class Teacher extends Person {
String subject;
public Teacher() {
}
public Teacher(String name, int age, String subject) {
super(name, age);
this.subject = subject;
}
public void setSubject(String subject) {
this.subject = subject;
}
public String getSubject() {
return subject;
}
public void display() {
System.out.println("이름 : "+getName()+"\t"+" 나이 : "+getAge()+"\t"+" 담당과목 : "+subject);
}
}
상속관계에서 멤버변수가 갖는 특징, 상속테스트1
- 상속관계에서 상위클래스에 선언된 멤버변수는 하위클래스에서 접근이 가능하다.
- 상위클래스에서 선언된 변수와 동일한 이름의 멤버변수를 하위클래스에서 정의하면, 하위클래스내부에서는 부모클래스의 멤버변수보다 하위클래스의 멤버변수가 우선순위가 높다.
- 하위클래스에서 상위클래스의 멤버를 접근하고 싶은 경우 super키워드를 이용해서 접근
객체를 지칭하는 용어 키워드는 수퍼와 디스뿐..
this -> 자기자신의 객체
super -> 부모객체 - 상위클래스의 멤버가 private으로 정의되어 있으면 하위클래스에서 접근할 수 없다
package oop.inheritance;
class Super{
int num = 10;
}
class Sub extends Super{
int num = 100;
public void display() {
System.out.println("num=>"+num);
System.out.println("부모의 num=>"+super.num);
}
}
public class InheritanceTest1 {
public static void main(String[] args) {
Sub obj = new Sub();
obj.display();
System.out.println(obj.num);
}
}출력:
num=>100
부모의 num=>10
100
상속관계에서 메소드가 갖는 특징
- 상위클래스에서 정의된 메소드를 하위클래스에서 호출할 수 있다
=>하위클래스타입의 참조변수를 통해서도 상위클래스의 메소드를 사용할 수 있다. - 상위클래스에 정의된 메소드와 동일한 메소드를 하위클래스에 정의하면 하위클래스의 메소드가 우선으로 실행된다.
=>상위클래스에 정의된 메소드의 선언부(리턴타입, 메소드명, 매개변수갯수, 매개변수타입)가 동일한 경우, 이를 메소드의 재정의 즉 메소드 오버라이딩이라 한다.
class Parent{
public void display() {
System.out.println("부모의 display()");
}
}
class Child extends Parent{
public void test() {
System.out.println("자식클래스의 test()");
display();
super.display();
}
public void display() {
System.out.println("하위클래스의 display()");
}
}
public class InheritanceTest2 {
public static void main(String[] args) {
Child obj = new Child();
obj.test();
obj.display();
}
}
출력:
자식클래스의 test()
하위클래스의 display()
부모의 display()
하위클래스의 display()
상속관계에서 생성자가 갖는 특징
- 모든클래스의 최상위클래스는 java.lang.Object클래스이다.
=>자바에서는 객체가 갖는 공통의 특징을 java.lang.Object에 정의해놓고 상속하는 클래스가 없는 경우 컴파일러를 통해 자동으로 상속받도록 하고있다.
=> JVM에서 실행될때 문제가 없으려면 내부에서 인식하는 공통의 타입을 갖고 있어야 하며, 이 타입이 java.lang.Object
=> 상속을 받는 클래스가 없는 경우 모두 extends Object생략되어있는거임.오브젝트가 최상위클래스,, - 상위클래스를 이용해서 객체를 생성하지 않고 하위클래스를 이용해서 객체를 생성해서 사용한다.
=> 상위클래스는 일반적인 내용을 담고 있는 클래스로 완성되지 않은 내용일 수 있으므로 모든 필드를 다 가지고 있는 하위클래스를 이용해서 객체를 생성하고 작업
=> 부모가 갖고 있는 멤버변수는 자식객체를 통해서 전달받아 초기화 - 상위클래스의 객체가 메모리에 할당될 수 있도록 모든 생성자의 첫번째 문장에는 super()가 생략되어있다.
즉, 부모클래스의 기본생성자를 호출하는 명령문이 생략 : super()생략
=>단, 명시적으로 생성자를 호출하는 명령문이 없는 경우
private은 아무리 상속해도 접근안됨. 오류뜸
- 부모의 매개변수가 있는 생성자를 명시적으로 호출할 수 있다.
super(매개변수1,매개변수2,...) - 생성자는 상속되지 않는다.
class SuperA extends Object{
private String name;
private String age;
public SuperA() {
System.out.println("부모의 생성자");
}
public SuperA(String name, String age) {
super();//Object의 기본생성자를 호출
this.name = name;
this.age = age;
System.out.println("부모의 매개변수 생성자");
}
}
class SubA extends SuperA{
String subdata;
public SubA() {//생성자를 아무것도 안만들면 컴파일러가 기본생성자 부여 public SubA() {}이게 기본생성자
super();//Object의 기본생성자를 호출
System.out.println("자식의 생성자");
}
public SubA(String name, String age, String subdata) {
super(name,age);//기본생성자가 아닌 매개변수 있는 생성자가 호출됨! 그래서 private라도 넘어옴ㅋ
this.subdata = subdata;
}
}
public class InheritanceTest3 {
public static void main(String[] args) {
SubA obj = new SubA();
SubA obj2 = new SubA("뷔","30","data");
}
}출력:
부모의 생성자
자식의 생성자
부모의 매개변수 생성자
본 포스팅은 멀티캠퍼스의 멀티잇 백엔드 개발(Java)의 교육을 수강하고 작성되었습니다.
