Java十分钟精通多态与抽象类的使用与原理

我们知道Java的三大特性：封装、继承、多态。前两个之前在Java入门（六）已经讲到，现在来讲多态这个特性。

什么是多态？

多态顾名思义即为多种形态的意思

Java中多态的含义：

• 发送消息给某个对象，让这个对象自行决定采用哪种行为响应这个消息
• 子类对象的引用赋值给父类引用变量来实现动态的方法调用

Java中形成多态的前提：

• 继承
• 父类方法的重写
• 向上转型

我对多态的解释：

比如我们，是人，也是学生，也是年轻人，我可以用人的身份去做事情，也可以用学生的身份去买学生票，也可以用年轻人的身份做公益，这样我们可以通过不同的形态去做不同的事情。这样是不是更好理解一点？

注意：

多态前提条件：必须有子父类关系。

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

多态的定义与使用格式：

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

多态中成员的特点：

• 多态成员变量：编译运行看左边
• 多态成员方法：编译看左边，运行看右边

多态的转型：

• 多态的转型分为向上转型和向下转型两种
• 向上转型：多态本身就是向上转型过的过程
• 使用格式：父类类型 变量名=new 子类类型();
• 适用场景：当不需要面对子类类型时，通过提高扩展性，或者使用父类的功能就能完成相应的操作。
• 向下转型：一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用类型转为子类引用各类型
• 使用格式：子类类型 变量名=（子类类型） 父类类型的变量；
• 适用场景：当要使用子类特有功能时。

代码解释：

public class Person {     //人类，作为父类使用
    public void speak(){
        System.out.println("我们都是一个人");
    }
}



public class Student extends Person{    //继承父类，相当于我们是学生，有人的方法
    @Override
    public void speak(){
        System.out.println("我是人类中的学生");
    }
}



public class Child extends Person{   //继承父类，相当于我们是孩子，有孩子的行为
    @Override
    public void speak(){

        System.out.println("我是人类中的孩子");
    }
}




//测试类
public class TestMain {
    public static void main(String[] args) {

		//父类类型 变量名=new 子类类型();
        Person p = new Student();   //子类对象的引用赋值给父类 
        p.speak(); //多态 相当于这里使用的是Student的方法。输出我是人类中的学生
        //我作为人，我用学生的身份，说出：我是人类中的学生


		Person p = new Child(); 
		p.speak();  //输出：我是人类中的孩子
		//我作为人，用孩子的身份，说出我是人类中的孩子

    }
}

//这段代码，我们用到了 继承，重写，向上转型，因为多态本来就是向上转型的过程

多态的作用：

介绍完多态，讲讲多态有什么用呢？为什么多态可以作为Java的三大特性。肯定是有原因的：

• 提高代码的可重用性
• 降低模块之间的耦合度

这里给大家介绍一下什么是多态机制？Java语言是如何实现多态的？（可能有点难以理解，本人对于该内容也没用理解充分，但这也是面试会考的题）

所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并 不确定，而是在程序运行期间才确定，即一个引用变量倒 底会指向哪个类的实例对象，该引用变量发出 的方法调用到底是哪个类中实现的 方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具 体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而 导致该引用 调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时 所绑定的具体代码，让程序可以选 择多个运行状态，这就是多态性。 多态分为编译时多态和运行时多态。其中编辑时多态是静态的，主要 是指方法的 重载，它是根据参数列表的不同来区分不同的函数，通过编辑之后会变成两个不 同的函数， 在运行时谈不上多态。而运行时多态是动态的，它是通过动态绑定来 实现的，也就是我们所说的多态性。

对于多态的理解，还可以参考一段代码：

class People{     //父类
    public void eat(){
        System.out.println("我们会吃饭");
    }
}


class Student extends People{  //继承父类
    @Override
    public void eat(){
        System.out.println("我会吃肉");
    }
    public void study(){
        System.out.println("我们要好好学习");
    }
}


class Teacher extends People{     //继承父类
    @Override
    public void eat(){
        System.out.println("老师会吃蔬菜");
    }
    public void teach(){
        System.out.println("老师要认真上课");
    }
}

//测试类：
public class TestMain {
    public static void main(String[] args) {
        People p=new Stu();      //子类对象的引用赋值给父类 
        p.eat();       //输出： 我会吃肉
    }
}

抽象类：

什么是抽象类？

普通类是一个完善的功能类，可以直接产生实例化对象，并且在普通类中可以包含有构造方法、普通方法、static方法、常量和变量等内容。而抽象类是指在普通类的结构里面增加抽象方法的组成部分。

抽象方法：

在所有的普通方法上面都会有一个“{}”，这个表示方法体，有方法体的方法一定可以被对象直接使用。而抽象方法，是指没有方法体的方法，同时抽象方法还必须使用关键字abstract做修饰。也就是说，抽象类里面的抽象方法，可以不写，在被继承后，再重写。

抽象类声明关键字：abstracat

定义一个抽象类：

public abstract class studnet{//定义一个抽象类
	
	public void study(){                         //普通方法
		System.out.println("我会学习");
	}
	
	public abstract void eat();         //抽象方法，没有方法体，有abstract关键字做修饰
	
}

//注意： 有抽象方法，这个类必须是抽象的！！！

举例解释：

形状类Shape需要提供用于计算面积和周长的方法，但是形状本身没有被确定，那么计算周长和面积的方法就无法确定，此时我们就需要使用抽象类和抽象方法。

由于Shape类计算周长和面积的方法无法确定，那么就可以将这样的方法声明为抽象的，以便在具体的子类中进行实现。

//定义一个shape类，但是没有具体的形状，所以我们定义成抽象类
public abstract class Shape {
    
    private int a;
    public abstract void area(){}     //求面积的方法
    public abstract void perimeter();   //求周长的方法

    public Shape() {    //无参构造
    }

    public Shape(int a) {
        this.a = a;
    }
}

//计算圆形面积的子类

public  abstract class shape {    //有抽象方法的类，则一定是抽象类，需要关键字abstract修饰

        private int a;
        public abstract void area();     //求面积的方法，没有方法体的方法，需要关键字abstract修饰
        public abstract void perimeter();   //求周长的方法
}


//创建计算圆面积和周长的子类，并继承抽象类shape,并重写shape内的方法
public class Circle extends shape{

    public static double pi = 3.14;
    private double r;  //半径


    @Override
    public void area() {
        System.out.println("圆的面积："+Circle.pi*this.r*this.r);
    }

    @Override
    public void perimeter() {
        System.out.println("圆的周长为："+2*Circle.pi*this.r);
    }

    public Circle() {
    }

    public Circle(double r) {  //
        this.r = r;
    }

}


//测试类：
public class TestMain {
    public static void main(String[] args) {
        Circle c = new Circle(5);        //传入半径为：5
        c.area();
        c.perimeter();

    }

}

//输出结果： 圆的面积：78.5
// 圆的周长为：31.400000000000002

抽象方法和抽象类的注意事项：

• 抽象类中是可以有构造函数的，并且构造函数的写法和其它类没有区别，只不过它真正跑起来是因为子类构造函数的super调用，毕竟我们没办法new一个抽象类对象出来，只能把抽象类的构造函数交给子类的构造函数去使用。
• 抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类。
• 抽象类的子类，必须重写父类中所有的抽象方法，如果有一个抽象方法没有重写，都会出现编译错误不给过，这时也可以把子类也声明为抽象类，报错就会消失。

简洁总结：

• 抽象方法：没有方法体的方法，需要关键字abstract修饰
• 有抽象方法的类，则一定是抽象类，需要关键字abstract修饰
• 抽象方法不能使用private和static修饰
• 抽象类,不一定有抽象方法的类
• 抽象类,不一定有抽象方法的类
• 抽象类可以有构造函数

普通类和抽象类有哪些区别？

• 普通类不能包含抽象方法，抽象类可以包含抽象方法
• 抽象类不能直接实例化，普通类可以直接实例化。

到此这篇关于Java十分钟精通多态与抽象类的使用与原理的文章就介绍到这了,更多相关Java 多态 内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！