一起来了解Java的态和抽象类

目录
  • 多态:
  • 抽象类:
  • 总结

多态:

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

什么是多态?

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

Java中多态的含义:

1.发送消息给某个对象,让这个对象自行决定采用哪种行为响应这个消息

2.子类对象的引用赋值给父类引用变量来实现动态的方法调用

Java中形成多态的前提:

1.继承

2.父类方法的重写

3.向上转型

我对多态的解释:

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

注意:

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

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

多态的定义与使用格式:

父类类型 变量名=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修饰
  • 抽象类,不一定有抽象方法的类
  • 抽象类,不一定有抽象方法的类
  • 抽象类可以有构造函数

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

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

总结

本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注我们的更多内容!

(0)

相关推荐

  • Java语法之 Java 的多态、抽象类和接口

    目录 一.多态 1. 向上转型 2. 动态绑定 3. 方法重写 4. 向下转型 5. 关键字 super 6. 在构造方法中调用重写方法(坑) 7. 理解多态 8. 小结 二.抽象类 1. 概念 2. 注意事项 3. 抽象类的意义 3. 抽象类的作用 三.接口 1. 语法规则 2. 实现多个接口 3. 接口的继承 4. Comparable 接口 4. Comparator 接口 5. Cloneable 接口和深拷贝 上一篇文章:Java 基础语法之解析 Java 的包和继承 今天这章主要介绍

  • java 方法重写与权限修饰符以及多态和抽象类详解概念和用法

    1.方法重写 子类写和父类一样的方法定义 public void call(){ System.out.println("输出文字"); //父类的方法 } public void call(){ System.out.println("helloworld"); } //子类的方法 重写父类方法时,容易写错名字怎么办? 加个@Override 注解 如果报错,说明重写父类方法时,写错了 @Override: @Override public void call()

  • java 多态与抽象类详解总结

    目录 前言 多态 初识多态 什么是多态? 多态的分类 多态的必要条件 实现多态 向上转型 向下转型 instanceof运算符 具体实现 抽象类与抽象方法 为什么要使用抽象? 抽象方法 抽象类 前言 今天是2021LOL全球总决赛,一直不被大家看好的EDG冲到了决赛对战韩国队的DK,可以说EDG面对如此强大的对手,想赢是比较难的,为了给中国队打气我立下flag,如果EDG获胜那我就奖励自己学习到第二天6点,结果我就来了,,,恭喜EDG! 为了接下来接口的学习,我们先来学习多态与抽类相关的一些知识

  • Java抽象类、继承及多态和适配器的实现代码

    Java继承 方法重写是Java语言多态的特性,必须满足以下条件 在子类中,方法名称与父类方法名称完全相同 方法的参数个数和类型完全相同,返回类型完全相同 方法的访问修饰符访问级别不低于父类同名方法的访问级别 在方法上添加@override注释,如果报错说明不是重写 方法重写限制 final修饰的父类方法在子类中不能被重写 static修饰的父类方法在子类中不能被重写,只能覆盖 super关键字 super关键字和this类似,super修饰的是父类的对象,如super();调用的是父类的默认无

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

    我们知道Java的三大特性:封装.继承.多态.前两个之前在Java入门(六)已经讲到,现在来讲多态这个特性. 什么是多态? 多态顾名思义即为多种形态的意思 Java中多态的含义: 发送消息给某个对象,让这个对象自行决定采用哪种行为响应这个消息 子类对象的引用赋值给父类引用变量来实现动态的方法调用 Java中形成多态的前提: 继承 父类方法的重写 向上转型 我对多态的解释: 比如我们,是人,也是学生,也是年轻人,我可以用人的身份去做事情,也可以用学生的身份去买学生票,也可以用年轻人的身份做公益,这

  • Java多态性抽象类与接口细致详解

    目录 1.多态性 1.1 向上转型 1.2 向下转型 2.抽象类 2.1 抽象类的基本概念 3.接口 3.1 接口的基本概念 3.2 接口的使用限制 3.3 使用接口定义标准 3.4 抽象类与接口的区别 1.多态性 多态性是面向对象的最后一个特征,它本身主要分为两个方面: ​ 方法的多态性:重载与覆写 ​ 1 重载:同一个方法名称,根据参数类型以及个数完成不同功能: ​ 2 覆写:通一个方法,根据操作的子类不同,所完成的功能也不同. ​ 对象的多态性:父子类对象的转换. ​ 1 向上转型:子类对

  • 一起来了解Java的态和抽象类

    目录 多态: 抽象类: 总结 多态: 我们知道Java的三大特性:封装.继承.多态.前两个之前在Java入门(六)已经讲到,现在来讲多态这个特性. 什么是多态? 多态顾名思义即为多种形态的意思 Java中多态的含义: 1.发送消息给某个对象,让这个对象自行决定采用哪种行为响应这个消息 2.子类对象的引用赋值给父类引用变量来实现动态的方法调用 Java中形成多态的前提: 1.继承 2.父类方法的重写 3.向上转型 我对多态的解释: 比如我们,是人,也是学生,也是年轻人,我可以用人的身份去做事情,也

  • java 中接口和抽象类的区别与对比

    java 中接口和抽象类的区别与对比 接口和抽象类的概念不一样. 接口是对动作的抽象,抽象类是对根源的抽象. 抽象类表示的是,这个对象是什么.接口表示的是,这个对象能做什么.比如,男人,女人,这两个类(如果是类的话--),他们的抽象类是人.说明,他们都是人. 人可以吃东西,狗也可以吃东西,你可以把"吃东西"定义成一个接口,然后让这些类去实现它. 所以,在高级语言上,一个类只能继承一个类(抽象类)(正如人不可能同时是生物和非生物),但是可以实现多个接口(吃饭接口.走路接口). 第一点:接

  • Java的接口和抽象类深入理解

    Java的接口和抽象类深入理解 对于面向对象编程来说,抽象是它的一大特征之一.在Java中,可以通过两种形式来体现OOP的抽象:接口和抽象类.这两者有太多相似的地方,又有太多不同的地方.很多人在初学的时候会以为它们可以随意互换使用,但是实际则不然.今天我们就一起来学习一下Java中的接口和抽象类. 一.抽象类 在了解抽象类之前,先来了解一下抽象方法.抽象方法是一种特殊的方法:它只有声明,而没有具体的实现.抽象方法的声明格式为: abstract void fun(); 抽象方法必须用abstra

  • 深入理解Java的接口与抽象类

    对于面向对象编程来说,抽象是它的一大特征之一.在Java中,可以通过两种形式来体现OOP的抽象:接口和抽象类.这两者有太多相似的地方,又有太多不同的地方.很多人在初学的时候会以为它们可以随意互换使用,但是实际则不然.今天我们就一起来学习一下Java中的接口和抽象类.下面是本文的目录大纲: 一.抽象类 二.接口 三.抽象类和接口的区别 一.抽象类 在了解抽象类之前,先来了解一下抽象方法.抽象方法是一种特殊的方法:它只有声明,而没有具体的实现.抽象方法的声明格式为: abstract void fu

  • 详解java中接口与抽象类的区别

    详解java中接口与抽象类的区别 1.abstract class 在 Java 语言中表示的是一种继承关系,一个类只能使用一次继承关系.但是,一个类却可以实现多个interface. 2.在abstract class 中可以有自己的数据成员,也可以有非abstarct的成员方法,而在interface中,只能够有静态的不能被修改的数据成员(也就是必须是static final的,不过在 interface中一般不定义数据成员),所有的成员方法都是abstract的. 3.abstract c

  • Java的抽象方法和抽象类实例详解

    本文实例讲述了Java的抽象方法和抽象类.分享给大家供大家参考,具体如下: 一 点睛 抽象方法是只有方法签名,没有方法实现的方法. 抽象方法和抽象类必须使用abstract修饰符来定义,有抽象方法的类只能被定义为抽象类,抽象类里可以没有抽象方法. 抽象类和抽象方法的规则: 抽象类必须使用abstract修饰符来修饰,抽象方法必须使用abstract修饰符来修饰,抽象方法不能有方法体. 抽象类不定被实例化.即使抽象类里不包含抽象方法,这个抽象类也不能创建实例. 抽象类可以包含成员变量.方法(普通方

  • 浅谈java IO流——四大抽象类

    IO所谓的四大抽象类就是: InputStream.OutputStream.Reader.Writer InputStream:字节输入流的父类,数据单位为字节. 常用方法: int read();    从输入流中读取下一个字节 void close();   关闭流  OutputStream:字节输出流的父类,数据单位为字节. 常用方法: void write(int b);  将一个integer数组长度写入此流  void flush();   刷新此流  void close();

  • Java中接口和抽象类的区别详解

    需求:接口是否可继承接口?抽象类是否可实现(implements)接口?抽象类是否可继承实体类(concrete class)?抽象类中是否可以有静态的main方法? 先说明二者的定义,然后聊聊需求,最后分析二者的区别. 含有abstract修饰符的类即为抽象类,抽象类不能创建实例对象.含有抽象方法的类必须定义为abstract class.在abstract class中,方法不必是抽象的,但是抽象方法必须在具体子类中实现,所以,不能有抽象构造方法或抽象静态方法.子类如果没有实现抽象父类中的所

  • 浅析Java中接口和抽象类的七大区别

    目录 接口 抽象类 区别1:定义关键字不同 区别2:继承或实现的关键字不同 区别3:子类扩展的数量不同 区别4:属性访问控制符不同 区别5:方法控制符不同 区别6:方法实现不同 区别7:静态代码块使用不同 总结 Java 是一门面向对象的编程语言,面向对象的编程语言有四大特征:抽象.封装.继承和多态. 而本文介绍的接口和抽象类就是面向对象编程中"抽象"的具体实现,也就是说接口和抽象类都是用来定义实体类的公共行为的,它们是对实体类(对象)更高层次的抽象. ​说明:本文以下内容基于 JDK

随机推荐