接口

接口

通过interface关键字定义接口

类通过implements实现接口

接口不可以实例化

接口中全部都是抽象方法

接口中的抽象方法可以省略public abstract关键字

实现类必须实现接口中的全部抽象方法

要么它就是一个抽象类

在jdk1.8里允许接口中出现普通方法,要求被static或者default修饰

//    static public void hi() {}
    //    default public void hi() {}

public class Test1_Interface {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Demo  demo=new DemoImpl();
        demo.eat();
        demo.game();
        
    }

}
interface Demo{
    void eat();
    void game();
}
class DemoImpl implements Demo{

    @Override
    public void eat() {
        // TODO Auto-generated method stub
        System.out.println("eat()...");
    }

    @Override
    public void game() {
        // TODO Auto-generated method stub
        System.out.println("game()...");
    }
    
}

接口的用法

接口里没有构造方法/没有变量都是常量

接口里都是抽象方法(jdk1.8可以有特殊的普通方法)

接口里的常量可以简写,会自动拼接public static final

接口里的方法可以简写,会自动拼接public abstract

public class Test2_Interface2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Inter in=new InterImpl();
        System.out.println(in.age);
        System.out.println( Inter.age );//获取值,age是static的
        
        //TODO 7,测试接口里的方法
        String desc = in.save();
        System.out.println(desc);
        
        in.delete(10);
    }

}
interface Inter{
    int age=40;
    String save();
    void delete(int id);
}
class InterImpl implements Inter{

    @Override
    public String save() {
        // TODO Auto-generated method stub
        return "success";
    }

    @Override
    public void delete(int id) {
        // TODO Auto-generated method stub
        System.out.println("delete()..."+id);
    }
    
}

接口的复杂用法

接口可以多继承，

实现类和接口可以多实现

public class Test3_Interface3 {
    public static void main(String[] args) {
        //4,--2号接口的功能,接口那么多,想用谁的功能,左边就写谁
        Inter2 in = new Inter2Impl() ;
        in.update();
        in.save();
        in.delete(5);
        in.get();
    }
}    
interface Inter1{
    void save();
}
interface Inter3{
    void update();
    void get();
}
//5,实现类可以在继承的同时,多实现
abstract class Impl2 extends Object implements Inter1 , Inter3{
    
}
//3,接口和实现类之间 -- 是实现关系 ,可以多实现(逗号隔开)
//--Impl实现类,同时实现了Inter1和Inter3接口的功能,
//--需要同时重写多个抽象方法,否则就是一个抽象类
class Impl implements Inter1 , Inter3{
    @Override
    public void update() {
    }
    @Override
    public void get() {
    }
    @Override
    public void save() {
    }
}
//1,接口和接口之间 -- 是继承关系,可以多继承(逗号隔开)
//--2号接口同时使用了1号和3号接口的功能! 
interface Inter2 extends Inter1 , Inter3{
    void delete(int id) ;
}
//2,想要使用2号接口的功能,找一个实现类来实现接口
class Inter2Impl implements Inter2{
    @Override
    public void save() {
        System.out.println(1);
    }
    @Override
    public void update() {
        System.out.println(2);
    }
    @Override
    public void get() {
        System.out.println(3);
    }
    @Override
    public void delete(int id) {
        System.out.println(4);
    }
}

四,接口和抽象类的区别

--1,类和类间的关系:是继承关系
    --java里只支持单根继承
    --class A extends B
    --其中A是子类,B是父类.子类可以使用父类的所有功能
    --方法的重写override:如果想要修改父类的原有功能,可以进行方法重写
--2,接口和接口间的关系:是继承关系
    --接口的出现就是为了突破java单继承的局限性
    --接口间可以多继承
    --interface A extends B , C
    --其中A是子接口,B和C是父接口            
    --A就拥有了B和C的所有功能,A的功能是最全的
    --class Impl implements A
    --Impl实现类就需要同时重写A B C 接口里的所有抽象方法,否则就是一个抽象类

--3,类和接口间的关系:是实现关系
    --实现类可以实现接口,而且可以多实现
    --class A implements B,C
    --A是实现类,B和C是接口.
    --A需要同时重写B和C接口里的所有抽象方法,否则就是一个抽象类
    --类可以在继承的同时多实现
    --class A extends B implements C , D
    --A可以叫子类,也可以叫是实现类
    --A同时拥有父类B的功能,也同时拥有接口C和D的功能
    --A需要同时重写C和D接口里的所有抽象方法,否则就是一个抽象类
    --对于父类B里的方法吗?看需求,B类是父类,里面如果都是普通方法,只有需要修改才会发生重写.
    
--4,抽象类和接口的区别
    --相同点
        --抽象类和接口都是抽象层,一般用来提取共性
        --都不能被实例化
    --不同点
        --构造方法:抽象类里有,接口里没有!!
        --成员变量:抽象类里有,接口里没有,接口里都是常量!!
        --成员方法:抽象类类可以有普通方法和抽象方法,但是接口里都是抽象方法(1.8后可以有)
        --接口里存在简写形式,抽象类里没有.
        --接口里的常量,int age = 10;会为常量自动拼接public static final
        --接口里的方法,void save();会为方法自动拼接public abstract
        --怎么去设计你的抽象层,到底是体现为一个抽象类呢还是接口呢?
            --关键就看你需不需要提供方法体,如果类里的方法都不需要提供方法体,可以设计为接口.如果类里的方法需要提供方法,设计为抽象类.
        --抽象层到底设计成抽象类还是接口,谁好呢?
            --如果实现类想要同时拥有多个功能,最好选择接口,因为接口可以多继承多实现
            --如果就是设计为抽象类,子类就只能继承一个父类,只有这么一次的继承权

五,程序设计:

--需求:
    具体事物:培优班老师,高手班老师
    共性:备课 / 讲课
    测试:创建多态对象测试
--利用面向接口编程的思想实现:

public class Test4_Design {
    public static void main(String[] args) {
        Teacher cgb=new cgbteacher();
        cgb.ready();
        cgb.teach();
    }
}
interface Teacher{
    void ready();
    void teach();
}
class cgbteacher implements Teacher{

    @Override
    public void ready() {
        // TODO Auto-generated method stub
        System.out.println("培优班老师正在 备课");
    }

    @Override
    public void teach() {
        // TODO Auto-generated method stub
        System.out.println("培优班老师正在 讲课");
    }
    
}
abstract class actteacher implements Teacher{
    
}