java面向对象 12 接口

    接口的定义和实现：

            只有规范！（无法写方法~专业的约束！ 约束和实现分离：面向接口编程~）

                1. 接口就是用来实现类间多重继承的一种结构 (interface)，方法定义和常量值的集合。

                2.接口是一种特殊的抽象类，这种重新来中只包含常量和方法的定义，而没有方法的实现。

• 接口的定义：1. 接口是由常量和抽象方法组成的特殊类，用interface关键字替代class关键字。

                                2. 接口体中包括常量定义和方法定义。

                                3. 接口中的方法具有public和abstract属性。

                                4. 常量的定义（public static final）

                  注意：子接口中定义了和父接口同名的常量或者相同的方法，则父接口中的常量被隐藏，方法被覆盖。

• 接口的实现：1. 把对接口功能的继承称为实现（implements）.

                                2. 用implements表示一个类要实现某个接口。

                                3. 可以引用接口中定义的常量，而必须实现接口定义的所有方法(多个接口用逗号分割)

               注意：1. 方法声明必须与接口中所定义的完全一致。

                          2. 在类中实现接口定义的方法时，必须使用public修饰符

                          3. 接口不能被实例化~，接口中没有构造方法~

                          3. 接口的类如果是抽象类，则可以不用实现接口的抽象方法，如果非抽象类，则必须实现

• 接口作用：1. 实现不相关的类的相同行为，而不需要考虑这些类之间的层次关系。

                            2. 通过接口可以指明多个类需要实现的方法。

                            3.可以了解对象的交互界面，而不需要了解对象所应的类。

                            4.implements可以实现多个接

                           5.定义一些方法，让不同的人实现~ 10 ----> 1

           接口是可以用来实现类间多重继承功能的结构。接口把方法的定义和类的层次区分开来，通过它

           可以在运行时动态的定位所调用的方法。

 

• 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是....则必须能...”的思想。如果你是天使，则必须能飞。

            如果你是汽车，则必须能跑。如果你是好人，则必须干掉坏人；如果你是坏人，则必须欺负好人。

• 接口的本质是契约，就像我们人间的法律一样，制定好后大家都遵守。

interface Bank2
{
    double oneYearRate=0.0178;
    double interestRate=0.0078;
    double count();
}
class OneYearFixed2 implements Bank2
{
    double savedq;
    public void setSavedq(double savedq)
    {
        this.savedq = savedq;
    }
    public double getSavedq()
    {
        return (this.savedq);
    }
    public double count()
    {
        return savedq*(1+oneYearRate);
    }
​
}
class OneYear2 implements Bank2
{
    double savehq;
    public void setSavehq(double savehq)
    {
        this.savehq = savehq;
    }
​
    public double getSavehq()
    {
        return (this.savehq);
    }
    public double count()
    {
        return savehq*(1+interestRate);
    }
}
public class TestBank2
{
    public static void main (String[] args)
    {
        OneYearFixed2 oyf2=new OneYearFixed2();
        oyf2.setSavedq(10000);
        System.out.println ("本金1万元存1年定期后，总金额为："+oyf2.count());
        OneYear2 oy2=new OneYear2();
        oy2.setSavehq(10000);
        System.out.println ("本金1万元存1年活期后，总金额为："+oy2.count());
​
    }
}
--------------------------------

package Demo07;
//interface定义的关键字,接口都需要实现类
//抽象的思维~java 架构师
public interface UserSeryice
{
   //接口中所有的定义的方法其实都是抽象的public abstract
    //常量~ public  static final
     void add(String name );
     void delete(String name);
    void update(String name);
    void query(String name);
}

package Demo07;
​
public interface TimeService
{
    void timer();
}
​

package Demo07;
//类 可以实现接口 implements 接口
//实现了接口的类，就需要重写接口中的方法~
//多继承~利用接口实现多继承~
public class UserServiceImpI implements UserSeryice ,TimeService
{
​
    @Override
    public void add(String name)
    {
​
    }
​
    @Override
    public void delete(String name)
    {
​
    }
​
    @Override
    public void update(String name)
    {
​
    }
​
    @Override
    public void query(String name)
    {
​
    }
    public void timer()
    {
​
    }
}
​

• final关键字：1. final在类之前表示该类最终类，不能被继承

                                2. 把它修饰为final类，就不能被继承

                                3. 不能再被子类重写，不能被子类覆盖。

                                4. 初始化之后不能改变