《day10》

//65-面向对象-接口-接口的思想
/*
举例：笔记本电脑。


1，接口的出现对功能实现了扩展。
2，接口的出现定义了规则。
3，接口的出现降低了耦合性。(解耦)

接口的出现完成了解耦，说明有两方，一方在使用这个规则，另一方在实现这个规则。
比如笔记本电脑在使用这个规则，而外围设备在实现这个规则。
*/

//66-67面向对象-接口-接口和抽象的区别及总结：
/*
接口和抽象类的区别：

描述事物：
犬。按照功能分类。导盲犬，缉毒犬...

犬：
    吼叫();
    吃饭();
*/

abstract class 犬
{
    public abstract void 吼叫();
    public abstract void 吃饭();
}
class 缉毒犬 extends 犬 
{
    public void 吼叫(){}
    public void 吃饭(){}
    //public void 缉毒(){}
}

//对于缉毒，有可能还有缉毒猪。具备着缉毒功能。应该将这个缉毒的功能抽取。
//对缉毒进行描述。
abstract class 缉毒
{
    public abstract void 缉毒(){}
}

/*
缉毒犬既需要犬的功能又需要缉毒的功能。
无法直接多继承。
是否可以多实现呢?
犬是一个接口，缉毒犬多实现即可。
类负责描述的是事物的基本功能，接口负责描述事物的扩展功能。
缉毒犬是犬中的一种。is a 关系。
将犬定义成类，而缉毒是犬的一个扩展功能，这时将缉毒定义成接口。

这时描述就变成了这样。
*/
abstract class 犬
{
    public abstract void 吼叫();
    public abstract void 吃饭();
}
interface 缉毒able
{
    public abstract void 缉毒();
}

class 缉毒犬 extends 犬 implements 缉毒able
{
    public void 吼叫(){}
    public void 吃饭(){}
    public void 缉毒(){}
}

/*
小节：
1，抽象类是描述事物的基本功能，可以描述非抽象的方法。
   接口中定义的只能是抽象的方法。负责事物功能的扩展。
2，类与类之间是继承关系 is a 关系。
   类与接口之间是实现关系 like a 关系。
  
  门:
    open();
    close();

  报警功能的门。

  
interface 报警
{
    public abstract void 报警();
}

abstract 门
{
    public abstract void open();
    public abstract void close();
}

class 报警门 extends 门 implements 报警
{
    public void open(){code...}
    public void close(){code..}
    public void 报警(){code...}
}


*/

//68-面向对象-多态-好处&弊端-前提

//多态技术的引出，解决什么问题？程序扩展性的问题。
//描述Dog
class Dog extends Animal
{
    public void eat()
    {
        System.out.println("骨头");
    }
    public void lookHome()
    {
        System.out.println("看家");
    }
}

//描述猫
class Cat extends Animal
{
    public void eat()
    {
        System.out.println("鱼");
    }
    public void catchMouse()
    {
        System.out.println("抓老鼠");
    }
}
//进行抽取，将共性的功能抽取到父类中Animal中。
abstract class Animal
{
    public abstract void eat();
}


class  DuoTaiDemo
{
    public static void main(String[] args) 
    {
        Dog d = new Dog();
    //    d.eat();
        method(d);

        Cat c = new Cat();
        method(c);

        /*
        发现，每多一个动物，都需要为这个动物单独定义一个功能。
        让这个动物的对象去做事。
        这个程序扩展性很差。
        如何提高扩展性呢？
        发现既然是让动物去eat，无论是Dog,还是Cat。
        eat是它们的共性，干脆，将eat进行抽取。抽取到父类Animal中。

        Dog是Animal中的一种。
        Dog d = new Dog();
        Animal a = new Dog();

        Cat是Animal中的一种。
        Cat c = new Cat();
        Animal aa = new Cat();
        */

        //只要去建立Ainmal的引用就可以接受所有的Dog，Cat对象。让它们去eat。
        //提高了程序的扩展性。
        public static void method(Animal a)
        {
            a.eat();
        }


        /*
        //接收Dog，让dog做事。
        public static vodi method(Dog d)
        {
            d.eat();
        }

        //接收Cat,让Cat做事。
        public static void method(Cat c)
        {
            c.eat();
        }
        */
    }
}

//68-面向对象-多态-好处&弊端-前提

//多态技术的引出，解决什么问题？程序扩展性的问题。
//描述Dog
class Dog extends Animal
{
    public void eat()
    {
        System.out.println("骨头");
    }
    public void lookHome()
    {
        System.out.println("看家");
    }
}

//描述猫
class Cat extends Animal
{
    public void eat()
    {
        System.out.println("鱼");
    }
    public void catchMouse()
    {
        System.out.println("抓老鼠");
    }
}

//进行抽取，将共性的功能抽取到父类中Animal中。
abstract class Animal
{
    public abstract void eat();
}

/*
多态：
    【体现】
    父类的引用或者接口的引用指向了自己的子类对象。
    Dog d = new Dog();//Dog 类型是Dog类型。
    Animal a = new Dog();//Dog对象的类型右边是Dog类型，左边是Animla类型。
    【好处】
      提高了程序的扩展性。
    【弊端】
      通过父类引用操作对象时，只能使用父类中中已有的方法，不能操作子类特有的方法。
    【前提】
      1，必须有关系，继承，实现。
      2，同常都有重写操作。
    【子类的特有方法如何调用呢？】
     Ainmal a = new Dog();//Animal是父类型，new Dog()是子对像。
     但是父类型引用指向子类对象时，这就是让子类对象进行了类型的提升(向上转型)
     向上转型的好处：提高了扩展性，隐藏了子类型。弊端，不能使用子类型的特有方法。
     如果想使用子类的特有方法，只有子类型可以用。
     可以向下转型。（可以用double d = 4  同时也可以把d强转为int型）.
     Ainmal a = new Dog();
     a.eat();

     //向下转型
     Dog d = (Dog)a;//将a转型为Dog类型。
     d.lookHome();
     向下转型什么时候用？当需要使用子类型的特有内容时，

     注意：无论向上还是向下转型，最终都是子类对象在做着类型的变化。
     千万不要把父类型的对象进行强转，因为父类型创建以后还不明确它的
     子类型到底有哪些？

     【向下转型的注意事项】
     Animal a = new Dog();
    Cat c = (Cat)a;//向下转型因为不明确具体子类对象类型，
                   //所以容易引发ClassCastException:
    所以为了避免这个问题，需要在向下转型前，做类型判断。
    判断类型用关键字。instanceof
    if(a instanceof cat)//a指向的对象时Cat类型。
    {
        //将a转型成Cat类型
        Cat c = (Cat)a;
        c.catchMouse();
    }
    else if(a instanceof Dog)
    {
        Dog d = (Dog)a;
        d.lookHome();
    }
    【转型总结】
    1，什么时候向上转型呢？
           提高程序的扩展性，不关心子类型(子类型被隐藏)。
           需要用子类的特有方法吗？不需要，哦了，向上转型。
    2，什么时候使用向下转型呢？
        需要使用子类型的特有方法时。
        但是一定要使用instanceof进行类型的判断。避免发生ClassCastException:
    
    

*/

class  DuoTaiDemo2
{
    public static void main(String[] args) 
    {
        Dog d = new Dog();
        /*
        d.eat();
        d.lookHome();
        Animal a = new Dog();
        a.eat();//可以。
        a.lookHome();//不可以。
        */
        method(d);

        Cat c = new Cat();
        method(c);
    }

        public static void method(Animal a)
        {

            a.eat();
            Dog d = (Dog)a;
            //d.lookHome();//Exception in thread "main" 
                            //java.lang.ClassCastException:
                            //Cat cannot be cast to Dog

    //        a.lookHome();//不可以，因为动物不具备lookHome功能。
        }
}

//70-面向对象-多态-举例
class 毕姥爷
{
    public void 讲课()
    {
        System.out.println("讲管理");
    }
    public void 钓鱼()
    {
        System.out.println("钓鱼");
    }
}

class 毕老师 extends 毕姥爷
{
    public void 讲课()
    {
        System.out.println("Java");
    }
    public void 看电影()
    {
        System.out.println("看电影");
    }
}
class DuoTaiTest
{
    public static void main(String[] args) 
    {
        毕姥爷 x = new 毕老师();//多态，向上转型了。
        x.讲课();
        x.钓鱼();//可以。
//        x.看电影();//不行
        //想要使用毕老师的特有方法时，需要向下转型。
        if(x instanceof 毕老师)
        {
            毕老师 y = (毕老师)x;
            y.看电影();
        }

        //自始至终都是子类对象在做着类型的变化。
    }
}

//72-面向对象-多态-练习-笔记本电脑
/*
阶段一需求：笔记本电脑运行。
按照面向对象的思想，用代码体现。
名词提炼法。
笔记本电脑：
    行为：运行。

class noteBook
{
    //定义一个运行功能。
    public void run()
    {
        System.out.println("notebook run");
    }
}

阶段二需求：想要在笔记本上加上一个手提式鼠标。
多了个对象。鼠标。
    行为：开启，关闭。
class Mouse
{
    public void open()
    {
        System.out.println("mouse run");
    }
    public void close()
    {
        System.out.println("mouse close");
    }
}

笔记本怎么用鼠标呢？
笔记本中就多了个使用鼠标的功能。
需要修改原来的笔记本类中的内容，添加一个功能。
class noteBook
{
    //定义一个运行功能。
    public void run()
    {
        System.out.println("notebook run");
    }
    //使用鼠标功能。
    public void useMouse(Mouse m)
    {
        if(m!=null)
        {
            m.open();
            m.close();
        }
    }
}
//问题：如果想要加入一个键盘呢？
只要描述一个键盘类，并在电脑类中加入一个使用键盘的功能。就可以了。
但是从鼠标开始，这个问题就已经产生了。一旦需要添加新设备的时候，
都需要改变电脑的源码。这个扩展性是非常差的。

设计上该如何改进呢？
之前的问题在于外围设备的增加和笔记本电脑之间的耦合性过高。
如何降低这些外围设备和笔记本电脑的耦合性呢？
外围设备还不确定，我们不要面对外围具体设备。
为了让笔记本可以使用这些设备，可以事先定义好一些规则。
笔记本只要使用这些规则就可以了。
有了这些规则就可以进行功能的扩展。
后期这些外围的设备只要符合这些规则就可以被笔记本使用了。

那么规则在java中该如何体现呢？

./1,描述接口。USB.

//2,描述笔记本电脑：运行功能，使用USB接口的功能。



*/

//USB接口定义。
interface USB
{
    public abstract void open();
    public abstract void close();
}

//描述笔记本电脑。
class NoteBook 
{
    public void run()
    {
        System.out.println("notebook run");
    }

    //使用usb接口的功能。
    public void usbUSB(USB usb)//多态！//接口类型的变量。接口类型的变量只能
                                //只能指向自己的子类对象。
                                //USB usb = new Mouse();
    {
        if(usb!=null)
        {
            usb.open();
            usb.close();
        }
    }
}

//需要鼠标。想要被笔记本电脑使用，该鼠标必须要符合规则。
//描述鼠标。
class Mouse implements USB
{
    public void open()
    {
        System.out.println("mouse open");
    }
    public void close()
    {
        System.out.println("mouse close");
    }
}

class KeyBoard implements USB
{
    public void open()
    {
        System.out.println("keyboard open");
    }
    public void close()
    {
        System.out.println("keboard close");
    }
}

/*
发现：接口的出现
1，扩展了笔记本的功能。
2，定义了规则。
3，降低了笔记本电脑和外围设备之间的耦合性。
*/
class DuoTaiTest2
{
    public static void main(String[] args) 
    {
        NoteBook book = new NoteBook();
        book.run();
        book.usbUSB(null);
        book.usbUSB(new Mouse());
        book.usbUSB(new KeyBoard());
    }
}

//73-面向对象-多态-成员变量&成员函数&静态函数的特点
/*
多态中，成员调用的特点。
1，成员变量：
    当子父类中出现了同名的成员变量时，
    多态调用该变量时，分两个时期：
        编译时期参考的是引用型变量所属的类中是否有被调用的成员变量。没有，编译失败。
        运行时期，也是调用引用型变量所属的成员变量。
        简单记：编译和运行都参考等号左边。
                编译运行看左边。
2，成员函数：
    编译：参考左边。如果有，编译通过，如果没有，编译失败。
    运行：参考右边。参考右边对象所属的类。
        编译看左边，运行看右边。

        对于成员函数是动态绑定到对象上。
3，静态函数。
    对于静态函数，编译和运行都看左边。
        静态函数是静态的绑定到类上的。（因为静态方法加载的时候还没有对象。）

总结：
对于成员变量和静态函数，编译和运行都看左边。
对于成员函数，编译看左边，运行看右边。
*/

class Fu
{
    //成员变量。
    int num = 3;

    //成员函数。
    void show()
    {
        System.out.println("fu show run");
    }

    //静态函数。
    static void method()
    {
        System.out.println("fu static method run");
    }
}
class Zi extends Fu
{
    int num = 5;

    void show()
    {
        System.out.println("zi show run");
    }

    //静态函数。
    static void method()
    {
        System.out.println("zi static method run");
    }
}

class DuoTaiDemo3
{
    public static void main(String[] args) 
    {
        /*测试成员变量的多态调用：

        //Fu f = new Zi();
        //System.out.println(f.num);//打印结果：3

        //Zi z = new Zi();
        //Zi z = (Zi)f;
        //System.out.println(z.num);
        */

        //测试成员函数的多态调用：
        //Fu f = new Zi();
        //f.show();

        //测试静态成员函数的多态调用：
        Fu f = new Zi();
        f.method();
        //注意：真正开发，静态方法是不会被多态调用的，因为静态方法不所属于对象。
        //因为静态方法就是应该被类调用的。Fu.method();
    }
}

//76-77-面向对象-Object-概述&toStrng方法。
/*
Object类中的常用方法。

Object是所有类的根类，定义了所有对象都具备的功能。
API(应用程序接口)文档。



*/
class Person extends Object
{
    private int age;
    Person(int age)
    {
        this.age = age;
    }
    //判断是否是同龄人。其实这个方法也是在比较Person对象是否相等。
    //注意：Person类中是否有比较两个Person对象相等的方法？有的。
    //因为继承Object,本身就具备着equals方法。
    //既然有，还需要定义compare方法吗?不需要。
    //但是equals方法判断的是地址，不是我们所需要的内容。
    //咋办？继续使用Object的equals方法，但是建立子类自己的内容。
    //这就是传说中的重写。
    //重写：
    //【记住】以后判断对象是否相同，就需要覆盖equals方法。
    public boolean equals(Object obj)
    {
        //建立Person自己的判断相同的依据。判断年龄是否相同。
//        return this.age == obj.age;//obj所属类型Object，Object中没有定义age，所有编译失败。
        
        //如果调用该方法的对象和传递进来的对象是同一个，就不要转型和判断，直接返回true就可以了。
        if(this == obj)
            return true;//效率高一些。

        //age是Person类型的属性，既然要用到子类型的内容，需要向下转型。
        if(!(obj instanceof Person))
//            return false;
            throw new ClassCastException("类型是不对的；请改正。");
        Person p = (Person)obj;

        return this.age == p.age;
    }

    //覆盖toString方法，建立Person对象自己的字符串表现形式。
    public String toString()
    {
        return "Person[age = "+age+"]";
    }
    /*
    public boolean compare(Person p)
    {
        return this.age == p.age;
    }
    */
}

class Dog
{

}
class ObjectDemo
{
    public static void main(String[] args) 
    {
        Person p1 = new Person(12);
        Person p2 = new Person(17);
//        p1.equals(p2);
//        p1.equals(new Dog());//会抛出异常。
//        System.out.println(p1.equals(p1));

        System.out.println(p1.toString());//Person@2a139a55
                                          //想要建立自定义对象的字符串表示形式，
                                          //覆盖toString方法。
        System.out.println(p2.toString());

//        System.out.println(p1.compare(p2));
//        System.out.println(p1==p2);
//        System.out.println(p1.equals(p2));
    }
}