接口

描述事物的扩展功能。

package org.westos_04_interface;
/**
 * 
 *  接口的概念:
 * 接口体现的是一种:扩展功能:       比如:猫可以跳高(并不是所有的猫都具有跳高功能)
 *  
 *  如何表示接口:
 *          interface:接口            interface 接口名{
 *
 *                                  }
 *      接口里面的方法可以是非抽象方法吗?
 *          不可以,只能是抽象方法
 *      接口中不能有构造方法
 *      
 *      接口的特点:不能实例化(不能直接创建对象)
 *      接口如何实例化:
 *          接口的子实现类:
 *                  1)接口的子实现类是抽象类,没有意义,子类都不能创建对象了;实际开发中用的就是子类的对象进行初始化!
 *                  2)接口的子实现类是非抽象类
 *                      接口的实例化:就是通过子实现类对数据进行初始化!
 *      
 * 接口的子实现类和接口的关系:implements:
 *  格式:
 *      class 子实现类名    implments(实现) 接口名{
 * 
 *      }
 * */
//定义跳高的接口
interface Jump{

    //非抽象方法:抽象类中不能有抽象方法
//  public void jump(){
//      System.out.println("猫可以跳高了...");
//  }

    public abstract  void  jump() ;

    //构造方法:不能有
//  public Jump(){
//      
//  }
}

//子实现类是抽象类类
//abstract class Cat implements Jump{
//子实现类是非抽象类
class Cat implements Jump{

    @Override
    public void jump() {
        System.out.println("猫可以跳高了...");
    }

}

//测试类
public class InterfaceDemo {
    public static void main(String[] args) {
        //创建接口对象
//      Jump j = new Jump() ;//接口不能实例化

        //接口多态:接口的引用指向子实现类对象
        Jump j = new Cat() ;
        j.jump();
    }
}

接口中的成员方法默认修饰符:public abstract(永远建议自己给出默认修饰符)
如果不默认给出，在写接口的实现类时，重写接口中的方法，要注意默认的访问修饰符是public ，重写的方法必须用public修饰，否则会编译出错，不能降低所实现接口的访问级别。

package org.westos_04_interface;
/**
 * 接口成员的特点:
 *      成员变量:
 *              只能是常量:存下默认修饰符:public static final (永远建议自己给出默认修饰符)
 *      构造方法:
 *              接口是没有构造方法的
 *      成员方法:
 *              接口中的成员方法默认修饰符:public abstract(永远建议自己给出默认修饰符)
 * 
 * 类,抽象类,接口
 *  
 * */
//定义一个接口
interface Inter{
    public static final int num = 100 ;
    public static final  int num2 = 200 ;
    //抽象方法
//  public void show();
//  void show() ;

    //全部给出默认修饰符
    public abstract void show() ;

    //接口没有构造方法
//  public Inter(){
//      
//  }

    public abstract void function() ;
}

//定义接口的子实现类:见名知意:接口名+impl
class InterImpl implements Inter{

    @Override
    public void show() {
        System.out.println(num);
        System.out.println(num2);
    }

    @Override
    public void function() {
        System.out.println("function InterImpl...");
    }

}

//测试类
public class InterfaceDemo2 {
    public static void main(String[] args) {
        //创建接口对象:接口多态的形式
        Inter i = new InterImpl() ;
//      i.num = 20 ;//当前num变量:被final修饰
        System.out.println(Inter.num);//接口名.成员变量(当前变量被static修饰)
        System.out.println(Inter.num2);
        System.out.println("-------------");
        i.show() ;
        i.function() ;
    }
}

package org.westos_04_interface;

/**
 * 类与类的关系:
 *      继承关系:extends,java中只支持单继承,不支持多继承,但是可以多层继承!
 * 类与接口的关系
 *      实现关系:implements,并且,一个类在继承另一个类的同时,可以实现多个接口
 * (class 子实现类名  enxtends Object implements 接口名1,接口名2...)
 *          
 * 接口与接口的关系
 *      继承关系:extends,可以支持单继承,也可以多继承!
 * 
 * 面试题:
 *      接口和抽象类的区别?
 *      
 * */
interface Inter2{

}
interface Inter3{

}

//接口与接口的关系:extends
interface Zi extends Inter2{}
interface Son extends Inter2,Inter3{}

//子实现类
class InterImpl2  extends Object implements Inter2,Inter3{

}
public class InterfaceDemo3 {

}

接口和抽象类的区别?

    1)成员的区别:
        成员变量:
            抽象类:成员变量可以是常量,也可以是变量
            接口:成员变量只能是一常量:存在默认修饰符:public static final（无法被继承。只能通过接口名访问。）
        构造方法:
            抽象类:可以有无参构造,有参构造方法
                  作用:通过子类进行数据初始化(通过子类创建对象)
            接口:没有构造方法的
        成员方法的区别:
            抽象类:可以有抽象方法,也可以有非抽象方法
            接口:只能是抽象方法:存在默认修饰符:public abstract

    2)关系的区别:
        类与类的关系:
            继承关系:extends,java中只支持单继承,不支持多继承,但是可以多层继承!
            类与接口的关系:
                实现关系:implements,并且,一个类在继承另一个类的同时,可以实现多个接口
                (class 子实现类名  enxtends Object implements 接口名1,接口名2...)

            接口与接口的关系
                    继承关系:extends,可以支持单继承,也可以多继承!

    3)设计理念的区别:
            抽象类:
                体现的是一种"is a"的关系,存在继承关系!(抽象类多态)
            接口:
                体现的是一种"like a"的关系,由于接口的一种扩展功能