Java中的abstract方法和abstract类的问题

abstract在java中用法(一)Abstract在Java中在Java中，abstract是一个关键字，用于定义抽象类和抽象方法。

抽象类是一种特殊的类，不能被实例化，只能用作其他类的基类。

抽象方法是一种没有具体实现的方法，只有方法声明，没有方法体。

下面将详细讲解abstract在Java中的用法。

抽象类抽象类是一种用abstract关键字修饰的类。

它不能被实例化，只能作为父类被继承。

抽象类的主要作用是定义子类需要实现的一组方法，子类必须实现这些方法才能被实例化。

定义抽象类的语法如下：abstract class AbstractClass {// 抽象方法public abstract void abstractMethod();// 普通方法public void normalMethod() {// 方法实现}}抽象类可以包含抽象方法和普通方法。

抽象方法用abstract关键字修饰，没有方法体；普通方法有方法体。

抽象类可以包含普通成员变量和静态成员变量，也可以包含普通方法和静态方法。

但是不能创建抽象类的实例。

抽象方法抽象方法是一种没有具体实现的方法，只有方法声明。

抽象方法用abstract关键字修饰，没有方法体。

抽象方法必须在抽象类中声明，子类必须实现这些抽象方法才能被实例化。

定义抽象方法的语法如下：abstract void abstractMethod();抽象方法也可以包含参数和返回值，用于定义子类必须实现的方法签名。

子类继承抽象类后，必须实现抽象方法，否则子类也必须声明为抽象类。

继承抽象类子类继承抽象类后，必须实现抽象类中的所有抽象方法才能被实例化。

子类可以通过覆盖抽象方法来实现具体的功能。

如果子类不想实现某个抽象方法，那么子类也必须声明为抽象类。

继承抽象类的语法如下：class ConcreteClass extends AbstractClass {// 实现抽象方法public void abstractMethod() {// 方法实现}// 覆盖普通方法public void normalMethod() {// 方法实现}}注意，如果一个类继承了抽象类，但没有实现抽象方法，则该类必须声明为抽象类。

抽象类和抽象方法一、定义：java中可以定义的一些不含方法体的方法，它的方法体的实现交给该类的子类根据自己的情况去实现，这就是抽象方法。

包含抽象方法的类就叫做抽象类。

一个抽象类可以有一个或多个抽象方法。

二、抽象规则：1、抽象类和方法必须用abstract来修饰；2、抽象类不能被实例化；3、抽象方法只需声明，无需实现，抽象方法一定调用子类重写后的非抽象的方法；4、抽象类有构造但不能被调用；5、含有抽象方法的类必须声明为抽象类，抽象类的子类必须覆盖所有的抽象方法后才能被实例化，否则这个类还是个抽象类。

注意：抽象方法不能为private的，因为抽象方法没有具体实现，需要在子类中继承并重写来实现具体实现。

抽象方法必须重写实现其具体的功能。

【TestAbstract.java】package day7am;public abstract class TestAbstract {public abstract void test();//含有抽象方法的类一定是抽象类。

public static void main(String[] args) {}}三、抽象方法的继承与实现当某类继承抽象类时，如果其本身不是抽象类时，则必须实现所继承抽象类中的抽象方法。

如，具有启动(startup)方法的抽象车辆类Car，其每中子类都必须实现其自己的、专属于某种类型车辆的具体启动(startup)方法,下边例子就说明了。

【TestAbstract.java】package Pra;//定义抽象类Carabstract class Car{//定义抽象方法startUppublic abstract void startUp();}//定义抽象类Audi并使该类继承自Carabstract class Audi extends Car{//定义抽象方法turbopublic abstract void turbo();}//定义非抽象类Audi_A6继承自Audiclass Audi_A6 extends Audi{//实现startUp方法public void startUp(){System.out.println("调用了奥迪A6的启动功能！！！");}//实现turbo方法public void turbo(){System.out.println("调用了奥迪A6的加速功能！！！");}}//定义非抽象类Audi_A8继承自Audiclass Audi_A8 extends Audi{//实现startUp方法public void startUp(){System.out.println("调用了奥迪A8的启动功能！！！");}//实现turbo方法public void turbo(){System.out.println("调用了奥迪A8的加速功能！！！");}}public class TestAbstract{public static void main(String[] args){//创建Audi_A6对象并使该类引用a6指向该对象Audi_A6 a6=new Audi_A6();//调用Audi_A6对象中的方法a6.startUp();a6.turbo();//创建Audi_A8对象并使该类引用a8指向该对象Audi_A8 a8=new Audi_A8();//调用Audi_A8对象中的方法a8.startUp();a8.turbo();}}程序运行结果：-----------------------------调用了奥迪A6的启动功能！！！调用了奥迪A6的加速功能！！！调用了奥迪A8的启动功能！！！调用了奥迪A8的加速功能！！！-----------------------------上面的例子里定义了4个类，其中Car和Audi为抽象类，他们分别代表轿车和奥迪轿车，故不适具体类，因为轿车和奥迪轿车还有很多子类。

Java Abstract方法继承一、什么是Abstract方法Abstract方法是Java中一种特殊的方法，它只有声明而没有具体的实现。

在定义一个Abstract方法时，需要使用abstract关键字修饰方法，并且该方法所在的类必须是抽象类或者接口。

Abstract方法的定义如下：public abstract void methodName();二、抽象类与接口抽象类（Abstract Class）是一个不能被实例化的类，它可以包含Abstract方法和具体的方法实现。

抽象类通过使用abstract关键字进行修饰。

接口（Interface）是一种纯抽象的类，它只包含Abstract方法和常量。

接口定义方法时，默认使用public abstract修饰。

抽象类和接口的区别如下： - 抽象类可以有构造方法，而接口不能有构造方法。

- 类只能继承一个抽象类，但可以实现多个接口。

- 抽象类可以有成员变量，而接口只能有常量。

- 接口中的方法默认是public的，而抽象类中的方法可以有不同的访问修饰符。

三、Abstract方法的继承方式Abstract方法在继承关系中有以下几种继承方式：子类覆盖方法、子类重载方法、子类继续声明抽象方法。

1. 子类覆盖方法当一个子类继承自一个抽象类或者实现一个接口时，它必须实现抽象类或接口中的所有Abstract方法。

子类通过覆盖Abstract方法来提供具体的实现。

例如，有一个抽象类Animal，其中定义了一个Abstract方法eat()，如下所示：public abstract void eat();}如果一个子类Dog继承自Animal，则必须实现eat()方法：public class Dog extends Animal {@Overridepublic void eat() {System.out.println("狗吃骨头");}}2. 子类重载方法除了覆盖Abstract方法，子类还可以重载Abstract方法。

java中abstract怎么使⽤abstract（抽象）修饰符，可以修饰类和⽅法1，abstract修饰类，会使这个类成为⼀个抽象类，这个类将不能⽣成对象实例，但可以做为对象变量声明的类型，也就是编译时类型，抽象类就像当于⼀类的半成品，需要⼦类继承并覆盖其中的抽象⽅法。

2，abstract修饰⽅法，会使这个⽅法变成抽象⽅法，也就是只有声明（定义）⽽没有实现，实现部分以"；"代替。

需要⼦类继承实现（覆盖）。

注意：有抽象⽅法的类⼀定是抽象类。

但是抽象类中不⼀定都是抽象⽅法，也可以全是具体⽅法。

abstract修饰符在修饰类时必须放在类名前。

abstract修饰⽅法就是要求其⼦类覆盖（实现）这个⽅法。

调⽤时可以以多态⽅式调⽤⼦类覆盖（实现）后的⽅法，也就是说抽象⽅法必须在其⼦类中实现，除⾮⼦类本⾝也是抽象类。

注意：⽗类是抽象类，其中有抽象⽅法，那么⼦类继承⽗类，并把⽗类中的所有抽象⽅法都实现（覆盖）了，⼦类才有创建对象的实例的能⼒，否则⼦类也必须是抽象类。

抽象类中可以有构造⽅法，是⼦类在构造⼦类对象时需要调⽤的⽗类（抽象类）的构造⽅法。

举个简单的例⼦下⾯有⼀个抽象类abstract class E{public abstract void show();//public abstract 可以省略}然后其它类如果继承它通常为了实现它⾥⾯的⽅法class F extends E{void show(){//写具体实现的代码}}最后再主⽅法⾥⾯定义⼀个⽗类引⽤指向⼦类对象,就会发⽣多态现象,⽐如E e=new F();e.show();实际调⽤了⼦类⾥⾯的show()⽅法。

Java抽象类、抽象⽅法详解⽬录1. 概述类⽤于描述现实⽣活中⼀类事物。

类中有属性、⽅法等成员。

⽗类中的⽅法，被它的⼦类们重写，⼦类各⾃的实现都不尽相同。

那么⽗类的⽅法声明和⽅法主体，只有声明还有意义，⽽⽅法主体则没有存在的意义了。

某种情况下，⽗类只能知道⼦类应该具备⼀个怎样的⽅法，但是不能够明确知道如何实现该⽅法。

只能在⼦类中才能确定如何去实现⽅法体。

例如：所有⼏何图形都应该具备⼀个计算⾯积的⽅法。

但是不同的⼏何图形计算⾯积的⽅式不同。

我们把没有⽅法主体的⽅法称为抽象⽅法。

Java语法规定，包含抽象⽅法的类就是抽象类。

2. 抽象⽅法抽象⽅法：只有⽅法的声明，没有⽅法体，以分号 ; 结尾，使⽤abstract关键字修饰定义格式：修饰符 abstract 返回值类型⽅法名(参数列表);代码举例：public abstract void run();抽象⽅法不能⽤private、final、static、native修饰3. 抽象类抽象类：包含抽象⽅法的类。

如果⼀个类包含抽象⽅法，那么该类必须是抽象类，使⽤abstract关键字修饰定义格式：public abstract class 类名 {//抽象类中可以包含变量、常量，抽象⽅法，⾮抽象⽅法}代码举例：public abstract class Person {public abstract void work()；}抽象类的使⽤抽象类不能实例化，不能直接创建对象。

抽象类是⽤来被继承的，继承抽象类的⼦类必须重写⽗类所有的抽象⽅法。

否则，该⼦类也必须声明为抽象类，使⽤abstract关键字修饰抽象类也是类，因此原来类中可以有的成员，抽象类都可以有，那么抽象类不能直接创建对象，为什么还有构造器呢？供⼦类调⽤，⼦类创建对象时，需要为从⽗类继承的属性初始化。

抽象类不能使⽤final修饰public class Teacher extends Person {public void work() {System.out.println("讲课");}}public class AbstractClassTest {public static void main(String[] args) {// 创建⼦类对象Teacher t = new Teacher();// 调⽤run⽅法t.work();}}输出结果：讲课此时的⽅法重写，是⼦类对⽗类抽象⽅法的完成实现，我们将这种⽅法重写的操作，叫做实现⽅法。

抽象方法必须在抽象类中吗抽象方法是一种没有实现的方法，它只有方法的声明而没有方法的具体实现。

在Java中，抽象方法必须在抽象类中声明。

这是因为抽象类是一种不能创建对象的类，它的主要作用是给它的子类提供一种方法的约束，要求子类必须实现抽象类中的抽象方法。

首先，一个抽象方法的存在就意味着它需要被子类实现。

而抽象类是作为子类的父类存在的，它定义了子类需要实现的方法。

如果抽象方法不是在抽象类中定义，那么它将无法被子类重写和实现，失去了抽象方法的目的和意义。

其次，抽象类本身是不能被实例化的。

抽象类是一种功能不完整、不具体的类，只有具体的子类才能被实例化。

在Java中，如果一个类中包含了抽象方法，那么这个类必须声明为抽象类。

抽象类不能直接实例化，它只能被继承，然后由子类实现其中的抽象方法。

另外，抽象类还可以包含非抽象方法。

非抽象方法是有方法体的方法，它可以在抽象类中直接实现，也可以在抽象类的具体子类中重写。

非抽象方法是抽象类的一部分，它们和抽象方法一起构成了抽象类的特征和能力。

通过上述的解释，我们可以看出抽象方法必须在抽象类中声明是有其合理性和必要性的。

抽象方法的存在使得抽象类成为了一种约束和模板，它给予了子类必须实现的方法规范。

抽象类作为一种模板和约束，它可以定义并实现一些通用的方法，而将具体的实现交给子类来完成。

这样做的好处是可以有效地避免代码的重复和冗余，提高代码的复用性和可维护性。

此外，抽象类还可以通过构造器继承或实例化子类对象。

子类继承抽象类可以获得父类中的方法和变量，并且必须实现父类中的抽象方法。

抽象类也可以通过抽象类的引用变量实例化子类对象。

这种方式可以实现面向抽象编程，提高代码的灵活性和可扩展性。

总结来说，抽象方法必须在抽象类中声明。

抽象类是一种不能被实例化的类，它的主要作用是给子类一种方法的约束，要求子类必须实现抽象类中的抽象方法。

抽象方法的存在使得抽象类具有模板和约束的功能，提高了代码的复用性和可维护性。

Java抽象类详解 在中，介绍了抽象⽅法与接⼝，以及做了简单的⽐较。

这⾥我想详细探讨下抽象类。

⼀、抽象类的定义 被关键字“abstract”修饰的类，为抽象类。

（⽽且，abxtract只能修饰类和⽅法） 下⾯显⽰了⼀个最简单的空抽象类public abstract class AbstractClass {public static void main(String[] args) {AbstractClass abstractClass=new AbstractClass();}} 当对这个空的抽象类进⾏实例化时，编译器会报错： 'AbstractClass' is abstract; cannot be instantiated' 现在对这个抽象类进⾏扩展，添加属性和⽅法：public abstract class AbstractClass {public int constInt = 5;/*重载method()*/public void method() { }//没有编译错误public abstract void method(int a);public static void main(String[] args) {AbstractClass abstractClass=new AbstractClass() {@Overridepublic void method(int a) {System.out.println("实例化抽象类");}};System.out.println(abstractClass.constInt);abstractClass.method(5);}}//运⾏结果/* 5 实例化抽象类*/ 在这个抽象类中我添加了⼀个实例属性，⼀个抽象⽅法，以及该抽象⽅法的重载实例⽅法，这些都是合法的。

在main⽅法中，直接对抽象类通过new操作符进⾏实例化，出乎意料的是，IDE直接提⽰了这种操作——这⾥⽣成了⼀个（Anonymous Inner）。

public abstract方法public abstract方法是面向对象编程中的一种方法，它具有特殊的功能和用途。

在本文中，我将详细介绍public abstract方法的定义、特点和使用场景。

我们来了解一下public abstract方法的定义。

在Java编程语言中，public abstract方法是一种特殊的方法，它具有以下特点：那么，为什么需要public abstract方法呢？public abstract方法的主要作用是定义一种方法的接口规范，而不关心具体的实现。

通过声明public abstract方法，可以使得子类或者实现类必须实现这些方法，以达到统一的接口规范。

在使用public abstract方法时，需要注意以下几点。

首先，public abstract方法不能有方法体，即不能包含具体的实现代码。

其次，public abstract方法必须被子类或者实现类重写或实现，否则会导致编译错误。

此外，如果一个类继承了抽象类，那么它必须实现所有的public abstract方法，否则仍然会导致编译错误。

public abstract方法的使用场景非常广泛。

首先，它可以用于定义接口。

接口是一种纯粹的抽象类型，其中所有的方法都是public abstract方法。

通过接口，可以定义一种规范，任何实现该接口的类都必须实现接口中定义的所有方法。

这样，可以达到一种面向接口编程的设计思想，提高代码的可扩展性和可维护性。

public abstract方法也可以用于定义抽象类。

抽象类是一种不能被实例化的类，其中可以包含具体的实现代码和public abstract方法。

通过抽象类，可以定义一些通用的方法，而将具体的实现交给子类去完成。

这样，可以实现代码的复用和扩展。

public abstract方法还可以用于回调函数的定义。

回调函数是一种常用的设计模式，通过定义public abstract方法，可以在某个事件发生时回调该方法，以实现特定的功能。

1、Java中用于定义接口的关键字是（）A、importB、packageC、classD、interface2、以下关于abstract的说法，正确的是( )A、abstract只能修饰类B、abstract只能修饰方法C、abstract类中必须有abstract方法D、abstarct方法所在的类必须用abstract修饰3、下列哪种说法是正确的（）A、私有方法不能被子类覆盖。

B、子类可以覆盖超类中的任何方法。

C、覆盖方法可以声明自己抛出的异常多于那个被覆盖的方法。

D、覆盖方法中的参数清单必须是被覆盖方法参数清单的子集。

4、关于类继承的说法，正确的是（）A、Java 类允许多重继承B、Java接口允许多继承C、接口和类都允许多继承D、接口和类都不允许多继承5、关于抽象类，正确的是______。

A. 抽象类中不可以有非抽象方法B. 某个非抽象类的父类是抽象类，则这个子类必须重载父类的所有抽象方法C. 不能用抽象类去创建对象D. 接口和抽象类是同一个概念6、下列哪个类是由编译器自动生成对象的特殊类，是用于类操作？（）A、Class类B、Thread类C、System类D、Object类7、下面关于继承的哪些叙述是正确的。

( )A、在java中只允许单一继承。

B、在java中一个类只能实现一个接口。

C、在java中一个类不能同时继承一个类和实现一个接口。

D、java的单一继承使代码更可靠。

8、抽象类A和抽象类B的定义如下：abstract class ex4_5_10_A {abstract int getinfo();}public class ex4_5_10 extends ex4_5_10_A {private int a = 0;public int getinfo() {return a;}public static void main(String args[]) {ex4_5_10 b = new ex4_5_10();System.out.println(b.getinfo());}}关于上述代码说明正确的是（）。

abstract类的特点
abstract类是一种特殊的类，它具有以下特点：
1. abstract类不能被实例化，即不能创建abstract类的对象。

只能通过继承abstract类来创建子类对象。

2. abstract类可以包含抽象方法和非抽象方法。

抽象方法是没有具体实现的方法，只有方法的声明，没有方法体。

非抽象方法是有具体实现的方法。

3. 子类继承abstract类时，必须实现所有的抽象方法。

如果子类没有实现所有的抽象方法，那么子类也必须被声明为abstract类。

4. abstract类可以有构造方法，用于初始化abstract类的成员变量。

5. abstract类可以有成员变量和成员方法，这些成员变量和成员方法可以被子类继承和访问。

6. abstract类可以被其他类继承，同样可以继承其他类。

abstract类的特点是不能被实例化，包含抽象方法和非抽象方法，子类必须实现所有的抽象方法。

abstract类可以作为其他类的父类，提供基础的实现和接口。

接口方法abstract
接口（interface）是一种抽象数据类型，它定义了一组方法（method）的规范，但没有提供方法的具体实现。

接口可以作为一种契约，规定了类应该提供哪些方法，而不关心方法是如何实现的。

方法（method）是一段执行特定任务的代码。

在面向对象编程中，方法是定义在类（class）中的，用于操作类的实例对象或其它类成员。

方法可以定义在接口中，也可以定义在类中。

抽象（abstract）是一种特殊的类或方法的修饰符，表示该类或方法不能被实例化或调用。

抽象类（abstract class）是一个不能被实例化的类，它提供了一组抽象方法的定义，子类必须实现这些方法。

抽象方法（abstract method）是一个没有实现体的方法，它只能存在于抽象类或接口中。

抽象方法必须被子类实现或在实现接口的类中提供具体实现。

Java之关键字abstract（抽象类与抽象⽅法）/** abstract关键字的使⽤* 1.abstract:抽象的* 2.abstract可以⽤来修饰的结构：类、⽅法** 3. abstract修饰类：抽象类* > 此类不能实例化* > 抽象类中⼀定有构造器，便于⼦类实例化时调⽤（涉及：⼦类对象实例化的全过程）* > 开发中，都会提供抽象类的⼦类，让⼦类对象实例化，完成相关的操作*** 4. abstract修饰⽅法：抽象⽅法* > 抽象⽅法只有⽅法的声明，没有⽅法体* > 包含抽象⽅法的类，⼀定是⼀个抽象类。

反之，抽象类中可以没有抽象⽅法的。

* > 若⼦类重写了⽗类中的所有的抽象⽅法后，此⼦类⽅可实例化* 若⼦类没有重写⽗类中的所有的抽象⽅法，则此⼦类也是⼀个抽象类，需要使⽤abstract修饰*/public class AbstractTest {public static void main(String[] args) {//⼀旦Person类抽象了，就不可实例化// Person p1 = new Person();// p1.eat();}}abstract class Creature{public abstract void breath();}abstract class Person extends Creature{String name;int age;public Person(){}public Person(String name,int age){ = name;this.age = age;}//不是抽象⽅法：// public void eat(){//// }//抽象⽅法public abstract void eat();public void walk(){System.out.println("⼈⾛路");}}class Student extends Person{public Student(String name,int age){super(name,age);}public Student(){}public void eat(){System.out.println("学⽣多吃有营养的⾷物");}@Overridepublic void breath() {System.out.println("学⽣应该呼吸新鲜的没有雾霾的空⽓");}}。

java基础之抽象类和抽象⽅法Java 抽象类在⾯向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是⽤来描绘对象的，如果⼀个类中没有包含⾜够的信息来描绘⼀个具体的对象，这样的类就是抽象类。

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员⽅法和构造⽅法的访问⽅式和普通类⼀样。

由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使⽤。

也是因为这个原因，通常在设计阶段决定要不要设计抽象类。

⽗类包含了⼦类集合的常见的⽅法，但是由于⽗类本⾝是抽象的，所以不能使⽤这些⽅法。

在 Java 中抽象类表⽰的是⼀种继承关系，⼀个类只能继承⼀个抽象类，⽽⼀个类却可以实现多个接⼝。

抽象类在 Java 语⾔中使⽤ abstract class 来定义抽象类。

如下实例：/* ⽂件名 : Employee.java */public abstract class Employee{private String name;private String address;private int number;public Employee(String name, String address, int number){System.out.println("Constructing an Employee"); = name;this.address = address;this.number = number;}public double computePay(){System.out.println("Inside Employee computePay");return 0.0;}public void mailCheck(){System.out.println("Mailing a check to " + + " " + this.address);}public String toString(){return name + " " + address + " " + number;}public String getName(){return name;}public String getAddress(){return address;}public void setAddress(String newAddress){address = newAddress;}public int getNumber(){return number;}}注意到该 Employee 类没有什么不同，尽管该类是抽象类，但是它仍然有 3 个成员变量，7 个成员⽅法和 1 个构造⽅法。

abstract关键字用法
abstract关键字用法有以下几种：
1. 抽象类的声明：在类的声明前加上abstract，表示该类是抽象类，不能直接实例化，只能被继承。

2. 抽象方法的声明：在方法的声明前加上abstract，表示该方法是抽象方法，没有具体的实现，需要子类去实现。

抽象方法没有方法体，用分号代替。

3. 抽象属性的声明：在成员变量的声明前加上abstract，表示该成员变量是抽象属性，没有具体的实现，需要子类去实现。

4. 接口的声明：接口中的所有方法默认都是抽象方法，所有成员变量默认都是public、static、final类型，可以不用声明为abstract。

5. 抽象类的继承：一个非抽象类可以继承一个抽象类，但必须实现该抽象类的所有抽象方法。

总的来说，abstract关键字的作用是定义抽象类、抽象方法或抽象属性，通过继承和实现来完成具体的操作。

抽象方法可以有方法体在Java中，抽象方法是指在父类中声明但没有实现的方法。

抽象方法是通过abstract关键字进行声明的，并且没有方法体。

抽象方法只能存在于抽象类或接口中。

抽象方法的存在主要是为了让子类进行继承和实现。

子类在继承抽象类或实现接口时，必须实现父类或接口中的所有抽象方法。

这样，抽象方法就充当了一种约束，保证了子类的一致性和完整性。

由于抽象方法没有方法体，因此它没有具体的实现，只是定义了方法的签名。

抽象方法的特点是：1. 没有方法体：抽象方法没有具体的实现，只有方法的声明。

例如，在抽象类中声明一个抽象方法：javapublic abstract void methodName();2. 必须被子类实现：抽象方法必须在子类中被实现，否则子类也必须声明为抽象类。

子类通过实现抽象方法来完成对父类的扩展。

例如，一个抽象类Animal 中声明了一个抽象方法eat()，那么所有继承自Animal的子类都必须实现eat()方法。

3. 可以有参数：抽象方法可以有参数，用于传递数据。

参数的类型和数量可以任意。

例如，声明一个带有参数的抽象方法：javapublic abstract void methodName(int param1, String param2);4. 可以有返回值：抽象方法也可以有返回值，返回值的类型可以是任意类型。

例如，声明一个带有返回值的抽象方法：javapublic abstract int methodName();尽管抽象方法本身没有方法体，但是在抽象类中可以有普通方法（非抽象方法）。

这些普通方法可以有方法体，并且可以在抽象类被实例化时被调用。

例如，在抽象类Animal中可以有一个普通方法：javapublic void sleep() {System.out.println("Animal is sleeping.");}这个普通方法可以被Animal类的子类继承和使用，而不需要重新实现。