R, 117 63 59 bytes

function(m)sum(colSums(as.matrix(dist(which(m==8,T)))<2)<2)

Try it online!

dist computes distances (default is Euclidean) among rows of a matrix. which with second argument TRUE returns the coordinates where the predicate is true.

Coordinates are neighbours if the distance between them is not more than the square root of 2, but the inner <2 is good enough because the possible distance jumps from sqrt(2) ro 2.

APL (Dyalog Classic), 29 28 25 bytes

≢∘⍸16=2⊥¨3,⌿3,/8=(⍉0,⌽)⍣4

Try it online!

Jelly, ₁₈ 15 bytes

8=µ+Ż+ḊZµ⁺ỊṖḋµS

Try it online!

How it works

8=µ+Ż+ḊZµ⁺ỊṖḋµS Main link (monad). Input: digit matrix
8= 1) Convert elements by `x == 8`
 µ 2) New chain:
 +Ż+Ḋ x + [0,*x] + x[1:] (missing elements are considered 0)
 Effectively, vertical convolution with [1,1,1]
 Z Transpose
 µ⁺ 3) Start new chain, apply 2) again
 ỊṖ Convert elements by `|x| <= 1` and remove last row
 ḋ Row-wise dot product with result of 1)
 µS 4) Sum

Previous solution, 18 bytes

æc7B¤ZḊṖ
8=µÇÇỊḋµS

Try it online!

Wanted to share another approach, though this is 1 byte longer than Jonathan Allan's solution.

How it works

æc7B¤ZḊṖ Auxiliary link (monad). Input: integer matrix
æc7B¤ Convolution with [1,1,1] on each row
 ZḊṖ Zip (transpose), remove first and last elements

8=µÇÇỊḋµS Main link (monad). Input: digit matrix
8= Convert 8 to 1, anything else to 0 (*A)
 怀 Apply aux.link twice (effective convolution with [[1,1,1]]*3)
 Ịḋ Convert to |x|<=1, then row-wise dot product with A
 µS Sum the result

JavaScript (Node.js), 88 85 bytes

a=>g=(x,y=0,c=0)=>a.map(p=>p.map((q,j)=>c+=q-8?0:1/x?(x-j)**2+y*y<3:g(j,-y)<2)&--y)|c

Try it online!

Thank Arnauld for 2 bytes

J,43, 40 37 bytes

-3 bytes thanks to Bubbler

1#.1#.3 3(16=8#.@:=,);._3(0|:@,|.)^:4

Try it online!

Explanation:

The first part of the algorithm assures that we can apply a 3x3 sliding window to he input. This is achieved by prepending a row of zeroes and 90 degrees rotation, repeated 4 times.

1#.1#.3 3(16=8#.@:=,);._3(0|:@,|.)^:4
 ( )^:4 - repeat 4 times
 0|:@,|. - reverse, prepend wit a row of 0 and transpose
 ;._3 - cut the input (already outlined with zeroes)
 3 3 - into matrices with size 3x3
 ( ) - and for each matrix do
 , - ravel (flatten)
 8 = - check if each item equals 8
 #.@: - and convert the list of 1s and 0s to a decimal
 16= - is equal to 16?
 1#. - add (the result has the shape of the input)
1#. - add again

Retina 0.8.2, 84 bytes

.+
_$&_
m`(?<!(?(1).)^(?<-1>.)*.?.?8.*¶(.)*.|8)8(?!8|.(.)*¶.*8.?.?(?<-2>.)*$(?(2).))

Try it online! Explanation:

.+
_$&_

Wrap each line in non-8 characters so that all 8s have at least one character on each side.

m`

This is the last stage, so counting matches is implied. The m modifier makes the ^ and $ characters match at the start or end of any line.

(?<!...|8)

Don't match a character directly after an 8, or...

(?(1).)^(?<-1>.)*.?.?8.*¶(.)*.

... a character below an 8; the (?(1).)^(?<-1>.)* matches the same column as the ¶(.)* on the next line, but the .?.? allows the 8 to be 1 left or right of the character after the . on the next line.

8

Match 8s.

(?!8|...)

Don't match an 8 immediately before an 8, or...

.(.)*¶.*8.?.?(?<-2>.)*$(?(2).)

... a character with an 8 in the line below; again, the (?<-2>.)*$(?(2).) matches the same column as the (.)*¶ on the previous line, but the .?.? allows the 8 to be 1 left or right of the 8 before the . on the previous line.

Jelly, 17 bytes

=8ŒṪµŒcZIỊȦƲƇẎ⁸ḟL

Try it online! Or see the test-suite.

How?

=8ŒṪµŒcZIỊȦƲƇẎ⁸ḟL - Link: list of lists of integers (digits)
=8 - equals 8?
 ŒṪ - multidimensional truthy indices (pairs of row & column indices of 8s)
 µ - start a new monadic chain
 Œc - all pairs (of the index-pairs) 
 Ƈ - filter keep if: (keep those that represent adjacent positions)
 Ʋ - last four links as a monad:
 Z - transpose
 I - incremental differences
 Ị - insignificant? (abs(x) <= 1)
 Ȧ - all?
 Ẏ - tighten (to a list of all adjacent 8's index-pairs, at least once each)
 ⁸ - chain's left argument (all the index-pairs again)
 ḟ - filter discard (remove those found to be adjacent to another)
 L - length (of the remaining pairs of indices of single 8s)

J, 42 bytes

[:+/@,8=]+[:+/(<:3 3#:4-.~i.9)|.!.0(_*8&=)

Try it online!

explanation

The high-level approach here is similar to the one used in the classic APL solution to the game of life: https://www.youtube.com/watch?v=a9xAKttWgP4.

In that solution, we shift our matrix in the 8 possible neighbor directions, creating 8 duplicates of the input, stack them up, and then add the "planes" together to get our neighbor counts.

Here, we use a "multiply by infinity" trick to adapt the solution for this problem.

[: +/@, 8 = ] + [: +/ (neighbor deltas) (|.!.0) _ * 8&= NB. 
 NB.
[: +/@, NB. the sum after flattening
 8 = NB. a 0 1 matrix created by
 NB. elmwise testing if 8
 NB. equals the matrix
 (the matrix to test for equality with 8 ) NB. defined by...
 ] + NB. the original input plus
 [: +/ NB. the elmwise sum of 8
 NB. matrices defined by
 _ * NB. the elmwise product of 
 NB. infinity and
 8&= NB. the matrix which is 1
 NB. where the input is 8
 NB. and 0 elsewhere, thus
 NB. creating an infinity-0
 NB. matrix
 (|.!.0) NB. then 2d shifting that 
 NB. matrix in the 8 possible
 NB. "neighbor" directions
 (neighbor deltas) NB. defined by the "neighbor
 NB. deltas" (see below)
 NB. QED.
 NB. ***********************
 NB. The rest of the
 NB. explanation merely
 NB. breaks down the neighbor
 NB. delta construction.


 (neighbor deltas ) NB. the neighbor deltas are
 NB. merely the cross product
 NB. of _1 0 1 with itself,
 NB. minus "0 0"
 (<: 3 3 #: 4 -.~ i.9) NB. to create that...
 <: NB. subtract one from
 3 3 #: NB. the base 3 rep of
 i.9 NB. the numbers 0 - 8
 4 -.~ NB. minus the number 4
 NB.
 NB. All of which produces
 NB. the eight "neighbor"
 NB. deltas:
 NB. 
 NB. _1 _1
 NB. _1 0
 NB. _1 1
 NB. 0 _1
 NB. 0 1
 NB. 1 _1
 NB. 1 0
 NB. 1 1

Java 8, 181 157 156 bytes

(M,R,C)->int z=0,c,f,t;for(;R-->0;)for(c=C;c-->0;z+=f>1?0:f)for(f=0,t=9;M[R][c]==8&t-->0;)tryf+=M[R+t/3-1][c+t%3-1]==8?1:0;catch(Exception e)return z;

-24 bytes thanks to @OlivierGrégoire.

Takes the dimensions as additional parameters R (amount of rows) and C (amount of columns).

The cells are checked pretty similar as I did in my Fryer simulator answer.

Try it online.

Explanation:

(M,R,C)-> // Method with integer-matrix as parameter & integer return
 int z=0, // Result-counter, starting at 0
 c,f,t; // Temp-integers, starting uninitialized
 for(;R-->0;) // Loop over the rows:
 for(c=C;c-->0 // Inner loop over the columns:
 ; // After every iteration:
 z+=f==1? // If the flag-integer is larger than 1:
 0 // Leave the result-counter the same by adding 0
 : // Else:
 f) // Add the flag-integer (either 0 or 1)
 for(f=0, // Reset the flag to 0
 t=9;M[R][c]==8& // If the current cell contains an 8:
 t-->0;) // Inner loop `t` in the range (9, 0]:
 tryf+= // Increase the flag by:
 M[R+t/3-1] // If `t` is 0, 1, or 2: Look at the previous row
 // Else-if `t` is 6, 7, or 8: Look at the next row
 // Else (`t` is 3, 4, or 5): Look at the current row
 [c+t%3-1] // If `t` is 0, 3, or 6: Look at the previous column
 // Else-if `t` is 2, 5, or 8: Look at the next column
 // Else (`t` is 1, 4, or 7): Look at the current column
 ==8? // And if the digit in this cell is 8:
 1 // Increase the flag-integer by 1
 :0; // Else: leave it the same
 catch(Exception e) // Catch and ignore ArrayIndexOutOfBoundsExceptions
 // (try-catch saves bytes in comparison to if-checks)
 return z; // And finally return the counter

Python 2, 130 bytes

lambda a:sum(sum(u[~-c*(c>0):c+2].count(8)for u in a[~-r*(r>0):r+2])*8==8==a[r][c]for r in range(len(a))for c in range(len(a[0])))

Try it online!

Powershell, 121 bytes

param($a)(($b='='*4*($l=($a|% Le*)[0]))+($a|%"!$_!")+$b|sls "(?<=[^8]3.$l[^8])8(?=[^8].$l[^8]3)" -a|% m*).Count

Less golfed test script:

$f = %"!$_!")+$border 

@(

,(3,"84565","93848","08615","67982","88742")
,(0,"88","23")
,(0,"534","252")
,(2,"5838")
,(2,"8","0","8")
,(1,"4285","2618","8558")
,(3,"45438182","82778393","98785428","45021869","15434561")
,(1,"8")
,(4,"85816877","99282783","28497327","92971956","69873152","19971882","35681475")
,(3,"818","257","801")
,(0,"")

) | % 
 $expected,$a = $_
 $result = &$f $a
 "$($result-eq$expected): $result : $a"

Output:

True: 3 : 84565 93848 08615 67982 88742
True: 0 : 88 23
True: 0 : 534 252
True: 2 : 5838
True: 2 : 8 0 8
True: 1 : 4285 2618 8558
True: 3 : 45438182 82778393 98785428 45021869 15434561
True: 1 : 8
True: 4 : 85816877 99282783 28497327 92971956 69873152 19971882 35681475
True: 3 : 818 257 801
True: 0 : 

Explanation:

First, the script calculates a length of the first string.

Second, it adds extra border to strings. Augmended reality string likes:

....=========!84565! !93848! !08615! !67982! !88742!===========....

represents the multiline string:

...=====
=======
!84565!
!93848!
!08615!
!67982!
!88742!
=======
========...

Note 1: the number of = is sufficient for a string of any length.

Note 2: a large number of = does not affect the search for eights.

Next, the regular expression (?<=[^8]3.$l[^8])8(?=[^8].$l[^8]3) looks for the digit 8 with the preceding non-eights (?<=[^8]3.$l[^8]) and the following non-eights (?=[^8].$l[^8]3):

.......
<<<....
<8>....
>>>....
.......

Finally, the number of matches is returned as a result.

Jelly, 12 bytes

œẹ8ạṀ¥þ`’Ạ€S

Try it online!

How it works

œẹ8ạṀ¥þ`’Ạ€S Main link. Argument: M (matrix)

œẹ8 Find all multidimensional indices of 8, yielding an array A of pairs.
 þ` Table self; for all pairs [i, j] and [k, l] in A, call the link to the
 left. Return the results as a matrix.
 ạ Absolute difference; yield [|i - k|, |j - l|].
 Ṁ Take the maximum.
 ’ Decrement all the maxmima, mapping 1 to 0.
 Ạ€ All each; yield 1 for each row that contains no zeroes.
 S Take the sum.

JavaScript (ES6), 106 bytes

a=>a.map((r,y)=>r.map((v,x)=>k+=v==8&[...'12221000'].every((d,i,v)=>(a[y+~-d]||0)[x+~-v[i+2&7]]^8)),k=0)|k

Try it online!

Bitwise approach, 110 bytes

a=>a.map(r=>r.map(v=>x=x*2|v==8,x=k=0)|x).map((n,y,b)=>a[0].map((_,x)=>(n^1<<x|b[y-1]|b[y+1])*2>>x&7||k++))&&k

Try it online!

Clojure, 227 198 bytes

(fn[t w h](let[c #(for[y(range %3 %4)x(range % %2)][x y])e #(= 8(get-in t(reverse %)0))m(fn[[o p]](count(filter e(c(dec o)(+ o 2)(dec p)(+ p 2)))))](count(filter #(= 1(m %))(filter e(c 0 w 0 h))))))

Ouch. Definitely not the shortest here by any means. 54 bytes of parenthesis is killer. I'm still relatively happy with it though.

-29 bytes by creating a helper function that generates a range since I was doing that twice, changing the reduce to a (count (filter setup, and getting rid of the threading macro after golfing.

(defn count-single-eights [td-array width height]
 ; Define three helper functions. One generates a list of coords for a given range of dimensions, another checks if an eight is
 ; at the given coord, and the other counts how many neighbors around a coord are an eight
 (letfn [(coords [x-min x-max y-min y-max]
 (for [y (range y-min y-max)
 x (range x-min x-max)]
 [x y]))
 (eight? [[x y]] (= 8 (get-in td-array [y x] 0)))
 (n-eights-around [[cx cy]]
 (count (filter eight?
 (coords (dec cx) (+ cx 2), (dec cy) (+ cy 2)))))]

 ; Gen a list of each coord of the matrix
 (->> (coords 0 width, 0 height)

 ; Remove any coords that don't contain an eight
 (filter eight?)

 ; Then count how many "neighborhoods" only contain 1 eight
 (filter #(= 1 (n-eights-around %)))
 (count))))

(mapv #(count-single-eights % (count (% 0)) (count %))
 test-cases)
=> [3 0 0 2 2 1 3 1 4 3]

Where test-cases is an array holding all the "Python test cases"

Try it online!