抽象类和抽象方法

Java抽象类包访问权限⼀、抽象类 1. 使⽤abstract定义的类被称之为抽象类 抽象类不能够⽣成对象(即使⽤new) 但抽象类可以有构造函数,其在⼦类对象⽣成的时候通过⼦类构造函数中super调⽤ 如果⼀个类当中包含抽象函数，那么这个必须声明为抽象类 如果⼀个类中没有抽象函数，这个类也可以被声明为抽象类(可防⽌被⽣成对象) 2. 抽象⽅法：只有⽅法的定义(返回值、函数名、参数列表),没有函数体({})的函数,如：public abstract void fun(); 3. 抽象类可以被继承，通过⼦类复写抽象函数⼆、软件包 1. 为Java类提供了命名空间，不同包中可以有相同名的类 2. 将类放置到⼀个包当中，打包需要使⽤package “包名”; 3. 编译时需要使⽤-d 参数，该参数的作⽤是依照包名⽣成相应的⽂件夹(javac -d . Test.java,'.'代表当前⽬录，javac⽤于) 4. 运⾏.class时需要使⽤命令java ”包名“+“."+”类名“ 5. 包名的⼀般命名规范：包名所有字母都要⼩写包名⼀般是你的域名倒过来写 6. 使⽤其他包中的公共类时,需要使⽤”包名“+”."+"类名"或者使⽤“ import 包名”将包导⼊,这时可直接使⽤类名三、访问权限 权限⾼到低public -> protected -> default -> private1. public：公共权限使⽤public修饰符的类允许任意类(可在不同的包中)访问该类public类中的成员和⽅法是public时，可被其他类访问2. private：私有权限⼀般修饰变量和⽅法，被修饰的变量和⽅法只能被当前的类访问(使⽤)3. default：包级别访问权限未使⽤权限修饰符时即为default包级别访问，同⼀个包中可访问跨包⼦类⽆法继承(使⽤)⽗类中default权限的成员变量和成员⽅法4. protected：受保护权限⾸先其拥有和default的功能，但只能修饰成员变量和成员⽅法允许包外部的⼦类使⽤该成员。

java抽象类例子Java 抽象类(Abstract Class)是一种特殊的类，它不能用来创建对象，只能作为其他类的基类来使用。

它提供了一种方法，用于将相同的代码组合在一起，并且还提供了一些基本的实现。

因此，使用抽象类可以大大减少开发人员的工作量，也可以节省时间和精力。

抽象类包含抽象方法（abstract methods）和普通的方法（concrete methods），它们都可以被子类继承和重写。

抽象方法不可以有实际的实现，必须由子类实现，因为抽象类本身就没有具体的实现。

子类可以复写抽象方法，添加自己的实现或者使用父类的实现。

但不能使用抽象方法，因为抽象类本身没有实现。

抽象类的一个关键优势是它们可以简化代码重用和时间上的效率。

通过统一的接口，可以将一组行为都定义在一个抽象类中，然后可以在其他类中使用这些行为，而不需要重复编写这些行为。

这样可以节省不必要的代码重复，提高程序的可用性，也可以使程序更加易读。

Java抽象类是一个经常使用的语法结构，它可以帮助开发者减少冗余代码，节省时间和精力。

下面是一个关于抽象类的例子：public abstract class Animals{protected String name;public abstract void eat();public abstract void sleep();public String getName(){return name;}}public class Dog extends Animals{@Overridepublic void eat(){System.out.println("Dog eats food");}@Overridepublic void sleep(){System.out.println("Dog is sleeping");}}这个例子中定义了一个名为Animals的抽象类，它定义了两个抽象方法eat和sleep，以及一个具有getName()方法的字段name。

抽象类的概念和作用是什么抽象类是面向对象编程中的概念，它是一种特殊的类，不能被实例化。

抽象类仅仅被用来继承和派生其他类。

它的目的是为了提供一个通用的基类，定义一些抽象的方法和属性，以及一些通用的行为和规范。

抽象类通过关键字"abstract"来声明，它可以包含实现和抽象方法。

实现方法是已经定义了具体实现的方法，而抽象方法是只有方法声明而没有具体实现的方法。

抽象方法必须在子类中被重写并实现，否则子类也必须声明为抽象类。

另外，抽象类可以拥有普通的方法、属性和字段。

抽象类的作用主要有以下几个方面：1. 提供一种抽象的存在方式：抽象类是对一类具有共同特性的事物的抽象，它定义了一些共性的属性和行为，而不涉及具体的实现细节。

这样可以使子类在继承抽象类时，只需要关注实现具体的细节，而不需要考虑整个类的设计。

2. 强制子类实现特定方法：抽象类中可以定义一些抽象方法，这些方法只有方法声明而没有具体实现。

它的存在意义在于强制其子类实现这些方法，以保证子类的功能完整和正确。

这样可以在一定程度上实现一种约束性，使得子类在继承抽象类后具有一些固定的行为和规范。

3. 统一接口规范：抽象类可以作为一种接口的替代品，定义了一些公共的方法和属性。

通过继承抽象类，子类可以实现相同的接口规范，从而实现对外统一的调用方式。

这样可以使得代码的可维护性和复用性更高，减少代码的冗余。

4. 代码的层次结构：抽象类可以被继承，可以形成一种继承关系，从而实现代码的组织和划分。

抽象类的存在使得代码结构更加清晰，便于管理和维护。

通过继承抽象类，可以建立起一种层次结构，从而实现面向对象编程中的多态性和封装性。

5. 提供默认实现：抽象类中的实现方法可以提供一种默认的实现，子类可以选择性地重写这些方法。

这样可以避免子类在没有特殊需求时重复实现相同的代码，减少了代码冗余。

同时也在一定程度上提供了一种代码复用和扩展的方式。

综上所述，抽象类是一种具有抽象方法和实现方法的特殊类，它的作用主要在于提供一种抽象的存在方式、强制子类实现特定方法、统一接口规范、代码的层次结构以及提供默认实现。

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 中也可以创建一种类专门用来当做父类，这种类称为“抽象类”。

抽象类的作用类似“模板”，其目的是要设计者依据它的格式来修改并创建新的类，但是不能直接由抽象类创建对象，只能通过抽象类派生出新的类，再由它来创建对象。

但是在抽象类的使用中同样存在单继承的局限，即一个子类只能继承一个抽象类抽象类的定义及使用规则：（1）包含一个抽象方法的类必须是抽象类（2）抽象类和抽象方法都要使用abstract 关键字声明（3）抽象方法只需声明而不需要实现（4）抽象类必须被子继承，子类（如果不是抽象类）必须覆写抽象类中的全部抽象方法抽象类的定义格式：abstract class 抽象类名称{属性;访问权限返回值类型方法名称(参数){//普通方法return 返回值;}访问权限abstract 返回值类型方法名称(参数);//抽象方法//在抽象方法中是没有方法体的}可以看出抽象类的定义比普通类多了一些抽象方法，其他地方与普通类的组成基本都是一样的。

二、代码示例abstract class A{public static final String FLAG = "CHINA";private String name = "Java";public String getName(){//设置姓名return name;}public void setName(String name){//取得姓名 = name;}public abstract void print();//定义抽象方法}此处由于定义了print() 的抽象方法，所以此类的声明为abstract class。

此时可以编写一个子类继承此抽象类，需要注意子类必须覆写抽象类中的全部抽象方法class B extends A{//继承抽象类，覆写全部抽象方法public void print(){System.out.println("FLAG = " + FLAG);System.out.println("姓名：" + super.getName());}}public class Test{public static void main(String[] args) {B b = new B();//实例化子类对象b.print();//调用被子类覆写过的方法}}三、思考（1）一个抽象类可以使用final关键字吗？已知一个类如果使用了final 关键字声明，则不能被子类继承，而抽象类又必须被子类覆写，所以，抽象类不能使用final 关键字此外使用abstract 关键字修饰抽象方法时不能使用private 修饰，因为抽象方法必须被子类覆写，而如果使用了private 声明，则子类是无法覆写的（2）一个抽象类可以定义构造方法吗？在一个抽象类中是允许存在构造方法的，因为抽象类依然使用的是类的继承关系，而且抽象类也存在各个属性，所以子类在实例化之前必须先要对父类进行实例化abstract class A{public A(){System.out.println("A、抽象类中的构造方法。

抽象⽅法和抽象类抽象类和抽象⽅法1、抽象类 ( Abstract Class )关键字：abstract从形式上看抽象类是由abstract修饰的 Java 类专门为继承体系顶端设计的类通常设计为抽象类抽象类不能被实例化不能通过 new 关键字直接创建抽象类的类型的实例但是可以创建其⼦类的实例抽象类中可以有字段、⽅法、构造⽅法、代码块、内部类特点：1、抽象类可以继承抽象类具体类可以继承抽象类抽象类可以继承具体类2、抽象⽅法是由 abstract 修饰的、没有⽅法体的⽅法3、有抽象⽅法的类必须是抽象类4、如果具体类继承了抽象类，则必须实现抽象类中的所有⽅法2、抽象⽅法如果某个⽅法在声明时⽆法确定其实现细节，则可以省略其实现过程，直接以分号结束如果某个⽅法省略了实现过程连 { } 都省略了此时需要为该⽅法增加关键字 abstract 表⽰该⽅法时抽象的抽象⽅法就是由 abstract 修饰的没有⽅法体的⽅法含有抽象⽅法的类必须就是抽象类但是有抽象类不⼀定有抽象⽅法3、⽰例Human 类package abstractclass;import java.util.Objects;/** 1、抽象类与具体类的区别是抽象类不可以实例化* 2、抽象类不⼀定要有抽象⽅法为了让某个类不能被实例化也可以将该类设计为抽象类** */public abstract class Human extends Object { // 抽象类可以继承实体类protected String name;static {System.out.println("Human:类初始化块");}{System.out.println("Human:实例初始化块");}public Human() {System.out.println("Human()");}public Human(String name) { = name;System.out.println("Human(String)");}public void show() {System.out.println();}public static void main(String[] args) {Human h = null;// h = new Human(); // 【错误】 Human 类是抽象的⽆法实例化}}Sinaean 类有⼀个抽象⽅法 eatpackage abstractclass;/*** 1、抽象类可以继承抽象类具体类可以继承抽象类抽象类可以继承具体类* 2、抽象⽅法是由 abstract 修饰的、没有⽅法体的⽅法* 3、有抽象⽅法的类必须是抽象类* */public abstract class Sinaean extends Human {// 声明⼀个抽象⽅法public abstract void eat(String foodName); // 没有⽅法体、由 abstract 修饰符修饰 }Han 类package abstractclass;/*** 1、如果具体类继承了抽象类，则必须实现抽象类中的所有⽅法*** */public class Han extends Sinaean {@Overridepublic void eat(String foodName) { // 如果有⽅法体就⼀定不能有 abstract 修饰符 System.out.println("在中国汉族⼈基本都使⽤筷⼦吃" + foodName );}public static void main(String[] args) {Han h = new Han(); = "⽕锅";h.eat("⽕锅");}}。

抽象方法可以有方法体
抽象方法可以有方法体，这种说法是错的。

抽象类必须使用abstract修饰符来修饰，抽象方法也必须使用abstract修饰符来修饰，抽象方法不能有方法体。

抽象类不能被实例化，无法使用new关键字来调用抽象类的构造器创建抽象类实例。

即使抽象类里不包含抽象方法，这个抽象类也不能创建实例。

抽象类可以包含成员变量，方法（普通方法和抽象方法），构造器，初始化块，内部类5种成分。

抽象类的构造器不能用于创建实例，主要用于被其子类调用。

含有抽象方法的类只能被定义成抽象类。

C#类和继承（扩展⽅法、静态类、抽象类、构造函数初始化等）分部类和分部⽅法namespace jiayou1{/*定义分部类需要注意以下问题：在申明和实现申明中都必须包含上下⽂关键字partial，直接放在关键字void的后⾯，返回类型必须是void参数列表不能包含out参数*/partial class MyClass{partial void PrintSum(int x,int y);//申明分部⽅法，没有实现部分public void Add(int x,int y){PrintSum(x,y);}}partial class MyClass{partial void PrintSum(int x, int y)//申明分部⽅法，实现部分{Console.WriteLine("sum is {0}",x+y);}}class Program{static void Main(string[] args){var mc = new MyClass();mc.Add(5,6);}}}类继承namespace类继承{class SomeClass//基类{public string Field1 = "base class field";public void Method1(string value){Console.WriteLine("base class--Method1:{0}",value );}}class OtherClass : SomeClass//派⽣类{public string Field2 = "derived class field";public void Method2(string value){Console.WriteLine("Derived class--Method2:{0}",value);}}class Program{static void Main(string[] args){OtherClass oc = new OtherClass();oc.Method1(oc.Field1 );//以基类字段为参数的基类⽅法oc.Method2(oc.Field2);//以基类字段为参数的基类⽅法oc.Method1(oc.Field2);//以基类字段为参数的基类⽅法oc.Method2(oc.Field1);//以基类字段为参数的基类⽅法}}}隐藏基类成员namespace隐藏基类的成员{/*要隐藏⼀个继承的数据成员，需要声明⼀个新的new相同的类型成员，并使⽤相同的名称要让编译器知道你在故意隐藏继承成员，使⽤New修饰符。

什么是抽象类什么是接⼝两者有什么区别？如何使⽤它⼀、抽象类：抽象类是特殊的类，只是不能被实例化；除此以外，具有类的其他特性；重要的是抽象类可以包括抽象⽅法，这是普通类所不能的。

抽象⽅法只能声明于抽象类中，且不包含任何实现，派⽣类必须覆盖它们。

另外，抽象类可以派⽣⾃⼀个抽象类，可以覆盖基类的抽象⽅法也可以不覆盖，如果不覆盖，则其派⽣类必须覆盖它们。

⼆、接⼝：接⼝是引⽤类型的，类似于类,和抽象类的相似之处有三点：1、不能实例化；2、包含未实现的⽅法声明；3、派⽣类必须实现未实现的⽅法，抽象类是抽象⽅法，接⼝则是所有成员（不仅是⽅法包括其他成员）；另外，接⼝有如下特性：接⼝除了可以包含⽅法之外，还可以包含属性、索引器、事件，⽽且这些成员都被定义为公有的。

除此之外，不能包含任何其他的成员，例如：常量、域、构造函数、析构函数、静态成员。

⼀个类可以直接继承多个接⼝，但只能直接继承⼀个类（包括抽象类）。

三、抽象类和接⼝的区别：1.类是对对象的抽象，可以把抽象类理解为把类当作对象，抽象成的类叫做抽象类.⽽接⼝只是⼀个⾏为的规范或规定，微软的⾃定义接⼝总是后带able字段，证明其是表述⼀类类“我能做。

”.抽象类更多的是定义在⼀系列紧密相关的类间，⽽接⼝⼤多数是关系疏松但都实现某⼀功能的类中.2.接⼝基本上不具备继承的任何具体特点,它仅仅承诺了能够调⽤的⽅法;3.⼀个类⼀次可以实现若⼲个接⼝,但是只能扩展⼀个⽗类4.接⼝可以⽤于⽀持回调,⽽继承并不具备这个特点.5.抽象类不能被密封。

6.抽象类实现的具体⽅法默认为虚的，但实现接⼝的类中的接⼝⽅法却默认为⾮虚的，当然您也可以声明为虚的.7.（接⼝）与⾮抽象类类似，抽象类也必须为在该类的基类列表中列出的接⼝的所有成员提供它⾃⼰的实现。

但是，允许抽象类将接⼝⽅法映射到抽象⽅法上。

8.抽象类实现了oop中的⼀个原则，把可变的与不可变的分离。

抽象类和接⼝就是定义为不可变的，⽽把可变的座位⼦类去实现。

3）一个抽象类中可以有一个或多个抽象方法，也可以没有抽象方法。

如果没有任何抽象方法，这就意味着要避免由这个类直接创建对象。

4）抽象类只能被继承（派生子类）而不能创建具体对象即不能被实例化。

下边我们举例说明抽象类的定义。

定义如上边所述的平面几何形状Shape类。

每个具体的平面几何形状都可以获得名字且都可以计算面积，我们定义一个方法getArea()来求面积，但是在具体的形状未确定之前，面积是无法求取的，因为不同形状求取面积的数学公式不同，所以我们不可能写出通用的方法体来，只能声明为抽象方法。

定义抽象类Shape 的程序代码如下：
/* 这是抽象的平面形状类的定义
* 程序的名字是：Shape.java
*/
public abstract class Shape
{
String name; //声明属性
public abstract double getArea(); //抽象方法声明
}
在该抽象类中声明了name属性和一个抽象方法getArea()。

下边通过派生不同形状的子类来实现抽象类Shape的功能。

5.2.2 抽象类的实现
如前所述，抽象类不能直接实例化，也就是不能用new运算符去创建对象。

抽象类只能做为父类使用，而由它派生的子类必须实现其所有的抽象方法，才能创建对象。

抽象类名词解释
抽象类是一种介乎于抽象和实际之间的特殊类，它由一组抽象方法和抽象属性（即不包含实现的方法和属性）组成。

因此，抽象类不能被实例化，但可以被继承，本质上是一种特殊的接口，其子类必须把它们提供的抽象方法和抽象属性具体化，也就是实现它们。

实际上，抽象类是一种抽象概念，它用于描述对象的共同特性和行为，但却没有任何实现。

抽象类可以用来定义一个类的逻辑结构，它通常提供类的模板代码，以便在实际继承它的情况下，所有子类可以充分利用其内容，并可以将它们添加到子类中。

在面向对象编程中，抽象类是一种重要的概念，它定义了一个类的基本特征，并提供了一种抽象的数据结构。

抽象类中的方法和属性可以让其子类获得一些基本特性，并且可以被继承。

抽象类也是一种实现多态的重要机制，它使得程序的设计和维护更加灵活，代码的复用性更加高效，也使得风格更加清晰。

值得一提的是，抽象类不仅仅是一种抽象的概念，它在设计模式中还起到了重要的作用，它可以用来实现多态性，抽象类可以帮助程序员更好地设计和实现复杂的功能，并使程序结构更加清晰和有序。

总之，抽象类是一种特殊的类，它介乎抽象和实际之间，它不能被实例化，但可以被继承，是一种重要的抽象概念，它定义了一个类的基本特征，并提供了一种抽象的数据结构。

抽象类有助于程序员更好地设计和实现复杂的功能，使程序结构更加清晰和有序，实现多态性，并使代码的复用性更加高效。

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`关键字修饰，例如：javaabstract class Animal {public abstract void sound();public void sleep() {System.out.println("动物睡觉");}}在上面的例子中，`Animal`是一个抽象类，其中声明了一个抽象方法`sound`和一个具体方法`sleep`。

抽象方法`sound`只有方法的声明，没有具体的实现；而具体方法`sleep`有具体的实现。

抽象类的作用主要有两个方面。

首先，抽象类可以作为其他类的父类，通过继承抽象类，子类可以获得抽象类中的属性和方法。

这样可以实现代码的复用，避免重复编写相同的代码。

其次，抽象类可以定义一些抽象方法，这些抽象方法在子类中必须被实现。

这样可以要求子类必须提供一些特定的功能，使得代码更加规范和可靠。

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

抽象方法的定义使用`abstract`关键字修饰，并且不能有方法体。

例如，在上面的例子中，`sound`就是一个抽象方法。

定义抽象方法的目的是为了给子类提供一种规范，要求子类必须实现该方法。

子类继承了抽象类后，如果不实现抽象方法，会编译报错。

例如，我们定义一个`Cat`类继承自`Animal`类：javaclass Cat extends Animal {public void sound() {System.out.println("喵喵喵");}}在`Cat`类中，必须实现抽象方法`sound`，否则会编译报错。

抽象类方法实现抽象类是一种特殊的类，它不能直接被实例化，只能通过继承的方式被子类实现。

抽象类通常用于定义一组相关的类的共同特征和行为，它提供了一种抽象的模板或蓝图，用于衍生出具体的类。

抽象类中可以包含一些具体的方法和属性，也可以包含一些抽象方法。

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

抽象方法必须在子类中被具体实现，否则子类也必须是一个抽象类。

抽象类的主要特点有以下几点：1. 抽象类不能被实例化：抽象类只能被继承，不能直接创建实例对象。

如果要使用抽象类定义的方法和属性，必须通过继承抽象类，并在子类中实现抽象方法。

2. 抽象方法必须在子类中实现：抽象类中的抽象方法没有具体的实现，子类必须实现这些抽象方法，否则子类也必须被声明为抽象类。

3. 抽象类可以包含具体方法和属性：抽象类可以包含一些已经实现的具体方法和属性，这些方法和属性可以在子类中直接使用或者重写。

为什么要使用抽象类？使用抽象类的主要目的是为了将具有共同属性和行为的类进行抽象和封装，实现代码的重用和灵活性的提高。

抽象类定义了一个共同的接口和一些共有的方法，子类通过继承抽象类可以快速地获取这些方法和属性，并在此基础上进行具体的实现。

抽象类的优点：1. 提供了一种代码复用的方式：抽象类提供了一个共同的接口和方法定义，子类可以直接继承这些方法和属性，避免了重复编写相同的代码，提高了代码的复用性。

2. 强制子类实现抽象方法：抽象方法必须在子类中被具体实现，这样可以确保子类具有某种特定的行为。

抽象方法的声明可以起到一种约束作用，确保子类的一致性和规范性。

3. 提供多态性的支持：抽象类可以通过多态的方式引用子类的实例，这样可以实现一种基于抽象类型编程的方式，提高了代码的灵活性和可维护性。

抽象类的使用场景：1. 定义一组相关的类的共同接口和行为：当有一组相关的类有一些共同的特征和行为，但又不完全相同，可以使用抽象类来定义这组类的共同接口和行为。