面向对象（接口——定义interface）
2016-11-10 22:59
267 查看
面向对象（接口——定义interface
abstract class AbsDemo{
abstract void show();
abstract void show();
}
/*
当一个抽象类中的方法都是抽象的时候，这时可以将该类抽象类用另外一种形式定义
和表示，就是接口interface。
定义接口使用的关键字不是class，是interface。
对于接口当中常见的成员：而这些成员都有固定的修饰符。
1，全局常量：public static final。
2，抽象方法 ：public abstract。
*/
interface Demo{
public static final int NUM=4;
public abstract void show();
public abstract void show();
}
class InterfaceDemo{
public static void main(String[] args){
System.out.println("hehe");
}
}
面向对象（接口——实现implements）
interface Demo{
public static final int NUM=4;
public abstract void show1();
public abstract void show2();
}
/*
类与类之间是继承关系，类与接口直接是实现关系。
接口不可以被实例化。
只能由实现了接口的子类并覆盖了接口中所有的抽象方法，
该子类才可以被实例化，否则，这个子类就是一个抽象类。
*/
class DemoImpl implements/*实现*/ Demo{
public void show1()
{}
public void show2()
{
}
}
class InterfaceDemo1{
publci static void main(String[] args){
DemoImpl d=new DemoImpl();
System.out.println(d.NUM);
System.out.println(DemoImpl.NUM);
System.out.println(Demo.NUM);
}
}
面向对象（接口——多实现）
在Java中不直接支持多继承，因为会出现调用的不确定性。所以java将多继承机制
改良，在java中变成了多实现。
一个类可以实现多个接口。
interface A{
public void show();
}
interface Z{
publi void show();
}
class Test implements A,Z//多实现
{
public void show()
{
}
}
class InterfaceDemo2{
public static void main(String[] args){
Test t=new Test();
t.show();
}
}
面向对象（接口——细节）
interface A{
public void show();
}
interface Z{
public void show();
}
class Test implements A,Z{
public int add(int a,int b){
return a+b+3;
}
public void show(){}
}
//一个类在继承另一个类的同时，还可以实现多个接口。
class Q{
public void method()
{}
}
abstract class Test2 extends Q implements A,Z
{
}
//接口的出现避免了单继承的局限性
interface C{
void show();
}
interface M{
void show();
}
interface Q extends C,M{
//接口与接口之间是继承关系，而且接口可以多继承。
void function();
}
class W ipmlements Q
{//覆盖3个方法
public void show(){}
public void method(){}
public void function(){}
}
class InterfaceDemo3{
publci static void main(String[] args){
Test t=new Test();
t.show();
}
}
java支持多继承吗？
支持。只不过多继承在类中进行了改良，用了多实现来体现，但是接口内容
的出现，却可以进行多继承，原理是，方法体是否有存在。
java支持多继承吗?
支持。支持接口。只要看有没有方法体，不支持多继承的原因就是方法体
导致运行调用的不确定性。
面向对象（接口——特点）
接口是对外暴露的规则
接口是程序的功能扩展
接口的出现降低耦合性
接口可以用来多实现
类也接口之间是实现关系，而且类可以继承一个类的同时实现多个接口
接口与接口之间可以有继承关系
面向对象（接口和抽象类的区别）
抽象类和接口的异同点：
相同点：都是不断向上抽取而来的
不同点：
1，抽象类需要被继承，而且只能单继承。
接口需要被实现，而且可以多实现
2，抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法
接口中只能定义抽象方法，必须由子类去实现
3，抽象类的继承，是is a关系，在定义该体系的基本共性内容
接口的实现时like a关系，在定义体现额外功能
注：is a（所有的意思）
like a（像，不像的意思）
犬按功能分，导盲犬，搜爆犬
abstract class 犬{
abstract void 吼叫（）；
}
interface 导盲{
abstract void 导盲（）；//导盲功能
}
class 导盲犬 extends 犬 implements 导盲{
public void 吼叫（）//吼叫功能
{
}
public void 导盲（）{}//导盲功能
}
面向对象（接口的应用）
笔记本电脑使用
为了扩展笔记本的功能，但日后出现什么功能设备不知道。
定义一个规则，只要日后出现的设备都符合这个规定就可以了。
规则在java中就是接口。
interface USB//暴露的规则
{
public void open();//开
public void close();//关
}
class BookPC{
public static void main(String[] args){
useUSB(new UPan());//功能扩展
useUSB(new UsbMouse());
}
//使用规则
publci static void useUSB(USB u)
{//接口类型的引用，用于接受（指向）接口的子类对象
u.open();
u.close();
}
}
//一年后
//实现规则
//这些设备和电脑的耦合性降低了
class UPan implements USB{
public void open(){
System.out.println{"upan open"}
}
public void close(){
System.out.println("upan close");
}
}
class UsbMouse implements USB{
public void open(){
System.out.println("UsnMouse open")
}
publci void close(){
System.out.println("UsnMouse close");
}
}
面向对象（接口——定义interface
abstract class AbsDemo{
abstract void show();
abstract void show();
}
/*
当一个抽象类中的方法都是抽象的时候，这时可以将该类抽象类用另外一种形式定义
和表示，就是接口interface。
定义接口使用的关键字不是class，是interface。
对于接口当中常见的成员：而这些成员都有固定的修饰符。
1，全局常量：public static final。
2，抽象方法 ：public abstract。
*/
interface Demo{
public static final int NUM=4;
public abstract void show();
public abstract void show();
}
class InterfaceDemo{
public static void main(String[] args){
System.out.println("hehe");
}
}
面向对象（接口——实现implements）
interface Demo{
public static final int NUM=4;
public abstract void show1();
public abstract void show2();
}
/*
类与类之间是继承关系，类与接口直接是实现关系。
接口不可以被实例化。
只能由实现了接口的子类并覆盖了接口中所有的抽象方法，
该子类才可以被实例化，否则，这个子类就是一个抽象类。
*/
class DemoImpl implements/*实现*/ Demo{
public void show1()
{}
public void show2()
{
}
}
class InterfaceDemo1{
publci static void main(String[] args){
DemoImpl d=new DemoImpl();
System.out.println(d.NUM);
System.out.println(DemoImpl.NUM);
System.out.println(Demo.NUM);
}
}
面向对象（接口——多实现）
在Java中不直接支持多继承，因为会出现调用的不确定性。所以java将多继承机制
改良，在java中变成了多实现。
一个类可以实现多个接口。
interface A{
public void show();
}
interface Z{
publi void show();
}
class Test implements A,Z//多实现
{
public void show()
{
}
}
class InterfaceDemo2{
public static void main(String[] args){
Test t=new Test();
t.show();
}
}
面向对象（接口——细节）
interface A{
public void show();
}
interface Z{
public void show();
}
class Test implements A,Z{
public int add(int a,int b){
return a+b+3;
}
public void show(){}
}
//一个类在继承另一个类的同时，还可以实现多个接口。
class Q{
public void method()
{}
}
abstract class Test2 extends Q implements A,Z
{
}
//接口的出现避免了单继承的局限性
interface C{
void show();
}
interface M{
void show();
}
interface Q extends C,M{
//接口与接口之间是继承关系，而且接口可以多继承。
void function();
}
class W ipmlements Q
{//覆盖3个方法
public void show(){}
public void method(){}
public void function(){}
}
class InterfaceDemo3{
publci static void main(String[] args){
Test t=new Test();
t.show();
}
}
java支持多继承吗？
支持。只不过多继承在类中进行了改良，用了多实现来体现，但是接口内容
的出现，却可以进行多继承，原理是，方法体是否有存在。
java支持多继承吗?
支持。支持接口。只要看有没有方法体，不支持多继承的原因就是方法体
导致运行调用的不确定性。
面向对象（接口——特点）
接口是对外暴露的规则
接口是程序的功能扩展
接口的出现降低耦合性
接口可以用来多实现
类也接口之间是实现关系，而且类可以继承一个类的同时实现多个接口
接口与接口之间可以有继承关系
面向对象（接口和抽象类的区别）
抽象类和接口的异同点：
相同点：都是不断向上抽取而来的
不同点：
1，抽象类需要被继承，而且只能单继承。
接口需要被实现，而且可以多实现
2，抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法
接口中只能定义抽象方法，必须由子类去实现
3，抽象类的继承，是is a关系，在定义该体系的基本共性内容
接口的实现时like a关系，在定义体现额外功能
注：is a（所有的意思）
like a（像，不像的意思）
犬按功能分，导盲犬，搜爆犬
abstract class 犬{
abstract void 吼叫（）；
}
interface 导盲{
abstract void 导盲（）；//导盲功能
}
class 导盲犬 extends 犬 implements 导盲{
public void 吼叫（）//吼叫功能
{
}
public void 导盲（）{}//导盲功能
}
面向对象（接口的应用）
笔记本电脑使用
为了扩展笔记本的功能，但日后出现什么功能设备不知道。
定义一个规则，只要日后出现的设备都符合这个规定就可以了。
规则在java中就是接口。
interface USB//暴露的规则
{
public void open();//开
public void close();//关
}
class BookPC{
public static void main(String[] args){
useUSB(new UPan());//功能扩展
useUSB(new UsbMouse());
}
//使用规则
publci static void useUSB(USB u)
{//接口类型的引用，用于接受（指向）接口的子类对象
u.open();
u.close();
}
}
//一年后
//实现规则
//这些设备和电脑的耦合性降低了
class UPan implements USB{
public void open(){
System.out.println{"upan open"}
}
public void close(){
System.out.println("upan close");
}
}
class UsbMouse implements USB{
public void open(){
System.out.println("UsnMouse open")
}
publci void close(){
System.out.println("UsnMouse close");
}
}
abstract class AbsDemo{
abstract void show();
abstract void show();
}
/*
当一个抽象类中的方法都是抽象的时候，这时可以将该类抽象类用另外一种形式定义
和表示，就是接口interface。
定义接口使用的关键字不是class，是interface。
对于接口当中常见的成员：而这些成员都有固定的修饰符。
1，全局常量：public static final。
2，抽象方法 ：public abstract。
*/
interface Demo{
public static final int NUM=4;
public abstract void show();
public abstract void show();
}
class InterfaceDemo{
public static void main(String[] args){
System.out.println("hehe");
}
}
面向对象（接口——实现implements）
interface Demo{
public static final int NUM=4;
public abstract void show1();
public abstract void show2();
}
/*
类与类之间是继承关系，类与接口直接是实现关系。
接口不可以被实例化。
只能由实现了接口的子类并覆盖了接口中所有的抽象方法，
该子类才可以被实例化，否则，这个子类就是一个抽象类。
*/
class DemoImpl implements/*实现*/ Demo{
public void show1()
{}
public void show2()
{
}
}
class InterfaceDemo1{
publci static void main(String[] args){
DemoImpl d=new DemoImpl();
System.out.println(d.NUM);
System.out.println(DemoImpl.NUM);
System.out.println(Demo.NUM);
}
}
面向对象（接口——多实现）
在Java中不直接支持多继承，因为会出现调用的不确定性。所以java将多继承机制
改良，在java中变成了多实现。
一个类可以实现多个接口。
interface A{
public void show();
}
interface Z{
publi void show();
}
class Test implements A,Z//多实现
{
public void show()
{
}
}
class InterfaceDemo2{
public static void main(String[] args){
Test t=new Test();
t.show();
}
}
面向对象（接口——细节）
interface A{
public void show();
}
interface Z{
public void show();
}
class Test implements A,Z{
public int add(int a,int b){
return a+b+3;
}
public void show(){}
}
//一个类在继承另一个类的同时，还可以实现多个接口。
class Q{
public void method()
{}
}
abstract class Test2 extends Q implements A,Z
{
}
//接口的出现避免了单继承的局限性
interface C{
void show();
}
interface M{
void show();
}
interface Q extends C,M{
//接口与接口之间是继承关系，而且接口可以多继承。
void function();
}
class W ipmlements Q
{//覆盖3个方法
public void show(){}
public void method(){}
public void function(){}
}
class InterfaceDemo3{
publci static void main(String[] args){
Test t=new Test();
t.show();
}
}
java支持多继承吗？
支持。只不过多继承在类中进行了改良，用了多实现来体现，但是接口内容
的出现，却可以进行多继承，原理是，方法体是否有存在。
java支持多继承吗?
支持。支持接口。只要看有没有方法体，不支持多继承的原因就是方法体
导致运行调用的不确定性。
面向对象（接口——特点）
接口是对外暴露的规则
接口是程序的功能扩展
接口的出现降低耦合性
接口可以用来多实现
类也接口之间是实现关系，而且类可以继承一个类的同时实现多个接口
接口与接口之间可以有继承关系
面向对象（接口和抽象类的区别）
抽象类和接口的异同点：
相同点：都是不断向上抽取而来的
不同点：
1，抽象类需要被继承，而且只能单继承。
接口需要被实现，而且可以多实现
2，抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法
接口中只能定义抽象方法，必须由子类去实现
3，抽象类的继承，是is a关系，在定义该体系的基本共性内容
接口的实现时like a关系，在定义体现额外功能
注：is a（所有的意思）
like a（像，不像的意思）
犬按功能分，导盲犬，搜爆犬
abstract class 犬{
abstract void 吼叫（）；
}
interface 导盲{
abstract void 导盲（）；//导盲功能
}
class 导盲犬 extends 犬 implements 导盲{
public void 吼叫（）//吼叫功能
{
}
public void 导盲（）{}//导盲功能
}
面向对象（接口的应用）
笔记本电脑使用
为了扩展笔记本的功能，但日后出现什么功能设备不知道。
定义一个规则，只要日后出现的设备都符合这个规定就可以了。
规则在java中就是接口。
interface USB//暴露的规则
{
public void open();//开
public void close();//关
}
class BookPC{
public static void main(String[] args){
useUSB(new UPan());//功能扩展
useUSB(new UsbMouse());
}
//使用规则
publci static void useUSB(USB u)
{//接口类型的引用，用于接受（指向）接口的子类对象
u.open();
u.close();
}
}
//一年后
//实现规则
//这些设备和电脑的耦合性降低了
class UPan implements USB{
public void open(){
System.out.println{"upan open"}
}
public void close(){
System.out.println("upan close");
}
}
class UsbMouse implements USB{
public void open(){
System.out.println("UsnMouse open")
}
publci void close(){
System.out.println("UsnMouse close");
}
}
面向对象（接口——定义interface
abstract class AbsDemo{
abstract void show();
abstract void show();
}
/*
当一个抽象类中的方法都是抽象的时候，这时可以将该类抽象类用另外一种形式定义
和表示，就是接口interface。
定义接口使用的关键字不是class，是interface。
对于接口当中常见的成员：而这些成员都有固定的修饰符。
1，全局常量：public static final。
2，抽象方法 ：public abstract。
*/
interface Demo{
public static final int NUM=4;
public abstract void show();
public abstract void show();
}
class InterfaceDemo{
public static void main(String[] args){
System.out.println("hehe");
}
}
面向对象（接口——实现implements）
interface Demo{
public static final int NUM=4;
public abstract void show1();
public abstract void show2();
}
/*
类与类之间是继承关系，类与接口直接是实现关系。
接口不可以被实例化。
只能由实现了接口的子类并覆盖了接口中所有的抽象方法，
该子类才可以被实例化，否则，这个子类就是一个抽象类。
*/
class DemoImpl implements/*实现*/ Demo{
public void show1()
{}
public void show2()
{
}
}
class InterfaceDemo1{
publci static void main(String[] args){
DemoImpl d=new DemoImpl();
System.out.println(d.NUM);
System.out.println(DemoImpl.NUM);
System.out.println(Demo.NUM);
}
}
面向对象（接口——多实现）
在Java中不直接支持多继承，因为会出现调用的不确定性。所以java将多继承机制
改良，在java中变成了多实现。
一个类可以实现多个接口。
interface A{
public void show();
}
interface Z{
publi void show();
}
class Test implements A,Z//多实现
{
public void show()
{
}
}
class InterfaceDemo2{
public static void main(String[] args){
Test t=new Test();
t.show();
}
}
面向对象（接口——细节）
interface A{
public void show();
}
interface Z{
public void show();
}
class Test implements A,Z{
public int add(int a,int b){
return a+b+3;
}
public void show(){}
}
//一个类在继承另一个类的同时，还可以实现多个接口。
class Q{
public void method()
{}
}
abstract class Test2 extends Q implements A,Z
{
}
//接口的出现避免了单继承的局限性
interface C{
void show();
}
interface M{
void show();
}
interface Q extends C,M{
//接口与接口之间是继承关系，而且接口可以多继承。
void function();
}
class W ipmlements Q
{//覆盖3个方法
public void show(){}
public void method(){}
public void function(){}
}
class InterfaceDemo3{
publci static void main(String[] args){
Test t=new Test();
t.show();
}
}
java支持多继承吗？
支持。只不过多继承在类中进行了改良，用了多实现来体现，但是接口内容
的出现，却可以进行多继承，原理是，方法体是否有存在。
java支持多继承吗?
支持。支持接口。只要看有没有方法体，不支持多继承的原因就是方法体
导致运行调用的不确定性。
面向对象（接口——特点）
接口是对外暴露的规则
接口是程序的功能扩展
接口的出现降低耦合性
接口可以用来多实现
类也接口之间是实现关系，而且类可以继承一个类的同时实现多个接口
接口与接口之间可以有继承关系
面向对象（接口和抽象类的区别）
抽象类和接口的异同点：
相同点：都是不断向上抽取而来的
不同点：
1，抽象类需要被继承，而且只能单继承。
接口需要被实现，而且可以多实现
2，抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法
接口中只能定义抽象方法，必须由子类去实现
3，抽象类的继承，是is a关系，在定义该体系的基本共性内容
接口的实现时like a关系，在定义体现额外功能
注：is a（所有的意思）
like a（像，不像的意思）
犬按功能分，导盲犬，搜爆犬
abstract class 犬{
abstract void 吼叫（）；
}
interface 导盲{
abstract void 导盲（）；//导盲功能
}
class 导盲犬 extends 犬 implements 导盲{
public void 吼叫（）//吼叫功能
{
}
public void 导盲（）{}//导盲功能
}
面向对象（接口的应用）
笔记本电脑使用
为了扩展笔记本的功能，但日后出现什么功能设备不知道。
定义一个规则，只要日后出现的设备都符合这个规定就可以了。
规则在java中就是接口。
interface USB//暴露的规则
{
public void open();//开
public void close();//关
}
class BookPC{
public static void main(String[] args){
useUSB(new UPan());//功能扩展
useUSB(new UsbMouse());
}
//使用规则
publci static void useUSB(USB u)
{//接口类型的引用，用于接受（指向）接口的子类对象
u.open();
u.close();
}
}
//一年后
//实现规则
//这些设备和电脑的耦合性降低了
class UPan implements USB{
public void open(){
System.out.println{"upan open"}
}
public void close(){
System.out.println("upan close");
}
}
class UsbMouse implements USB{
public void open(){
System.out.println("UsnMouse open")
}
publci void close(){
System.out.println("UsnMouse close");
}
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 09-面向对象(接口-定义interface)1 09-面向对象(接口-定义interface)2
- Thrift 接口定义语言（interface description language）参考手册
- 黑马程序员面试题面向对象二(多态,抽象类abstract,接口Interface,内部类,异常Exception,包package,String类,StringBuffer)
- 证明接口interface中定义的方法的访问权限为public
- Java-面向对象之接口interface
- Atlas学习手记（29）：JavaScript面向对象的扩展（三）：接口Interface
- 通过接口（interface）来实现定义回调函数
- java学习15-面向对象（interface接口）
- java面向对象-接口interface
- NO8.java笔记【面向对象、抽象类、abstract、接口、interface、多态 、内部类、匿名内部类、异常、Object类】
- 【java学习记录】7.定义一个接口ArearInterface，其中包含一个方法，计算面积三角形、矩形、圆形的面积
- 11-面向对象(接口-多实现)1 11-面向对象(接口-多实现的定义)2 11-面向对象(接口-多实现)3 11-面向对象(接口-多实现)4
- 接口：定义形式 interface
- Objective-c 类接口 （@interface） （类定义）
- Android Interface Definition Language (AIDL) android接口定义语言 开发文档翻译 - 1
- 关于Java接口interface定义的几点说明
- 并口串口接口定义(LPT COM Interface)
- Java面向对象-接口的定义和接口的成员
- AIDL(AndroidInterfaceDefinitionLanguage：接口定义语言)
- Java中接口（Interface）的定义和使用