java 抽象类 多态_Java抽象类\多态

1抽象类什么时候使用?

当某个父类只是知道子类应该包含怎么样的方法，但是无法准确知道子类如何实现这些方法。

比如一个图形类应该有一个求周长的方法，但是不同的图形求周长的算法不一样。那该怎么办呢？

(分析事物时，发现了共性内容，就出现向上抽取。会有这样一种特殊情况，就是方法功能声明相同，但方法功能主体不同。那么这时也可以抽取，但只抽取方法声明，不抽取方法主体。那么此方法就是一个抽象方法。)

2抽象类： 包含抽象方法的类，一定是抽象类,,使用 abstract 修饰的类，是抽象类

抽象类的特点：

1，抽象类与抽象方法都必须使用 abstract 来修饰

2，抽象类不能直接创建对象(意义),原因：调用抽象方法没有意义。

3，抽象类中可以有抽象方法，也可以没有抽象方法(面试问题)

4，抽象类的子类(继承)

a，实现了抽象方法的具体类,,只有覆盖了抽象类中所有的抽象方法后，其子类才可以创建对象。

b，抽象类,否则该子类还是一个抽象类,子类不可以创建对象。

抽象类面试题：//抽象类中是否可以没有抽象方法？如果可以，那么，该类还定义成抽象类有意义吗？为什么？可以没有抽象方法，有意义，不会让其他人直接创建该类对象

3抽象方法

抽象方法： 方法只有声明部分，没有方法体.

抽象方法定义的格式：

public abstract 返回值类型 方法名(参数);

抽象类定义的格式：

public abstract void class 类名 {

}

4 抽象类的细节问题：

1)、抽象类一定是个父类？是的，因为不断抽取而来的。

2)、抽象类中是否可以不定义抽象方法。

是可以的，那这个抽象类的存在到底有什么意义呢？不让该类创建对象,方法可以直接让子类去使用

3)、抽象关键字 abstract 不可以和哪些关键字共存？

①private：私有的方法子类是无法继承到的，也不存在覆盖，而 abstract 和 private 一起使用修饰方法，abstract 既要子类去实现这个方法，而 private 修饰子类根本无法得到父类这个方法。互相矛盾。

②final.

③static.

eg:

抽象类Employee

package com.hello.abstrsct;

public abstract class Employee {

public abstract void working();//声明抽象类方法

}

抽象类PhpCoder

package com.hello.abstrsct;

public class PhpCoder extends Employee {

public void working() {

System.out.println("java");

}

}

测试

package com.hello.abstrsct;

import org.junit.Test;

public class Demo {

@Test

public void test() {

PhpCoder p=new PhpCoder();//实例化子类

p.working();

}

}多态

现实事物经常会体现出多种形态，如学生，学生是人的一种，则一个具体的同学张三既是学生也是人，即出现两种形态。如 Student 类继承了 Person 类，一个 Student 的对象便既是 Student，又是 Person。那么一个 Student 对象既可以赋值给一个 Student 类型的引用，也可以赋值给一个 Person 类型的引用。

多态使用的前提：

1，有继承或者实现关系

2，要方法重写

3，父类引用指向子类对象

多态特点:

①最终多态体现为父类引用变量可以指向子类对象。

②多态的前提是必须有子父类关系或者类实现接口关系，否则无法完成多态。

③在使用多态后的父类引用变量调用方法时，会调用子类重写后的方法。

多态的定义格式：就是父类的引用变量指向子类对象

父类类型 变量名 = new 子类类型();

变量名.方法名();

分类:

①普通类多态定义的格式

父类 变量名 = new 子类();

如： class Fu {}

class Zi extends Fu {}

//类的多态使用

Fu f = new Zi();//实例化子类

②抽象类多态定义的格式

抽象类 变量名 = new 抽象类子类();

如： abstract class Fu {

public abstract void method();

}

class Zi extends Fu {

public void method(){

System.out.println(“重写父类抽象方法”);

}

}

//类的多态使用

Fu fu= new Zi();//实例化抽象子类

③接口多态定义的格式

接口 变量名 = new 接口实现类();

如：

//接口

interface Fu {

public abstract void method();

}

接口实现类implements

class Zi implements Fu {

public void method(){

System.out.println(“重写接口抽象方法”);

}

}

//接口的多态使用

Fu fu = new Zi();//实例化接口实现类

成员变量在使用上有没有变化,有的

package com.hello.abstrsct;

public class Fu {

int num = 4;

void show() {

System.out.println("Fu show num");

}

}

子类

package com.hello.abstrsct;

public class Zi extends Fu {

int num = 5;

public void show() {

System.out.println("Zi show num");

}

}

多态测试

public class Test1 {

public static void main(String[] args) {

Fu f = new Zi();

//f.show();//显示子类的

Zi zi=new Zi();

System.out.println(zi.num);//5

System.out.println(f.num);//4

}

成员方法在使用上有没有变化,有的

public static void main(String[] args) {

Fu f = new Zi();//实例化子类

f.show();//显示子类的

}instanceof 关键字

来判断某个对象是否属于某种数据类型。如学生的对象属于学生类，学生的对象也属于人类。

使用格式：

boolean b = 对象 instanceof 数据类型;

如Person p1 = new Student(); // 前提条件，学生类已经继承了人类

boolean flag = p1 instanceof Student; //flag 结果为 true

boolean flag2 = p2 instanceof Teacher; //flag 结果为 false

多态的转型分为向上转型与向下转型两种：

向上转型：当有子类对象赋值给一个父类引用时，便是向上转型，多态本身就是向上转型的过程。

使用格式：父类类型 变量名 = new 子类类型();

如：Person p = new Student();

向下转型：一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用转为子类引用，这个过程是向下转型。如果是直接创建父类对象，是无法向下转型的！

使用格式：子类类型 变量名 = (子类类型) 父类类型的变量;

Person p = new Student();

如:Student stu = (Student) p; //变量 p 实际上指向 Student 对象

!!如果是调用子类独有的功能时,必须要向下转型,才能调用.

//描述动物类，并抽取共性 eat 方法

abstract class Animal {

abstract void eat();

}

// 描述狗类，继承动物类，重写 eat 方法，增加 lookHome 方法

class Dog extends Animal {

void eat() {

System.out.println("啃骨头");

}

void lookHome() {

System.out.println("看家");

}

}

// 描述猫类，继承动物类，重写 eat 方法，增加 catchMouse 方法

class Cat extends Animal {

void eat() {

System.out.println("吃鱼");

}

void catchMouse() {

System.out.println("抓老鼠");

}

}

测试

public class Test {

public static void main(String[] args) {

Animal a = new Dog(); //多态形式，创建一个狗对象

a.eat(); // 调用对象中的方法，会执行狗类中的 eat 方法

// a.lookHome();//使用 Dog 类特有的方法，需要向下转型，不能直接使用

// 为了使用狗类的 lookHome 方法，需要向下转型

// 向下转型过程中，可能会发生类型转换的错误，即 Class Cast Exception 异常

// 那么，在转之前需要做健壮性判断

if( !a instanceof Dog){ // 判断当前对象是否是 Dog 类型

System.out.println("类型不匹配，不能转换");

return;}

}