java 공부 3주차

method

primitive data type의 경우 같은 값을 저장하면 포인터가 같은 곳을 가리킴.
ex) int p1=1;
int p2=1;
p1==p2//true

그렇지 않은 경우 같은 곳에 저장되지 않음
ex) String o1=new String("java"); 혹은 String o1="java";
String o2=new String("java");
o1==o2//false
o1.equals(o2)//true
원시 데이터타입은 equals를 가지고 있지 않음

그러나 특별히 String의 경우 원시데이터 타입처럼 작동 
String o3="java2"
String o4="java2"
o3==o4//true!
이때 같은 값을 집어넣으면 변수가 같은 곳을 가리키므로 true가 나옴.

 

Output.java

public class OutputMethod {
     
    public static String a() {
        // ... 
        return "a";
    }
     
    public static int one() {
        return 1;
        //...
    }
 
    public static void main(String[] args) {
 
        System.out.println(a());
        System.out.println(one());
         
    }
}

WhyMethod.java

import java.io.FileWriter;
import java.io.IOException;

public class WhyMethod {
     
    public static void main(String[] args) throws IOException {
            printTwoTimes("a", "-"); //인자, argument
            printTwoTimes("a", "*");
            printTwoTimes("a", "&");
            printTwoTimes("b", "!");
           writeFileTwoTimes("hello", "////");
 
    }
    
    public static void printTwoTimes(String text, String delimiter) { //parameter, 매개변수
        System.out.println(delimiter);
        System.out.println(text);
        System.out.println(text);
    }
    public static void writeFileTwoTimes(String text, String delimiter) throws IOException{
    	FileWriter fw= new FileWriter("output.txt");
    	fw.write(delimiter+"\n");
    	fw.write(text+"\n");
    	fw.write(text+"\n");
    	fw.close();
    }
 
}

<<access level modifiers>>
public, protected, default, private이 있음.
private: 같은 클래스 내에서만 사용 가능
protected: 동일 패키지 혹은 파생 클래스
default: 동일 패키지
public: 접근 제한 없음

<<static>>
static - class method
no static - instance method
method가 class의 소속일 때는 static이 있어야 하고, instance의 소속일 때는 static이 없어야 함

 

객체지향프로그래밍(OOP)

MyOPP.java

public class MyOOP { //파일 이름과 같은 class에는 public을 붙임
    public static void main(String[] args) {
        Print.delimiter = "----";
        Print.A();
        Print.A();
        Print.B();
        Print.B();
        
        Print.delimiter = "****";
        Print.A();
        Print.A();
        Print.B();
        Print.B();
    }
}

StaticApp.java

class Foo{
    public static String classVar = "I class var";
    public String instanceVar = "I instance var";
    public static void classMethod() {
        System.out.println(classVar); // Ok
//      System.out.println(instanceVar); // Error
    }
    public void instanceMethod() {
        System.out.println(classVar); // Ok
        System.out.println(instanceVar); // Ok
    }
}
public class StaticApp {
 
    public static void main(String[] args) {
        System.out.println(Foo.classVar); // OK
//      System.out.println(Foo.instanceVar); // Error
        Foo.classMethod();
//      Foo.instanceMethod();
         
        Foo f1 = new Foo();
        Foo f2 = new Foo();
//      
        System.out.println(f1.classVar); // I class var
        System.out.println(f1.instanceVar); // I instance var
//      
        f1.classVar = "changed by f1";
        System.out.println(Foo.classVar); // changed by f1
//        System.out.println(f2.classVar);  // changed by f1
//      
        f1.instanceVar = "changed by f1";
        System.out.println(f1.instanceVar); // changed by f1
        System.out.println(f2.instanceVar); // I instance var
    }
 
}

Print.java

class Foo{
    public static String classVar = "I class var";
    public String instanceVar = "I instance var";
    public static void classMethod() {
        System.out.println(classVar); // Ok
//      System.out.println(instanceVar); // Error
    }
    public void instanceMethod() {
        System.out.println(classVar); // Ok
        System.out.println(instanceVar); // Ok
    }
}
public class StaticApp {
 
    public static void main(String[] args) {
        System.out.println(Foo.classVar); // OK
//      System.out.println(Foo.instanceVar); // Error
        Foo.classMethod();
//      Foo.instanceMethod();
         
        Foo f1 = new Foo();
        Foo f2 = new Foo();
//      
        System.out.println(f1.classVar); // I class var
        System.out.println(f1.instanceVar); // I instance var
//      
        f1.classVar = "changed by f1";
        System.out.println(Foo.classVar); // changed by f1
//        System.out.println(f2.classVar);  // changed by f1
//      
        f1.instanceVar = "changed by f1";
        System.out.println(f1.instanceVar); // changed by f1
        System.out.println(f2.instanceVar); // I instance var
    }
 
}

AccountingApp.java

class Accounting{
    public double valueOfSupply;
    public static double vatRate = 0.1;
    public Accounting(double valueOfSupply) { //생성자는 클래스의 이름과 동일
        this.valueOfSupply = valueOfSupply;
    }
    public double getVAT() {
        return valueOfSupply * vatRate;
    }
    public double getTotal() {
        return valueOfSupply + getVAT();
    }
}
public class AccountingApp {
    public static void main(String[] args) {
        Accounting a1 = new Accounting(10000.0);
         
        Accounting a2 = new Accounting(20000.0);
         
        System.out.println("Value of supply : " + a1.valueOfSupply);
        System.out.println("Value of supply : " + a2.valueOfSupply);
         
        System.out.println("VAT : " + a1.getVAT());
        System.out.println("VAT : " + a2.getVAT());
         
        System.out.println("Total : " + a1.getTotal());
        System.out.println("Total : " + a2.getTotal());
         
  
    }
}

 

class 파일 쉽게 만드는 방법) class 부분 드래그>Refactor>Move type to new file 클릭

interface에 관하여)
interface는 일종의 규격, 틀 같은 것
interface에 method1, 2를 정의(구체적인 내용은 정의하지 않음)
interface Contract {
public String method1(String param);
public int method2(int param);
}
class Concreate1 implements Contract{
//Contract interface에 정의된 모든 멤버들을 구현하지 않으면 컴파일되지 않음
}
-> 처음 보는 클래스가 있어도 해당 인터페이스에 포함된 멤버들은 모두 구현이 되었을 것이라는 점을 알아차릴 수 있음

package에 관하여)
class를 정돈하는 directory로 사용됨.
같은 이름의 클래스가 있어도 서로 다른 패키지에 소속되어 있으면 상관 없음!

상속

overloading: 동일 클래스 내에서 같은 이름의 메소드 존재, 매개변수 구성이 다르면 ok
overriding: 부모 클래스에서 정의된 메소드를 자식 클래스에서 재정의(덮어쓰기)

this: 자기 자신, super: 부모 클래스
추가 개념들) Polymorphism(다형성), Access Modifiers, Final(overriding 금지 등), Abstact(상속자가 구현해야 하는 기능 강제)

 

class Cal{
	int v1, v2;
	Cal(int v1, int v2){
		System.out.println("Cal created");
		this.v1=v1;
		this.v2=v2;
	}
	public int sum() {return this.v1+v2;}
}
class Cal3 extends Cal{

	Cal3(int v1, int v2) {
		super(v1, v2); //생성자가 있는 클래스를 상속받았다면 부모 클래스를 반드시 호출해야함
		System.out.println("Cal3 created");
	}
	public int minus() {return this.v1-v2;}
	public int sum2() {return super.sum()+v1;}
 
}
public class InheritanceApp {
    public static void main(String[] args) {
    	
        Cal c = new Cal(2,1);
        Cal3 c3 = new Cal3(100,300);
        
        System.out.println(c.sum());
        System.out.println(c3.sum());  //c 클래스의 sum 메소드가 실행됨
        System.out.println(c3.minus());
        System.out.println(c3.sum2());
    }
}

 

 

cf)

C++에서는 this를 자기 자신을 가리키고 있는 포인터, *this를 자기 자신의 클래스 자체로 사용하였다. 따라서 포인터로 클래스 객체를 가리킬 때와 동일하게 this->클래스 멤버의 형식으로 this 포인터를 사용하였다.(클래스 네임으로 지정할 경우 ClassName.Method()와 같이 사용)
하지만, java에서는 this.method()와 같이 this를 사용하게 된다. java에는 포인터 개념이 없기 때문에 포인터로 클래스 멤버를 가리킬 때와 클래스 네임으로 클래스 멤버를 가리킬 때가 구분되지 않는다.
포인터가 왜 없는지를 조사하며 GC(Garbage Collector)에 대해 알게 되었는데, 쓰레기 객체(참조값이 끊어진 객체)를 정리해주는 역할을 한다. 사용자가 포인터를 이용해 주소값을 마음대로 건드리게 되면 치명적인 오류가 발생할 수 있기 때문에, 이를 막는 차원에서 포인터가 존재하지 않는다고 한다. java를 공부하며 C++과 달리 객체를 delete로 동적 소멸시켜주지 않아도 되는 이유를 알게 되었다.

 

이렇게 생활코딩의 JAVA 강의를 모두 마쳤다.