diff --git a/cpp/src/arrow/types/primitive.cc b/cpp/src/arrow/types/primitive.cc
index 611457dbf63f1..66a60fa43fb10 100644
--- a/cpp/src/arrow/types/primitive.cc
+++ b/cpp/src/arrow/types/primitive.cc
@@ -121,13 +121,13 @@ Status PrimitiveBuilder<T>::Reserve(int32_t elements) {
   return Status::OK();
 }
 
-template <typename T>
-std::shared_ptr<Array> NumericBuilder<T>::Finish() {
-  return PrimitiveBuilder<T>::Finish();
-}
+// template <typename T>
+// std::shared_ptr<Array> NumericBuilder<T>::Finish() {
+//   return PrimitiveBuilder<T>::Finish();
+// }
 
 template <typename T>
-Status NumericBuilder<T>::Append(const value_type* values, int32_t length,
+Status PrimitiveBuilder<T>::Append(const value_type* values, int32_t length,
     const uint8_t* valid_bytes) {
   RETURN_NOT_OK(PrimitiveBuilder<T>::Reserve(length));
 
@@ -170,16 +170,41 @@ std::shared_ptr<Array> PrimitiveBuilder<T>::Finish() {
   return result;
 }
 
-template class NumericBuilder<UInt8Type>;
-template class NumericBuilder<UInt16Type>;
-template class NumericBuilder<UInt32Type>;
-template class NumericBuilder<UInt64Type>;
-template class NumericBuilder<Int8Type>;
-template class NumericBuilder<Int16Type>;
-template class NumericBuilder<Int32Type>;
-template class NumericBuilder<Int64Type>;
-template class NumericBuilder<FloatType>;
-template class NumericBuilder<DoubleType>;
+template <>
+Status PrimitiveBuilder<BooleanType>::Append(const uint8_t* values, int32_t length,
+    const uint8_t* valid_bytes) {
+  RETURN_NOT_OK(Reserve(length));
+
+  for (int i = 0; i < length; ++i) {
+    if (values[i] > 0) {
+      util::set_bit(raw_data_, length_ + i);
+    } else {
+      util::clear_bit(raw_data_, length_ + i);
+    }
+  }
+
+  if (valid_bytes != nullptr) {
+    PrimitiveBuilder<BooleanType>::AppendNulls(valid_bytes, length);
+  } else {
+    for (int i = 0; i < length; ++i) {
+      util::set_bit(null_bitmap_data_, length_ + i);
+    }
+  }
+  length_ += length;
+  return Status::OK();
+}
+
+template class PrimitiveBuilder<UInt8Type>;
+template class PrimitiveBuilder<UInt16Type>;
+template class PrimitiveBuilder<UInt32Type>;
+template class PrimitiveBuilder<UInt64Type>;
+template class PrimitiveBuilder<Int8Type>;
+template class PrimitiveBuilder<Int16Type>;
+template class PrimitiveBuilder<Int32Type>;
+template class PrimitiveBuilder<Int64Type>;
+template class PrimitiveBuilder<FloatType>;
+template class PrimitiveBuilder<DoubleType>;
+template class PrimitiveBuilder<BooleanType>;
 
 BooleanArray::BooleanArray(int32_t length, const std::shared_ptr<Buffer>& data,
     int32_t null_count,
@@ -222,31 +247,4 @@ bool BooleanArray::Equals(const std::shared_ptr<Array>& arr) const {
   return EqualsExact(*static_cast<const BooleanArray*>(arr.get()));
 }
 
-Status BooleanBuilder::Append(const uint8_t* values, int32_t length,
-    const uint8_t* valid_bytes) {
-  RETURN_NOT_OK(Reserve(length));
-
-  for (int i = 0; i < length; ++i) {
-    if (values[i] > 0) {
-      util::set_bit(raw_data_, length_ + i);
-    } else {
-      util::clear_bit(raw_data_, length_ + i);
-    }
-  }
-
-  if (valid_bytes != nullptr) {
-    PrimitiveBuilder<BooleanType>::AppendNulls(valid_bytes, length);
-  } else {
-    for (int i = 0; i < length; ++i) {
-      util::set_bit(null_bitmap_data_, length_ + i);
-    }
-  }
-  length_ += length;
-  return Status::OK();
-}
-
-std::shared_ptr<Array> BooleanBuilder::Finish() {
-  return PrimitiveBuilder<BooleanType>::Finish();
-}
-
 } // namespace arrow
diff --git a/cpp/src/arrow/types/primitive.h b/cpp/src/arrow/types/primitive.h
index f090b46608c8f..ec6fee35513ce 100644
--- a/cpp/src/arrow/types/primitive.h
+++ b/cpp/src/arrow/types/primitive.h
@@ -121,10 +121,19 @@ class PrimitiveBuilder : public ArrayBuilder {
     return data_;
   }
 
+  // Vector append
+  //
+  // If passed, valid_bytes is of equal length to values, and any zero byte
+  // will be considered as a null for that slot
+  Status Append(const value_type* values, int32_t length,
+      const uint8_t* valid_bytes = nullptr);
+
   // Ensure that builder can accommodate an additional number of
   // elements. Resizes if the current capacity is not sufficient
   Status Reserve(int32_t elements);
 
+  std::shared_ptr<Array> Finish() override;
+
  protected:
   std::shared_ptr<PoolBuffer> data_;
   value_type* raw_data_;
@@ -134,15 +143,15 @@ class PrimitiveBuilder : public ArrayBuilder {
   // Increase the capacity of the builder to accommodate at least the indicated
   // number of elements
   Status Resize(int32_t capacity);
-
-  std::shared_ptr<Array> Finish() override;
 };
 
-template <typename Type>
-class NumericBuilder : public PrimitiveBuilder<Type> {
+template <typename T>
+class NumericBuilder : public PrimitiveBuilder<T> {
  public:
-  using typename PrimitiveBuilder<Type>::value_type;
-  using PrimitiveBuilder<Type>::PrimitiveBuilder;
+  using typename PrimitiveBuilder<T>::value_type;
+  using PrimitiveBuilder<T>::PrimitiveBuilder;
+
+  using PrimitiveBuilder<T>::Append;
 
   // Scalar append. Does not capacity-check; make sure to call Reserve beforehand
   void Append(value_type val) {
@@ -150,19 +159,13 @@ class NumericBuilder : public PrimitiveBuilder<Type> {
     raw_data_[length_++] = val;
   }
 
-  // Vector append
-  //
-  // If passed, valid_bytes is of equal length to values, and any zero byte
-  // will be considered as a null for that slot
-  Status Append(const value_type* values, int32_t length,
-      const uint8_t* valid_bytes = nullptr);
-
-  std::shared_ptr<Array> Finish() override;
-
  protected:
-  using PrimitiveBuilder<Type>::length_;
-  using PrimitiveBuilder<Type>::null_bitmap_data_;
-  using PrimitiveBuilder<Type>::raw_data_;
+  using PrimitiveBuilder<T>::length_;
+  using PrimitiveBuilder<T>::null_bitmap_data_;
+  using PrimitiveBuilder<T>::raw_data_;
+
+  using PrimitiveBuilder<T>::Init;
+  using PrimitiveBuilder<T>::Resize;
 };
 
 template <>
@@ -306,7 +309,7 @@ class BooleanBuilder : public PrimitiveBuilder<BooleanType> {
 
   virtual ~BooleanBuilder() {}
 
-  std::shared_ptr<Array> Finish() override;
+  using PrimitiveBuilder<BooleanType>::Append;
 
   // Scalar append
   void Append(bool val) {
@@ -322,16 +325,6 @@ class BooleanBuilder : public PrimitiveBuilder<BooleanType> {
   void Append(uint8_t val) {
     Append(static_cast<bool>(val));
   }
-
-  // Vector append
-  //
-  // If passed, valid_bytes is of equal length to values, and any zero byte
-  // will be considered as a null for that slot
-  Status Append(const uint8_t* values, int32_t length,
-      const uint8_t* valid_bytes = nullptr);
-
-  Status Append(const std::vector<uint8_t>& values,
-      const uint8_t* valid_bytes = nullptr);
 };
 
 } // namespace arrow