Java的态和抽象类是什么

多态:

我们知道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修饰

  • 抽象类,不一定有抽象方法的类

  • 抽象类,不一定有抽象方法的类

  • 抽象类可以有构造函数

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

  • 普通类不能包含抽象方法,抽象类可以包含抽象方法

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



Java是一种编程语言,它拥有多种属性和方法,其中包括了“态”和“抽象类”。这些概念在Java程序设计中扮演着非常重要的角色。在本文中,我们将讨论Java中的态和抽象类是什么,并为您提供一些实际用例和示例代码。
一、Java中的态是什么?
在计算机编程中,“态”通常指的是一个对象的属性或状态。它表示对象当前所处的状态,以及该状态下该对象的可用方法。换句话说,一个对象的态是它所处的环境和上下文的总和。
在Java中,一个类的态可以通过Java类的普通属性来表示。这些属性包括常量、变量和其他数据类型。您可以通过在类中定义这些属性来表示对象的不同状态。以下是一个示例代码,演示如何使用Java属性来表示对象的状态:
public class Car {
private int speed; // 当前速度
private int gear; // 当前档位
private boolean isRunning; // 是否在运行
public void start() {
isRunning = true;
gear = 1;
speed = 0;
}
public void stop() {
isRunning = false;
gear = 0;
speed = 0;
}
public void accelerate(int increment) {
if (isRunning) {
speed += increment;
}
}
}
在上面的代码中,Car类包含了一个speed属性,可用于表示车辆的当前速度,一个gear属性,用于表示当前车辆档位,还有一个isRunning属性,表示车辆的运行状态。这些属性可以在类中的不同方法中更新和使用,以更新车辆的状态。
二、Java中的抽象类是什么?
在Java程序设计中,抽象类是一种特殊的类,用于定义对象的基本特征,但不能用于直接创建对象。抽象类可以通过继承来创建子类,并使用这些子类创建对象。
抽象类通常用于定义接口和方法,不提供具体实现。这意味着,您可以定义一个抽象类,其中包含一些只是在子类中实现的方法。它们相当于接口,为程序提供框架,而不提供具体实现。
下面是一个抽象类的示例代码:
abstract class Animal {
public abstract void eat(); // 抽象方法
public void run() { // 具体方法
System.out.println(\"Animal is running\");
}
}
在上面的代码中,Animal是一个抽象类,它包含了一个抽象方法eat(),没有提供具体实现。它还包含一个具体方法run(),它提供了Animal类的基本实现。可以通过继承Animal来创建子类,并实现eat()方法。
public class Dog extends Animal {
@Override
public void eat() {
System.out.println(\"Dog is eating meat\");
}
}
在上面的代码中,Dog继承了Animal类,并实现了eat()方法。Dog还可以继承run()方法的实现,因为它是一个具体方法。
三、Java中的态和抽象类如何相互作用?
Java中的态和抽象类经常一起使用,以提高程序的结构和可读性。使用态可以轻松地更新和查询对象的状态,而使用抽象类可以在子类中提供具体的实现。
例如,考虑一个动物园的场景。动物园中会有不同类型(种类)的动物,例如狮子、老虎、大象等。每只动物又会有它们自己的属性和方法,例如获取动物的体重、颜色、饮食偏好等。
在这种情况下,可以使用抽象类Animal来表示不同种类的动物,每种动物都是Animal的子类。Animal抽象类可以提供一组公共的方法和属性,例如getName()、getColor()等方法来获取动物的基本特征。不同的子类(例如Lion、Tiger、Elephant)可以提供它们自己的实现,例如getWeight()、getFoodPreference()等方法。
同时,可以使用态来表示动物的当前状态。例如,一个Lion对象可能具有属性(态)speed和distance,用于表示狮子当前奔跑的速度和距离。该对象可以通过抽象类Animal来创建,并继承其他共同的方法和属性。
总结
在Java程序设计中,态和抽象类是非常有用的概念。态可以用于表示对象的属性和状态,抽象类可以用于定义接口和方法,并提供一个框架,为程序提供一个结构。通过结合使用这两个概念,可以创建更加合理,具有结构性的Java程序。