Java基础3

2018-04-07  本文已影响0人  Jy_北海

接口

当一个抽象类中的方法都是抽象的时候 可以将该抽象类用另一种方式表示 即接口

定义接口的关键字是 Interface

例如

abstract class Demo1

{

abstract void show1(){};

abstract boid show2(){};

}

interface Demo

{

abstract void show1();

abstract boid show2();

}

接口中常见的成员:

1.全局常量--->pubic static final

2.抽象方法--->public abstract

接口中的成员都是公共的权限~

interface Demo

{

public static final int Num = 1;

public abstract void show1();

public abstract void show2();

}

//类与类之间是继承关系 类与接口直接是实现过程

/*

1.接口不可以实例化 只能由实现了接口的子类并覆盖了接口中的所有抽象方法后

该子类才可以实例化,否则这个字类就是一个抽象类

*/

class DemoImpl implements Demo

{

public void show1(){}

public void show2(){}

}

interface Demo

{

public static final int Num = 1;

public abstract void show1();

public abstract void show2();

}

class InterfaceDemo

{

public static void main(String[] arr){

DemoImpl d = new DemoImpl();

System.out.println(d.Num);

System.out.println(DemoImpl.Num);

System.out.println(Demo.Num);

}

}

在Java中不直接支持多继承,会出现调用的不确定性

所以Java将多继承机制进行了改良 变成了多实现--↓

↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓

一个类可以实现多个接口。

interface A

{

public void show();

}

interface B

{

public void show();

}

class C

{

public void method()

{}

}

class Test implements A,B//多实现

{

public void show()

{

}

}

class Test extends C implements A,B

{

}

class InterfaceDemo

{

public static void main(String[] arr)

{

Test t = new Test();

t.show();

}

}

一个类在继承另一个类的同时 才可以实现多个接口

class Test extends C implements A,B

{

}

接口的出现避免了单继承的局限性

接口可以多继承

interface A{}

interface B{}

interface C extends A,B{}

接口的特点

抽象类和接口的异同点:

相同点:都是不断向上抽取而来的

不同点:

1.抽象类需要给继承,,而且只能单继承

接口需要被实现,而且可以多实现

2.抽象类中可以定义抽象方法和非抽象方法,子类继承后,可以直接使用非抽象方法

  接口中只能定义抽象方法,必须由子类去实现

3.抽象类的继承是所有的关系,在定义该体系的基本共性内容

接口的实现是'like'即'像'的关系,在定义体系额外功能

多态

定义:某一类事物的多种存在形态

对象的多态性

class Animal

{}

class Cat extends Animal

{}

class Dog extends Animal

{}

Cat x = new Cat();

Animal x = new Cat();//父类型指向子对象  一个对象两种形态

//Cat这类事物既具备了Cat的形态,也具备了Animal的形态,这就是对象的多态性

简单说:就是一个对象对应着不同的类型

多态在代码中的体现:

父类或者接口的引用指向其子类的对象

多态示例:

class Animal

{

abstract void eat();

}

class Dog extends Animal

{

void eat()

{

syso;

}

void look()

{

syso;

}

}

class Cat extends Animal

{

void eat()

{

syso;

}

void Catch()

{

syso;

}

}

class Pig extends Animal

{

void eat()

{

syso;

}

void pigWork

{

syso;

}

}

class DuoTaiDemo

{

public static void main(String[] arr)

{

Cat c = new Cat();

Dog d = new Dog();

//c.eat();

method(c);

method(d);

method(new Pig());

}

/*

public static void method(Cat c)

{

c.eat();

}

public static void method(Dog c)

{

d.eat();

}

public static void method(Pig p)

{

p.eat();

}*/

public static void method(Animal a)

{

a.eat();

}

}

由上可见,多态的好处:

提高了代码的扩展性,前期定义的代码可以使用后期的内容

多态的局限性:

前期定义的内容不能调用后期子类的特有功能

多态的前提:

1.必须有关系,继承,实现

2.要有覆盖

Animal a = new Cat();

//自动类型提升,Cat对象提升了Aniaml类型,但是Cat特有功能无法访问

//作用就是限制特有功能访问--->向上转型

Cat c = (Cat)a;//向下转型是为了使用子类特有功能

//向下转型  可以访问特有功能

上一篇下一篇

猜你喜欢

热点阅读