同样，我们由这道题引出抽象类，抽象方法这个概念。

按下面要求定义类Converter及其子类WeightConverter

定义抽象类：Converter：

定义一个抽象类Converter，表示换算器，其定义的如下：

1. 一个私有的String类型成员变量：name，表示换算器Converter的名称，并定义name变量的getter方法；
2. 一个带参数的构造器，用于对name赋值；
3. 一个公有的抽象方法：double convert(); 表示进行换算操作。

定义Converter的子类WeightConverter：

定义Converter的子类WeightConverter，表示重量换算器。

对于WeightConverter类的要求如下：

1. 成员变量 value 表示原重量值，并定义其getter方法；
2. 成员变量 factor 表示换算系数，比如 公斤-克的换算系数为1000，因为1公斤=1000克；
3. 带三个参数的构造器，在实例化WeightConverter对象时初始化：换算器名称、原重量值以及换算系数；
4. 实现父类Converter中的convert方法，将原重量值换算为指定单位的重量值

Main类代码：

import java.lang.reflect.Modifier;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> clazz = Class.forName("Converter");
        Class<?> clazz2 = Class.forName("WeightConverter");
        boolean isAbs = Modifier.isAbstract(clazz.getModifiers()) ;
        System.out.println(clazz.isAssignableFrom(clazz2)+" "+Modifier.isAbstract(clazz.getModifiers()));
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入换算器名称(比如：斤-克)、原重量值和换算系数，中间用空格分开");
        String name = scanner.next();
        double value = scanner.nextDouble();
        double factor = scanner.nextDouble();
        WeightConverter converter = new WeightConverter(name,value,factor);
        String[] units = name.split("-");
        System.out.println(converter.getName()+"换算，"+converter.getValue()+units[0]+"="+converter.convert()+units[1]);
    }
}

输入样例：

在这里给出一组输入。例如：

斤-克 2.5 500

输出样例：

在这里给出相应的输出。例如：

true true
请输入换算器名称(比如：斤-克)、原重量值和换算系数，中间用空格分开
斤-克换算，2.5斤=1250.0克

先来看有关抽象类问题的需求：
 定义一个抽象类，成员变量和构造器倒是和以前定义类时差不多，唯一变了的就是方法，这里要求我们定义一个抽象方法。

好嘞，撸起袖子加油干——咱们来唠唠“抽象”。

抽象

抽象：英文abstract,为什么要抽象？Java为了符合现实生活中的逻辑，有些类是不能被实例化的，于是便有了抽象类。

举个例子：我们要介绍一个人的爱好。这时候，爱好就是个抽象的概念，它看不见摸不着，是只存在人类脑子里的概念。爱好可以是方方面面，在写爱好类时，我们可以标上爱好的名字，但我们是敲不出方法体的——再细细道来：

我们可以先写一个Person类，然后Person类具有姓名，职业以及爱好这个方法，由上面分析可以知道，在没有实例化Person时我们并不知道这个爱好究竟是什么。这时候我们利用abstract关键字，把爱好这个方法写成抽象方法(具体格式在后面)，既然这个类有个方法/行为是抽象的，那么这个类也应该是抽象的。

因为对象，我们又称作实例对象，所有的属性和方法都得具体化。一旦抽象类被实例化，一是它的逻辑上说不通，二是抽象方法与具体、完整的实例方法相矛盾。

小总结：

故抽象类是不能被实例化的，且有了抽象方法就一定是抽象类

且看代码：

public abstract class Person {//定义一个Person类
    private String name;
    private String career;//俩成员变量
    public Person(String name,String career)
    {

        this.name = name;
        this.career = career;
    }//有参构造器

    public abstract String hobby();//未知爱好，无法书写方法体，故令其为抽象方法

    public String toString()//这里重写toString()方法，改变返回类的信息，不再是简单的地址_哈西玛
    {
        return name + "是一位" + career + "爱好是" + hobby();
    }//toString()方法是Person类继承Object类的方法，对其进行重写

}

题外话：所有的类的拥有一个共同的父类:Object类，一般默认不写，但是默认继承。

虽说只能有一个直接父类，但是间接父类是可以有很多的，并且都会继承间接父类的属性和方法。有关继承和方法覆盖，我们在这里详说：感兴趣的小伙伴可移步这里

Java-继承-定义Student类继承于Person类(例)-CSDN博客

抽象类的语法格式：

public abstract class 类名
{

}//abstract关键字放在class前面

abstract是放在class前面，抽象一般是公开的，但一定不能是private。

抽象方法的语法格式：

abstract 方法返回类型 方法名(参数列表)
{
  //方法体
}

问题来了，抽象到底做什么用呢？---抽象类的逻辑作用：避免抽象类被实例化(这个我们上文解释过了)；代码上的作用，其实就是一种继承。

抽象方法的作用——用来对继承它的子类的行为作出某种规范，实现方法的声明。

怎么又和继承挂上钩了？好问题，不过能问出这种问题，说明还需要对继承有正确的认识。

对于上次说到的继承：我们会使用继承，是因为类与类之间具有传承。这里引入的抽象类，其实本质上是对继承的扩大，有些时候父类并不会是实实在在的类，不能被实例化。

综上所述，继承本质上是描述类与类之间抽象与具体的关系，父类未完善的，子类就对其补充。

而抽象，也正是对继承的普遍化，对于我们定义子类起着更加规范的作用，因为抽象方法必须实现，因为不实现，编译都不给过。而子类继承非抽象类的父类的方法时，对于方法重写需要我们主动Override。

了解了继承与抽象的关系，那读懂抽象的语法规则简直易如反掌。

abstract的语法规则

1.abstract不能修饰private,抽象方法作父类肯定要被子类继承并一对一进行完善，子类看不见，显然是矛盾的。

2.抽象方法必须定义在抽象类中，抽象方法意味着某个类在某个行为上抽象，那沾了点抽象，就是抽象类了。

3.抽象方法不能有实现，被实现的抽象方法就不叫抽象方法了。注意：在子类里被实现的抽象方法是叫实例方法，也可以叫方法覆盖不过是强制性的。只有抽象类里的方法才能算抽象方法

咱们把这道题拿下，抽象的知识点基本就掌握了。

回到题目

1、2要求我们还是直接上代码，需要相应详细参考的，可以移步：定义类：定义一个类Square表示正方形_定义一个square类,当客户访问该页面时,服务器创建该类的对象,只要客户给出正方形-CSDN博客

public abstract class Converter {//让我们定义一个抽象类，则在class前面加一个abstract

        String name;//换算器名称

        public String getName()
        {
            return name;
        }//name的getter方法

        public Converter(String name)
        {
            this.name = name;
        }//有参构造器
}

3.抽象方法的书写

public abstract class Converter {

//...
 public abstract double convert();//抽象方法，是不是很像方法的声明，不过确实是方法声明
 
//抽象方法，如果在声明里面，abstract前面写上了public ,那后面在子类实现方法的时候一定也要加上public，否则会报错
}

在抽象方法声明里面有了public,后面子类实现方法的时候一定要加上public。如果声明里面没有写public，子类里面倒是可写 可不写。有觉得绕的同学，可以记住：要么都写，要么都不写。

前俩题，涉及定义类这个知识点。而3题，涉及super关键字和继承，要作详细了解的同学，移步： Java-继承-定义Student类继承于Person类-CSDN博客

前仨的代码：

public class WeightConverter extends Converter//子类继承抽象类/父类
{
    private double value;//原重量值
    public double  factor;//换算系数

    public double getValue()
    {
    return value;
    }

    public WeightConverter(String name,double value,double factor)
    {
       super(name);//调用父类的构造器，实现该对象下的成员变量赋值
       this.value = value;
       this.factor = factor;
    }
}

 

子类对抽象方法的实现

public class WeightConverter extends Converter
{
//...
  public double convert()
   {
       return value * factor; 
   }//根据题意得，看不懂题？由输入样例和输出样例结合一下，可知就是value和factor相乘的结果


}

完整代码:(合在一个java文件下，只会有一个public类就是main类)

abstract class Converter
{
    String name;

    public String getName()
    {
        return name;
    }

    public Converter(String name)
    {
        this.name = name;
    }
    public abstract double convert();

    
}
 class WeightConverter extends Converter
{
    double value;//原重量值
    double  factor;//换算系数

    public double getValue()
    {
    return value;
    }

    public WeightConverter(String name,double value,double factor)
    {
       super(name);
       this.value = value;
       this.factor = factor;
    }

   public double convert()
   {
       return value * factor; 
   }
    

}