面向对象（接口——定义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");
}
}
扫一扫
883
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
