关于java-se:接口

接口

通过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{
    
}