系統設計者的話：學英文根本不用背，你講中文，你有在背中文嗎？學英文也是一樣的道理，那是自然而然就會的東西，用背的方式最後肯定都是不行的。 更多...

最好的學習就是有英文的父母，不斷的跟你說話、耐心的教導你，時間長了，你也就慢慢就融入其中了。

但是我們沒有英文父母怎麼辦？看影片學英文就學的起來嗎？學不起來。

我們從小到大，也看過了不少英文電影，至少也看過1、200部也跑不掉，但是為什麼看了這麼多的英文電影，英文還是很爛呢？

主要的原因是我們沒有從基礎性的強化學習。舉個例子，西方的幼兒出生時，他至少聽了各種大人講英文至少聽了2年，才慢慢開始說英文、與大人互動。

而且都是一字一句慢慢的說、慢慢的教、漸進式的、慢慢的、越來越習慣、越來越聽的懂、越來越會說的過程。

那麼我們看的影片、電影過程中，都是大人成熟型的講話速度、方式、語調，我們怎麼可能跟的上？

一旦跟不上，思想中就會產生覺的好難哦、我不行種種念頭，那麼產生了這種潛在式的排斥心理作用，那麼你就更難學的會了。


所以我們必須打好基礎、深厚的基礎，萬丈高樓平地起，唯有打下深厚的基礎，後面你走的路才會越來越順。

程式界裏有句話，程式債欠的越多，最後就只能放棄。學英文也是一樣，英文單字債欠的越多，你就直接上來文法、句型、語調，最後也只能放棄。

基於上述的思維，我打造了這套系統，從最基礎的單字學習起，不斷的強化、加深你對這個單字的聽力，透過各式各樣的影片、各式各樣的人、各種不同的場景。

就只是為了訓練一個單字的聽力，無數的人跟你講同一個單字，講個20遍、50篇、100遍(且不重覆)，我就不信學不起來。


這套系統做出來後，我自己在使用的過程中，確實真的能聽出來他們講的這個單字，而且他們講的速度再快也能聽的出來。

能聽的出來，就知道他講的大概意思；能夠知道他講的大概意思，就能夠用幾個簡單的單字回應；能夠回應，也就能夠對話；當能夠對話，就能夠再修正文法、句型、語調。


我的目地就是希望自己至少能聽的懂人家在說什麼，用英文跟人家對話，大家共同努力、學習。若有其它想法或對這套系統設計的建議，也可以與我聯絡：ichich2013@gmail.com

Android for Java Developers (Big Android BBQ 2015)
觀看次數：506
device
with
a
constrained
cpu
gpu
memory
on
android
and
then
we'll
talk
about
usefulness
or
application
niceness
is
so
there's
there's
sort
of
two
effects
that
they're
constantly
relaunching
all
interrelated
and
contribute
to
the
low-end
devices
are
a
still
being
used
haven't
and
they're
gonna
be
here
for
a
your
application
behaves
reasonably
well
constantly
going
to
be
shoving
everybody
referred
to
as
gc
for
alloc
it's
a
collector
needs
to
run
synchronously
four
phases
of
normal
allocations
and
figure
out
what's
still
referred
to
in
okay
so
on
dalvik
there's
actually
two
collecting
there's
a
pause
time
to
enumeration
phase
and
then
there's
a
and
it
does
that
concurrently
in
art
no
synchronous
pause
during
the
enumeration
phase
it
can
do
that
concurrently
there
is
still
a
small
when
there's
not
a
pause
here
there's
you're
still
taking
up
cycles
to
do
gc
synchronously
we
stop
the
world
so
we
and
cause
a
hiccup
and
then
they're
on
the
order
of
10
to
20
milliseconds
milliseconds
which
is
much
better
it's
the
more
allocations
you're
asking
for
you
are
just
the
foreground
a
of
you
get
fewer
pauses
because
there's
cpu
to
actually
continually
do
this
you
know
mark-and-sweep
and
collect
in
the
you're
constantly
allocating
things
and
and
it's
up
on
proziscom
level
object
that
we're
allocating
the
iceberg
we're
also
allocating
stuff
at
i'll
talk
about
finalizar
later
so
ondraw
and
if
you're
on
draw
is
being
and
on
every
frame
you're
allocating
a
future
animation
at
some
point
you're
you're
in
the
middle
of
an
animation
hang
on
for
a
few
milliseconds
and
that's
what
causes
jank
for
the
user
so
that
only
get
allocated
lazily
so
when
particular
call
if
it's
null
we'll
go
obviously
if
you're
actually
accessing
tricky
if
they're
being
accessed
from
there's
a
bit
more
to
it
there's
things
the
right
trade-off
for
your
code
arrays
it
a
lot
it's
it's
one
of
the
nicer
and
more
streamlined
collections
for
storing
tends
to
be
more
optimal
than
arraylist
reallocation
that
collections
would
do
automatically
speaking
of
collections
I
android
collections
so
their
traditional
java
programming
language
collections
there's
there's
a
bunch
of
collections
in
android
there's
a
ray
map
in
the
support
library
there's
simpler
a
map
then
there's
a
sparse
array
there's
sparse
long
in
sparse
long
in
lots
of
different
combinations
but
they
of
the
auto
boxed
java
language
versions
wouldn't
it
be
nice
methods
that
mutate
traditional
java
programmers
walked
away
didn't
have
to
reallocate
that
thing
all
cached
object
in
the
caller
and
then
call
a
mutate
a
mutating
version
of
that
framework
you'll
see
a
lot
of
instances
of
this
internally
where
we'll
pass
an
you're
you
know
running
an
animation
or
automatically
going
to
box
it's
gonna
collections
there's
no
reason
to
not
use
realizing
why
iterators
is
one
of
my
syntax
I
don't
know
why
it's
called
the
it's
allocating
that
object
then
it's
iterator
object
the
iterator
approach
streamlined
thing
but
it's
still
doing
until
it
creates
the
iterator
and
then
do
this
so
one
of
the
optimization
allocations
that
were
going
on
allocations
and
then
the
animation
would
collecting
language
you're
going
to
allocating
objects
for
listeners
what
it
doesn't
advance
to
the
first
one
if
reads
there's
nuances
to
using
them
finalized
errs
is
nuances
in
the
declared
on
your
class
you're
basically
require
finalized
errs
we
do
use
them
map
works
so
there's
there's
a
situation
with
static
initialization
is
a
good
tuned
to
android
there
was
the
dagger
a
logo
saying
mobile-friendly
but
you
that
we've
seen
with
third-party
code
is
mechanisms
that
android
provides
to
help
you're
keeping
thick
cached
thumbnails
also
want
to
work
adequately
on
512
meg
things
don't
overdraw
there
are
there's
overdraw
I
don't
know
what
it
is
cult
the
overdraw
is
on
the
device
it
paints
in
a
lovely
palette
of
pastel
colors
it
painters
fill
algorithm
tell
us
to
in
the
order
of
back-to-front
listview
you've
painted
each
of
the
pixels
in
those
characters
five
or
six
the
the
opacity
the
backgrounds
that
your
overdraw
is
like
red
is
bad
i'll
avoiding
null
window
backgrounds
so
one
itself
so
like
we're
animating
in
you
because
there's
undefined
contents
in
effectively
you
can
brand
your
particularly
ineffective
approaches
they're
like
okay
well
we'll
have
a
shouldn't
be
so
inflation
tends
to
be
a
synchronously
off
the
ui
thread
doing
that's
not
visual
that's
not
ui
synchronously
right
so
you
could
spawn
that's
kind
of
the
the
physically
the
animation
run
an
animation
basically
rewind
to
set
up
the
animation
to
rewind
and
then
like
30
frames
a
second
60
frames
a
allocating
a
bunch
of
stuff
in
ondraw
or
is
reasonably
smooth
if
it
was
hierarchies
I
alluded
to
this
before
layout
traversal
for
rendering
all
of
associations
that's
probably
fine
nested
lettering
or
layouts
to
get
the
hierarchies
at
some
point
it's
much
more
initializers
like
not
inflating
all
of
otherwise
you
know
they've
clicked
the
rendering
of
that
thing
there's
the
milliseconds
i'm
super
fast
and
then
the
layout
or
you're
not
reusing
the
view
when
getview
is
called
on
your
listview
gl
like
there's
a
lot
of
associations
i'm
i'm
doing
my
perform
traversals
here
runtime
that's
going
to
be
allocating
objects
you
can't
avoid
run
that
animation
and
then
see
what's
being
allocated
during
the
animation
and
during
the
animation
but
if
you
can't
animation
trace
view
there's
two
versions
of
it
there's
a
sampling
as
well
as
a
non
sampling
instrumented
you're
not
optimizing
the
wrong
thing
you're
using
the
instrumented
version
use
and
more
tuned
for
android
dynamics
there's
there's
a
possibly
an
easier
android
studio
and
then
there's
on
or
whatever
gpu
profiling
there's
the
of
the
various
phases
of
rendering
so
you're
just
consistently
taking
too
much
debugging
animations
because
I
really
updating
information
that
is
currently
for
q&a

相關影片

加Line好友 每日8AM 推播1單字

加入好友

其他人正在學習的單字

1. work
2024-04-29 07:44
2. well
2024-04-29 07:44
3. porter
2024-04-29 07:44
4. got
2024-04-29 07:44
5. cupboard
2024-04-29 07:44
6. jersey
2024-04-29 07:43
7. block
2024-04-29 07:43
8. object
2024-04-29 07:43
9. amount
2024-04-29 07:43
10. kiss
2024-04-29 07:43
11. young
2024-04-29 07:43
12. request
2024-04-29 07:43
13. faster
2024-04-29 07:43
14. perform
2024-04-29 07:43
15. than
2024-04-29 07:43

本月觀看影片單字排行榜

本月查閱單字排行榜

本月聆聽單字排行榜