关于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{}