java接口的多态性,java抽象类和接口的理解

　　00-1010 1.多态性1.1向上转换1.2向下转换1.3实现多态性的条件1.4多态性的特点及应用1.5使用父类型作为方法的参数，父类型作为方法的返回值的多态性1.6多态性的注意点2。抽象类2.1抽象关键字2.2抽象方法与普通方法的区别2.3抽象类与普通类的区别2.4本质2 .5抽象类的局限性3。接口3.1定义接口3.2使用接口3.3实现多个接口3.4 jdk8接口新特性

　　00-1010一个特定类型的变量可以引用很多不同类型的对象，可以自动调用引用对象的方法，即根据引用对象的不同，响应不同的操作。

　　方法重写是多态的基础。在继承中，子类拥有与父类相同的方法(方法名、参数和返回值)，这被称为重写。

　　包com . itlaobing . demo；public pet { public void to hospital(){ system . out . println(宠物医生)；}}类狗扩展pet { public void to hospital(){ system . out . println(狗看病)；}} classcat扩展pet { public void to hospital(){ system . out . println(猫看病)；} }公共静态void main(String[]args){ Dog Dog=new Dog()；dog . tohospital()；//狗看病猫cat=新猫()；cat . to hospital()；//猫看病system . out . println(==============)；//多态宠物Pet；pet=新狗()；pet . to hospital()；//pet=new Cat()进行狗的治疗；pet . to hospital()；//在多态中，执行变量引用对象的对应方法。

　　多态是指在一个方法调用中，根据所包含对象的实际类型(即实际子类的对象)来决定应该调用method的哪个子类，而不是由用来存储对象引用变量的类型来决定。调用方法时，为了实现多态操作，必须在父类中声明方法，并在子类中重写方法。

　　00-1010由子类类型转换为父类类型，称为向上转换。父类引用指向子类对象。

　　//父类类型变量=子类类型实例；Pet pet=新狗()；//上转换多态性是指一个父类可能有多个子类，每个子类都覆盖父类的方法(每个子类都有不同的方法实现)。当父类调用一个方法时，父类引用指向哪个子类，执行哪个子类的方法。当父类引用同一个方法时，有不同的实现。

　　父类引用只能调用父类中存在的方法(从父类继承的子类的方法/重写方法)。

　　父类引用不能调用由子类扩展的方法(唯一方法)。

　　00-1010父类类型转换为子类类型，这称为向下转换。需要强制类型转换。

　　注意：首先你要判断是否属于需要转移的类型(instanceof)。否则，您将报告一个错误java.lang.ClassCastException

　　public static void main(String[]args){//Dog Dog=(Dog)new Pet()；//下变换java.lang.classcastexception//system.out.println(狗的newpet()实例)；//假宠pet=新狗()；//向上转换狗狗=nullif(pet instance of Dog){ Dog=(Dog)pet；//down conversion } system . out . println(pet . getclass())；//class com . itlaobing . demo . Dog system . out . println(Dog的宠物实例)；//true}

　　00-1010类之间有继承关系。

　　父类引用指向子类对象(向上转换)

　　子类应该覆盖父类的方法。

　　ian">

1.4多态的特点与使用

特点：①可替换性②可扩充性③接口性④灵活性⑤简化性

　　使用：①接口②重写③抽象类方法

1.5多态的应用

以父类类型作为方法的参数

父类类型出现的地方，子类都可以出现（使用）

public void toHost(Pet pet) { System.out.print("主人带"); pet.toHospital();}public static void main(String[] args) { Person person = new Person();     Dog dog = new Dog(); person.toHost(dog);     Cat cat = new Cat(); person.toHost(cat);     Pet pet = new Pet(); person.toHost(pet);}

使用父类型作为方法的返回值

public Pet getPet(int type) { if(1 == type) { return new Dog(); }else if(2 == type) { return new Cat(); }else { return new Pet(); }}

1.6 多态的注意点

public class Pet { public Pet getInstance() { System.out.println("pet getInstance()"); return new Pet(); } public static void staticMethod() { System.out.println("Pet staticMethod()"); }}class Dog extends Pet{ @Override public Dog getInstance() { System.out.println("Dog getInstance()"); return new Dog(); } public static void staticMethod() { System.out.println("Dog staticMethod()"); } }

public static void main(String[] args) { Pet p = new Dog(); p.getInstance(); // Dog getInstance() p.staticMethod();// Pet staticMethod() }

p.getInstance()调用的是 Dog 类中的方法，因为在 Dog 类中重写了 Pet 中的getInstance()方法，且调用实例方法看的是哪个对象调用就执行哪个对象中的方法。也就是说by Class。

　　p.staticMethod()调用的是 Pet 类中的方法，因为staticMethod()是 static 方法，属于 类。虽然 Dog 类中隐藏了父类的方法，但是调用 static 方法看的是类型，也就是说by type，并且这和多态无关。

　　可以简单的说，调用 static 方法看左边。调用 实例方法 看右边。

2.抽象类

public class Pet { public void toHospital() { System.out.println("宠物看病"); }}public class Dog extends Pet { public void porter() { System.out.println("看门狗"); } public void toHospital() { System.out.println("狗狗看病"); }}public class Cat extends Pet{ public void catchMouse() { System.out.println("猫捉老鼠"); } public void toHospital() { System.out.println("猫猫看病"); }}

从上面的代码可以 发现，父类中的的toHospital()方法并没有实际意义，只是定义了一个规范，但是删除之后，调用会报错。失去了多态的特性。抽象类/抽象方法作用就是定义规范

2.1 abstract关键字

在 java 中，被 abstract 关键字修饰的类叫做抽象类，被 abstract 关键字修饰的方法叫做抽象方法。 抽象方法是没有具体实现（没有方法体）的。 abstract 不能和 final 一起使用。

2.2 抽象方法和普通方法的区别

[修饰符] 返回值类型 方法名([参数列表]){ //普通方法 //方法体}[修饰符] abstract 返回值类型 方法名([参数列表]); //抽象方法

抽象方法没有具体的实现（没有方法体），所以，抽象不能执行。

　　抽象方法是由继承了抽象类的子类重写后调用子类重写的方法来执行。

　　区别：

　　①抽象方法有abstract修饰

　　②抽象方法没有方法体

　　③抽象方法无法执行

　　④抽象方法不能用private修饰，因为被private修饰的成员无法被继承

2.3 抽象类和普通类的区别

[修饰符] abstract class 类名{} //抽象类[修饰符] class 类名{} //普通类

抽象类中可以有普通方法

　　如果一个类继承了抽象类，那么这个类必须重写它的抽象方法，或者将类声明为抽象类

　　抽象类是有构造方法的，但是不能被实例化。因为抽象类中的抽象方法是没有方法体的，导致抽象类不是一个完整的类，因此不允许实例化。

　　构造方法、类方法( static )不能声明为抽象( abstract )方法

　　抽象类除了不能被实例化以外，和普通了类没有区别。定义抽象类是为了强迫子类实现抽象方 法，是定义规范的

　　区别：

　　①抽象类有abstract修饰

　　②抽象类中可以有抽象方法，普通类不能有抽象方法，一个类中只要含有抽象方法，这个类就必须是抽象类，但是抽象类不一定含有抽象方法

　　③抽象类不能被实例化，需要抽象类变量引用其子类的对象

2.4 本质

上层代码定义规范，不用实现。具体业务实现由子类完成，调用者不用关心。

2.5 抽象类局限

子类重写抽象类的抽象方法可能会出现代码重复的情况，不符合代码复用的要求

3.接口

约定好规范，然后按照规范来做。接口就是定义规范。

　　java 中的接口作用和生活中类似，它提供一种约定，使实现接口的类在形式上保持一致。

　　抽象类中可以有普通方法而接口中的方法都是抽象的，如果抽象类诶中的方法都是抽象方法，可以使用java提供的接口表示，因此也可以将接口看做是一个特殊的 抽象类 ，但是采用与抽象类完全不同的语法表示，并且两者的设计理念也不同。

　　接口不能被 实例化，而且没有构造方法。

3.1 定义接口

[修饰符] interface 接口名{//接口成员[public] [static] [final] 数据类型 成员变量名 = 常量；public] [abstract] 返回值类型 方法名称([参数列表]);}

接口的访问权限是public或package-acces，与类的访问权限类似

　　和抽象类不同，定义接口使用interface关键字

　　接口中的方法默认是抽象方法，所以可以省略 abstract 修饰符

　　接口中的方法默认都是 public 的，所以可以省略 public

　　接口中的变量只能是静态常量( static final ),所以可以省略 static final ，静态常量在定义时就要 赋值，且不可变。

　　一个接口可以继承其他接口，被继承的接口称为父接口。子接口将继承父接口中声明的常量和抽象方法

3.2 使用接口

使用接口和使用抽象类一样，都是通过子类。子类通过 implements 关键字实现接口，实现接口就必须实现 接口中的抽象方法

public 类名 implements 接口名{ 实现方法 普通方法 属性}

一个类可以实现多个接口，接口之间使用,隔开

　　实现接口的类必须实现接口中定义的所有抽象方法，即使不使用也必须实现它，通常用空方法体实现子类不需要的抽象方法，如果抽象方法有返回值，可返回默认值

　　接口的实现类中，可以有普通方法

　　实现的方法必须是public的，因为重写方法时，权限不能缩小，只能大于等于被继承的方法的访问权限。

　　接口与接口之间是继承关系，使用 extends 关键字。多个接口使用,隔开，但是接口不能继承类

3.3 实现多个接口

java 中继承是单继承,使用 extends 关键字；但是一个类可以实现多个接口，使用 implements ，多个 接口之间用 , 隔开。

　　一个类可以同时继承和实现接口， extends 要在 implements 之前

3.4 jdk8接口新特性

在 jdk8.0 中 default 关键字可用于在接口中修饰方法（默认方法）, default 修饰的方法可以有具体 实现，也只能在接口中出现。 default 修饰的方法可以被重写。如果一个类实现了两个接口，这两个接口又同时都包含了一个同名的default方法，这种情况下编译器会报错。

　　接口中还可以有static修饰的方法，称为静态方法(类方法)。类方法可以直接使用接口名.方法名调用。

　　以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持盛行IT。

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。