24~ 31

/*class Orange {
    int a,b;
    Orange(){

    }
    void func01() {
        System.out.println("함수1번콜");
    }
}
 */
package Pack01;
import java.util.concurrent.SynchronousQueue;
class Apple {
    int a,b;
    Apple(){
 
    }
    void Print() {
        System.out.println(a+" "+b);
    }
    void func01(int x,int y) {
        
    }
    void func02(int a,int b) {
        //인수와 필드명(변수가)이 같다.
        this.a = a;//변수를 인수에 대입
        this.b = b;//this. 가 선호됨
    }
    void func03() {
        System.out.println(this);
    }
 
    Apple func04() {
        Apple apple = new Apple();//비행기 제작
        return apple;
    }
}
public class Hello {
    public static void main(String[] args) {
        Apple a1 = new Apple();
        Apple a2 = new Apple();
        
        a1.Print();
        a1.func01(10, 10);//갱신이 된것이다.
        System.out.println(a1);//a1과 this의 민증번호가 같다.
        System.out.println();
        //this는 생성된 객체를 나타낸다.
        a1.func03();
        //this는 고정값이 아니다.
        System.out.println(a2);
        a2.func03();
        a2.func04();//비행기 만들고 버렸다.
        System.out.println();
        Apple a3 = a2.func04();//비행기랑 객체 a3랑 공유
        System.out.println(a2);
        System.out.println(a3);
        
        Apple a4 = a3.func04();//객체가 새로 생성되서 a,b는 각자 0 초기값 들고있다.
        //생성자콜시 초기화?
        
        a4.func02(100,200);
        a4.Print();
        System.out.println("---------------------");
        a1.Print();
        a2.Print();
        a3.Print();
        a4.Print();
        System.out.println("---------------------");
        System.out.println(a1);
        System.out.println(a2);
        System.out.println(a3);
        System.out.println(a4);
        //서로 짝이 맞다
        System.out.println("---------------------");
        a1.func03();
        a2.func03();
        a3.func03();
        a4.func03();
        
        
    }
}
 
 

26번

//객체 생성후 (객체.외부클래스함수)

package Pack01;
import java.util.concurrent.SynchronousQueue;
class Apple {
    int a,b;
    Apple(){
 
    }
    Apple func01() {
        return this;//this = 밑에 객체생성된 a1 => Apple type
    }
    void func02() {
        System.out.println("호랑이");
    }
    Apple func03() {
        System.out.println("코끼리");
        return this;//this = 밑에 객체생성된 a1 => Apple type
    }
    Apple func04() {
        System.out.println("독수리");
        return this;//this = 밑에 객체생성된 a1 => Apple type
    }
}
public class Hello {
    public static void main(String[] args) {
        Apple a1 = new Apple();
        a1.func01();
        Apple a2 = a1.func01();
        System.out.println(a1);
        System.out.println(a2);
        
        System.out.println("---------------------");
        Apple a3 = new Apple();
        a3.func01().func02();//체이닝은 많은 함수를 쓰기위해 사용
        a3.func03().func04().func03().func02();//순서대로 함수호출 func2는 안되므로 마침
        //Java - web프로그래밍 android프로그래밍
        //this  = self java가 밀리면서 밀림 = 파이썬에서 쓰임
        
        
    }
}
 
 

27번

package Pack01;
import java.util.concurrent.SynchronousQueue;
class Apple {
    int a,b;
    static int c;//처음부터 메모리가 있다. Apple.c 가능
    void Print() {
        
    }
    static void func01() {//static을 붙이게 되면 compile을 할때 한칸 위로 올라간다.
        //static는 처음부터 메모리가 만들어진다.
        //객체 생성하지않아도 처음부터 바로 메모리로 만들어버린다.
        
        
        
        //메모리 많이드는 순서
        
        //1. file i/o(파일입출력)     시간이 걸린다 = 비용이 든다 = 메모리를 많이 잡아먹는다.
        //2. 함수 콜                      유용하기 때문에
        //3. 객체 생성 new             메모리 많이듬
        //수학,연산 관련된 것들은 static를 쓴다.
        System.out.println("호랑이");
    }
    static void func02() {
        System.out.println("코끼리");
        func01();
        //static함수 안에서는 this를 쓸 수 없다 = 객체 없이 쓰는데 생성된 객체를 의미하는 this는 쓸 수 없다.
        //Print.func02();
        //static함수 안에서는 static함수만 콜할 수 있다.
    }
}
public class Hello {
    public static void main(String[] args) {
        Apple.func01();//static를 썻을때 객체생성없이 쓸 수 있다.
        //(class hello(static(void main = 함수)))  hello가 객체 생성하고 main을 써야되는데
        // static를 써서 객체 생성없이 바로 사용한다.
        
        
        
        
        /*Apple a1 = new Apple();    
        a1.func01();*/
        
    }
}
 
 

28번

package Pack01;
import java.util.concurrent.SynchronousQueue;
class Apple {
    int a,b;
    static int c;//c안에 없고 밖에 있다고 취급
    void Print() {
    }
    Apple(){
        
    }
    void func01() {
        a=10;
        b=20;
        c=30;
    }
    static void func02() {
        //a=10;
        //객체 생성시 사용가능
        c=50;//static으로 변수는 가능
        
        //static함수에서는 static 변수나 static함수만 사용할 수 있다.
        
    }
}
public class Hello {
    public static void main(String[] args) {
        
        Apple.c=10;
        Apple a1 = new Apple();
        a1.a = 10;
        a1.b = 20;
        a1.c = 30;
        Apple a2 = new Apple();
        a2.a = 40;
        a2.b = 50;
        a2.c = 60;
        
        System.out.println(a2.a+" "+a2.b+" "+a1.c+" "+a2.c);//static로 써져서 메모리 하나만 만들고 빠져나감
        //a b 처럼 객체 생성할때마다 바뀌는게 아님
        //static는 객체 생성마다 영향을 받지 않는다.
        
        
    }
}
 
 

29번

package Pack01;
import java.util.concurrent.SynchronousQueue;
class Apple {
    int a,b;
    void func01() {
 
    }
}
public class Hello {
    static int a,b;
    static void func01() {//static를 써줘야 main에서 사용가능하다.
        System.out.println("호랑이");
    }
    void func02() {
        //함수안에서는 static 사용불가하다.
    }
    public static void main(String[] args) {
        func01();
        a=10;
        b=20;
        int a = 0;
    }
}
 
 

30번

package Pack01;
import java.util.concurrent.SynchronousQueue;
class Apple {
    int a;
    private int b;//private = class안에서만 사용가능
    void print() {
 
    }
    void func01() {
        System.out.println("호랑이");
    }
    private void func02() {
        System.out.println("고양이");
    }
    private void func03() {
        System.out.println("물을 끓입니다.");
    }
    private void func09() {//손님은 건드리지 마라
        System.out.println("우유를 넣습니다.");
    }
    private void func04() {
        System.out.println("라면을 넣습니다.");
    }
    private void func05() {
        System.out.println("계란도 넣습니다.");
    }
    void func06() {
        func03();
        func04();
        func05();
        System.out.println("요리가 완성되었습니다");
    }
    void func07() {
        System.out.println("물을 끓입니다.");
        System.out.println("라면을 넣습니다.");
        System.out.println("계란도 넣습니다.");
        System.out.println("요리가 완성되었습니다");
    }
    void func08() {
        func03();
        func04();
        System.out.println("요리가 완성되었습니다");
    }
}
public class Hello {
    public static void main(String[] args) {
        Apple a1 = new Apple();
        a1.a = 10;
        //a1.b = 20;//private는 class밖에서는 사용할 수 없다.
        a1.func01();
        //a1.func02();//private는 class밖에서는 사용할 수 없다.
        a1.func06();//345는 못쓰게 private를 쓰고 6번만 쓸 수 있도록함. 데이터 은닉
        //함수는 한가지기능만 할 수 있도록 한것이 가장 잘만든 함수이다.
        a1.func08();
        //func06(),func08() 같이 레시피대로 하는 이 과정을 캡슐화라고 한다. private ,데이터 은닉
    }
}
 

31번

package Pack01;
import java.util.concurrent.SynchronousQueue;
class Apple {
    int a,b;
    private Apple(){//객체 생성시켜서 쓰지마세요~
        //우린 static함수만 있으니 static를 쓰세요~
    }
    void print() {
 
    }
    static void func01() {
        System.out.println("호랑이");
    }
}
public class Hello {
    public static void main(String[] args) {
        //Apple a1 = new Apple();//생성자가 pirvate이므로 객체 생성할 수 없다.
        Apple.func01();//클래스 이름으로 바로 쓰세요
        //int a = Math.abs(-50);//abs라고 하는 함수는 static함수이다.왜냐하면 바로 갔다 쓸수 있기 떄문에!
        //함수 역할은 절댓값을 구하는 것이다 abs return값이 있는 함수이다.
        //안쓰면 날린다
        //System.out.println(a);
        System.out.println(Math.abs(-50));
        //Math m = new Math();//생성자가 private이여서 쓸 수 없다.
        System.out.println();
        System.out.println(Math.max(10, 20));
        System.out.println(Math.min(10, 20));
        System.out.println(Math.sqrt(73));
        System.out.println(Math.sqrt(73));
        //mc**2=e mc sqrt 
        float a = 3.0f;
        float b = 5.0f;
        System.out.println(Math.sqrt((a*a)+(b*b)));
                
    }
}