7/21 배움 (추상class, )

package pack01;
//단지 추상함수만 있는, 코드가없고 ui만 있는것은 인터페이스
//추상함수 = 추상함수 + 기본함수
 
public class Hello {//abstract class는 코드의 ui를 통일시킨다.
    //처음부터 표준 ui를 만들어 놓음으로써 다른 class들의 시행착오를 줄인다.
    //ui강조 구현은 각 class들이 한다.
    public static void main(String[] args) {
        
    }
}

기본 필드 위 함수 및 객체 선언 사용

package pack01;
class Tiger{
    int a=30;
    Lion lion;
    //Lion lion = new Lion();//초기화는 가능  = 4줄 8째줄
    //a=100;//초기화 뺴고는 다 불가능 대입x
    Lion c1;//Tiger객체는 안딤 함수1번이 콜되면 사용가능
    Lion c2 = new Lion();//그냥 사용 가능
    Lion c3;//필드위의 c3는 쓸 방법이없다.
    void func01(){
        c1 = new Lion();//c3는 함수 안의 지역변수로 쓰인다.
        Lion c1 = new Lion();
 
        a++;
        lion = new Lion();
        Lion lion = new Lion();//위와 상관없이 함수안의 새로운 객체이다.
        System.out.println("호랑이");
        //함수안을 제외하고 코드작성을 할수없다.
    }
}
class Lion{
    void func01(){
        System.out.println("사자");
    }
}
public class Hello {
    public static void main(String[] args) {
        Tiger t1 = new Tiger();
        t1.c2.func01();
        t1.func01();
        t1.c1.func01();
        //c3는 쓸 방법이없다.
    }
}

package pack01;
abstract class Tiger{//객체 생성이 안됨 할게없다
 
}
public class Hello {
    public static void main(String[] args) {
        //Tiger t1 = new Tiger();//생성안됨
 
    }
}
/*package pack01;
abstract class Tiger{
    void func01(){
        System.out.println("호랑이 call");
    }
}
public class Hello {
    public static void main(String[] args) {

    }
}*/
/*package pack01;
abstract class Tiger{
    //void func01();
    abstract void func01();//미완성 함수 앞에 abstract붙이기
}
public class Hello {
    public static void main(String[] args) {

    }
}*/
/*package pack01;
abstract class Tiger{
    abstract void func01();
    void func02() {
        System.out.println("호랑이call");
    }
}
class Lion extends Tiger{
    void func01() {//추상 클래스 완성
        System.out.println("사자call");
    }
}
public class Hello {
    public static void main(String[] args) {
        Lion lion = new Lion();
        lion.func01();
        lion.func02();
    }
}*/

익명클래스

package pack01;//익명클래스//객체 생성때 자식 클래스 없이 함수를 생성한다.
abstract class Tiger {//객체 생성할때 )뒤에서 { 후에 ctrl space 하면 자동함수 생성
    abstract void func01();
}                    // @ =annotation 어노테이션
public class Hello {//컴파일러에게 위의 함수와 아래의 함수가 같은지 확인명령
    public static void main(String[] args) {
        Tiger tiger = new Tiger() {
            @Override
            void func01() {
                // TODO Auto-generated method stub
                
            }
        };
    }
}
 

package pack01;//익명클래스//객체 생성때 자식 클래스 없이 함수를 생성한다.
abstract class Tiger {//객체 생성할때 )뒤에서 { 후에 ctrl space 하면 자동함수 생성
    abstract void func01();
}                    // @ =annotation 어노테이션
public class Hello {//컴파일러에게 위의 함수와 아래의 함수가 같은지 확인명령
    public static void main(String[] args) {
        new Tiger() {//익명 객체 객체이름이 없음
            @Override
            void func01() {
                // TODO Auto-generated method stub
                System.out.println("호랑이");
            }
        }.func01();//한번더 못씀 즉석에서 사용
    }
}

익명객체

package pack01;//익명클래스//객체 생성때 자식 클래스 없이 함수를 생성한다.
abstract class Tiger {//객체 생성할때 )뒤에서 { 후에 ctrl space 하면 자동함수 생성
    abstract void func01();
}                    // @ =annotation 어노테이션
public class Hello {//컴파일러에게 위의 함수와 아래의 함수가 같은지 확인명령
    public static void main(String[] args) {
        Tiger t1 = new Tiger() {//익명 객체 객체이름이 없음
            @Override
            void func01() {
                // TODO Auto-generated method stub
                System.out.println("호랑이");
            }
        };
        Tiger t2 = new Tiger() {
            @Override
            void func01() {
                // TODO Auto-generated method stub
                System.out.println("코끼리");
            }
        };//한번더 못씀 즉석에서 사용
        t1.func01();
        t2.func01();
        Tiger t3 = t1;//공유
        t3.func01();
        t3 = new Tiger() {
            @Override
            void func01() {
                // TODO Auto-generated method stub
                System.out.println("앵무새");
            }
        };
        t3.func01();
        String s = new String();
        s = new String();
        s = new String();//객체가 다 다르다 s 3개
    }
}
 

package pack01;
abstract class Tiger{
    abstract void func01();
    void func03(){
        System.out.println("앵무새");
    }
}
public class Hello { 
    public static void main(String[] args) {
        Tiger t1 = new Tiger() {
            @Override
            void func01() {
                // TODO Auto-generated method stub
                System.out.println("호랑이");
                func02();
            }
            void func02() {
                System.out.println("사과");
            }
        };
        
        t1.func01();
        
        t1.func03();
    }
}
 

package pack01;
abstract class Tiger{
    public Tiger() {
        // TODO Auto-generated constructor stub
 
    }
    Tiger func01() {
        
        return this;
    }
    Tiger func02() {
        return this;
    }
    Tiger func03() {
        return this;
    }
}
 
public class Hello { 
    public static void main(String[] args) {
 
        Tiger t1 = new Tiger() {
            @Override
            Tiger func01() {
                // TODO Auto-generated method stub
                System.out.println("호랑이");
                return this;
            }
            @Override
            Tiger func02() {
                System.out.println("사자");
                return this;
            }
            @Override
            Tiger func03() {
                System.out.println("앵무새");
                return super.func03();
            }
 
        };
        new Tiger() {
            @Override
            Tiger func01() {
                // TODO Auto-generated method stub
                
                return super.func01();
            }
            @Override
            Tiger func02() {
                // TODO Auto-generated method stub
                
                return super.func02();
            }
            @Override
            Tiger func03() {
                // TODO Auto-generated method stub
                
                return super.func03();
            }
        };
        t1.func01().func01().func02().func03();
    }
}
 

package pack01;
abstract class Tiger{
    abstract void func01();
}
class Lion{
    void func01(){
        Tiger t1 = new Tiger() {
            @Override
            void func01() {
                // TODO Auto-generated method stub
                System.out.println("호랑이");
            }
        };
        t1.func01();
        System.out.println("앵무새");
        
    }
}
public class Hello { 
    public static void main(String[] args) {
        Lion lion = new Lion();
        lion.func01();
    }
}
 

package pack01;
abstract class Tiger{
    abstract void func01();
}
class Lion{
    Tiger t1;//이렇게만 생성하면 t1.func01()은 출력안됨
    Tiger t2 = new Tiger() {
        @Override
        void func01() {
            // TODO Auto-generated method stub
            System.out.println("호랑이");
        }
    };    
    void func01() {
        t2.func01();
    }
}//overriding 한거지 Lion class함수 안에는 함는 것이다. 
public class Hello { //타입 = 대입 , 객체 = 공유
    public static void main(String[] args) {
        Lion lion = new Lion();
        lion.t2.func01();
    
    }
}
 

package pack01;
abstract class Tiger{//ctrl -=
    abstract void func01();
}
class Lion{
    void func01(Tiger tiger) {//객체 생성
        tiger.func01();
    }
}
public class Hello { //타입 = 대입 , 객체 = 공유
    public static void main(String[] args) {
        Lion lion = new Lion();
        lion.func01(new Tiger() {//코드 자체를 인수로 보낸다.
            @Override
            void func01() {
                // TODO Auto-generated method stub
                for (int i = 0; i < 10; i++) {
                    System.out.println("5"+" * "+i+" = "+(5*i));
                }
            }
        });
        lion.func01(new Tiger() {
            @Override
            void func01() {
                // TODO Auto-generated method stub
                int s=0;
                for (int i = 0; i <= 10; i++) {
                    
                    s+=i;
                    
                }
                System.out.println(s);
            }
        });
    }
}
 

package pack01;
interface Tiger{//추상함수만 있을때 = 인터페이스 int + ctrl + space 
    //실행성코드는 x
    //abstract가 기본으로 깔려있다 안적어도 자동
    void func01();
    void func02();
    void func03();
}//인터페이스를 상속할때는 implements(구현)
class Lion implements Tiger{
    @Override
    public void func01() {//interface = 구현할때 함수앞에 public가 꼭 필요
        // TODO Auto-generated method stub
        System.out.println("하나");
    }
    @Override
    public void func02() {
        // TODO Auto-generated method stub
        System.out.println("둘");
    }
    @Override
    public void func03() {
        // TODO Auto-generated method stub
        System.out.println("셋");
    }
}
public class Hello {
    public static void main(String[] args) {
        Lion lion = new Lion();
        lion.func01();
        lion.func02();
        lion.func03();
        Tiger t1 = new Tiger() {
            @Override
            public void func01() {
                // TODO Auto-generated method stub
                System.out.println("하나");
 
            }
            @Override
            public void func02() {
                // TODO Auto-generated method stub
                System.out.println("하나");
 
            }
            @Override
            public void func03() {
                // TODO Auto-generated method stub
                System.out.println("하나");
 
            }
        };
        t1.func01();
        t1.func02();
        t1.func03();
    }
}

package a;
class A{
    
}
interface B{
    
}
class C extends A{//1. class class
    
}
class D implements B{//2 class implements
}
interface E implements B{//3 interface interface
    
}
//interface class X
    public static void main(String[] args) {
        // TODO Auto-generated method stub
 
    }
 
}
 

package pack;
/*class 장기{
    void play() {
        System.out.println("경기가 시작됩니다.");
        System.out.println("상대는 알파고입니다.");
    }
}
public class Hello {
public static void main(String[] args) {
        장기 a = new 장기();
        a.play();
    }
}1번 인공지능이 업그레이드했을때 코드자체를 고쳐야된다.
 */
/*package pack;
class 장기{
    void play(알파고 alphago) {
        System.out.println("경기가 시작됩니다.");
        alphago.fight();
    }
    void play(베타고 betago) {
        System.out.println("경기가 시작됩니다.");
        betago.fight();
    }
    void play(감마고 gammago) {
        System.out.println("경기가 시작됩니다.");
        gammago.fight();
    }
}
class 알파고{
    void fight() {
        System.out.println("상대는 알파고입니다.");
    }
}
class 베타고{
    void fight() {
        System.out.println("상대는 베타고입니다.");
    }
}
class 감마고{
    void fight() {
        System.out.println("상대는 감마고입니다.");
    }
}
public class Hello {
    public static void main(String[] args) {
        장기 a = new 장기();
        a.play(new 알파고());
        a.play(new 베타고());
        a.play(new 감마고());
    }
}vr2
*/
/*class 장기{
    void play(AI ai) {
        System.out.println("경기가 시작됩니다.");
        ai.fight();
    }
}
abstract class AI{
    abstract void fight();
}//밑은 모두 extends AI
class 알파고 extends AI{
    void fight() {
        System.out.println("상대는 알파고입니다.");
    }
}
class 베타고 extends AI{
    void fight() {
        System.out.println("상대는 베타고입니다.");
    }
}
class 감마고 extends AI{
    void fight() {
        System.out.println("상대는 감마고입니다.");
    }
}
public class Hello {
    public static void main(String[] args) {
        장기 a = new 장기();
        a.play(new 알파고());
        a.play(new 베타고());
        a.play(new 감마고());
    }
}vr3
*/
/*class 장기{
    void play(AI ai) {
        System.out.println("경기가 시작됩니다.");
        ai.fight();
    }
    void stop(AI ai) {
        System.out.println("휴식");
        ai.stop();
    }
}
abstract class AI{
    abstract void fight();
    abstract void stop();
}//밑은 모두 extends AI
class 알파고 extends AI{
    void fight() {
        System.out.println("상대는 알파고입니다.");
    }
    void stop() {
        System.out.println("알파고가 휴식을 취합니다");
    }
}
class 베타고 extends AI{
    void fight() {
        System.out.println("상대는 베타고입니다.");
    }
    void stop() {
        System.out.println("베타고가 휴식을 취합니다");
    }
}
class 감마고 extends AI{
    void fight() {
        System.out.println("상대는 감마고입니다.");
    }
    void stop() {
        System.out.println("감마고가 휴식을 취합니다");
    }
}
public class Hello {
    public static void main(String[] args) {
        장기 j = new 장기();
        알파고 a = new 알파고();
        베타고 b = new 베타고();
        감마고 c = new 감마고();
        j.play(new 알파고());
        j.play(new 베타고());
        j.play(new 감마고());
        j.stop(a);
        j.stop(b);
        j.stop(c);
    }//인수를 잘못던질수도있다. 
}*/
/*class 장기{
    AI ai;
    장기(AI ai){
        this.ai = ai;
    }
    void play(AI ai) {
        System.out.println("경기가 시작됩니다.");
        ai.fight();
    }
    void stop(AI ai) {
        System.out.println("휴식 시간입니다");
        ai.stop();
    }
}
abstract class AI{
    abstract void fight();
    abstract void stop();
}//밑은 모두 extends AI
class 알파고 extends AI{
    void fight() {
        System.out.println("상대는 알파고입니다.");
    }
    void stop() {
        System.out.println("알파고가 휴식을 취합니다");
    }
}
class 베타고 extends AI{
    void fight() {
        System.out.println("상대는 베타고입니다.");
    }
    void stop() {
        System.out.println("베타고가 휴식을 취합니다");
    }
}
class 감마고 extends AI{
    void fight() {
        System.out.println("상대는 감마고입니다.");
    }
    void stop() {
        System.out.println("감마고가 휴식을 취합니다");
    }
}
public class Hello {
    public static void main(String[] args) {
        알파고 a = new 알파고();
        베타고 b = new 베타고();
        감마고 c = new 감마고();
        장기 j1 = new 장기(a);
        장기 j2 = new 장기(b);
        장기 j3 = new 장기(c);
        j1.play(c);
        j2.stop(a);
        j3.stop(b);
    }//인공지능 하나씩 추가해주면됨
}*/
class 장기{
    AI ai;
    장기(AI ai){
        this.ai = ai;
    }
    void play(AI ai) {
        System.out.println("장기 경기가 시작됩니다.");
        ai.fight();
    }
    void stop(AI ai) {
        System.out.println("휴식 시간입니다");
        ai.stop();
    }
}
class 바둑{
    AI ai;
    바둑(AI ai){
        this.ai = ai;
    }
    void play(AI ai) {
        System.out.println("바둑 경기가 시작됩니다.");
        ai.fight();
    }
    void stop(AI ai) {
        System.out.println("휴식 시간입니다");
        ai.stop();
    }
}
interface AI{
    void fight();
    void stop();
}//밑은 모두 extends AI
class 알파고 implements AI{
    public void fight() {
        System.out.println("상대는 알파고입니다.");
    }
    public void stop() {
        System.out.println("알파고가 휴식을 취합니다");
    }
}
class 베타고 implements AI{
    public void fight() {
        System.out.println("상대는 베타고입니다.");
    }
    public void stop() {
        System.out.println("베타고가 휴식을 취합니다");
    }
}
class 감마고 implements AI{
    public void fight() {
        System.out.println("상대는 감마고입니다.");
    }
    public void stop() {
        System.out.println("감마고가 휴식을 취합니다");
    }
}
public class Hello {
    public static void main(String[] args) {
        
        베타고 b = new 베타고();
        장기 j2 = new 장기(b);
        바둑 j1 = new 바둑(b);
        j2.play(b);
        j1.stop(b);
        j1.play(b);
        j1.stop(b);
    }//게임이라는 부모 만들고  그 밑에 게임들 넣기.
}