Co oznacza "abstrakt nad"?

Dla pierwszego przybliżenia, możliwość "abstrakcji nad" czymś oznacza, że zamiast używać tego czegoś bezpośrednio, możesz zrobić z tego parametr lub w inny sposób użyć go "anonimowo".

Scala pozwala na abstrakcyjne typy, pozwalając klasom, metodom i wartościom mieć parametry typu, A wartości abstrakcyjne (lub anonimowe) typy.

Scala pozwala na abstrakcję nad akcjami, pozwalając metodom na posiadanie parametrów funkcji.

Scala pozwala na abstrakcyjny nad cechami, pozwalając definiować typy strukturalnie.

Scala pozwala na abstrakcję nad parametrami typu, pozwalając na parametry typu wyższego rzędu.

Scala pozwala na abstrakcję wzorców dostępu do danych, pozwalając na tworzenie ekstraktorów.

Scala pozwala na abstrakcję nad "rzeczami, które mogą być używane jako coś innego", zezwalając na niejawne konwersje jako parametry. Haskell robi podobnie z klasami typu.

Scala nie pozwala (jeszcze) ty do abstrakcji nad klasami. Nie można przekazać klasy do czegoś, a następnie użyć tej klasy do tworzenia nowych obiektów. Inne języki pozwalają na abstrakcję nad klasami.

("monady abstrakcyjne nad konstruktorami typów" są prawdziwe tylko w bardzo restrykcyjny sposób. Nie daj się zawiesić, dopóki nie będziesz miał swojego " Aha! Rozumiem monady!!"moment.)

Umiejętność abstrakcji nad pewnym aspektem obliczeń jest w zasadzie tym, co pozwala na ponowne użycie kodu i umożliwia tworzenie bibliotek funkcjonalność. Scala pozwala na wiele więcej rodzajów rzeczy do abstrahowania niż więcej języków głównego nurtu, a biblioteki w Scali mogą być odpowiednio potężniejsze.

Abstrakcja jest rodzajem uogólnienia.

Http://en.wikipedia.org/wiki/Abstraction

Nie tylko w Scali, ale w wielu językach istnieje potrzeba posiadania takich mechanizmów, aby zmniejszyć złożoność (lub przynajmniej stworzyć hierarchię dzielącą informacje na łatwiejsze do zrozumienia fragmenty).

Klasa jest abstrakcją nad prostym typem danych. Jest to coś w rodzaju podstawowego typu, ale w rzeczywistości je uogólnia. Tak więc klasa jest czymś więcej niż prostym typem danych, ale ma wiele rzeczy z nim wspólne.

Kiedy mówi "abstrakcja", ma na myśli proces, za pomocą którego uogólniasz. Jeśli więc abstrakcjonizujesz metody jako parametry, uogólniasz proces robienia tego. na przykład, zamiast przekazywania metod do funkcji możesz stworzyć jakiś rodzaj uogólnionego sposobu obsługi(np. nie przekazywanie metod w ogóle, ale budowanie specjalnego systemu do radzenia sobie z nimi).

W tym przypadku konkretnie chodzi o proces abstrakcji problemu i tworzenie oop jak rozwiązanie problemu. C ma bardzo małą zdolność do abstrakcji(można to zrobić, ale robi się bałagan bardzo szybko i język nie obsługuje go bezpośrednio). Jeśli napisałeś go w C++, możesz użyć pojęć oop, aby zmniejszyć złożoność problemu(cóż, jest to ta sama złożoność, ale konceptualizacja jest ogólnie łatwiejsza(przynajmniej raz nauczysz się myśleć w kategoriach abstrakcji)).

Na przykład, jeśli potrzebowałem specjalnego typu danych, który był jak int, ale powiedzmy ograniczony I czy abstrakt nad nim, tworząc nowy typ, który może być używany jak int, ale miał te właściwości, których potrzebowałem. Proces, którego użyłbym do zrobienia takiej rzeczy, nazwałby się "abstrakcją".

Oto moja wąska interpretacja show I tell. To jest oczywiste i działa w REPL.

class Parameterized[T] { // type as a parameter
  def call(func: (Int) => Int) = func(1)  // function as a parameter
  def use(l: Long) { println(l) } // value as a parameter
}

val p = new Parameterized[String] // pass type String as a parameter
p.call((i:Int) => i + 1) // pass function increment as a parameter
p.use(1L) // pass value 1L as a parameter


abstract class Abstracted { 
  type T // abstract over a type
  def call(i: Int): Int // abstract over a function
  val l: Long // abstract over value
  def use() { println(l) }
}

class Concrete extends Abstracted { 
  type T = String // specialize type as String
  def call(i:Int): Int = i + 1 // specialize function as increment function
  val l = 1L // specialize value as 1L
}

val a: Abstracted = new Concrete
a.call(1)
a.use()

Inne odpowiedzi dają już dobre wyobrażenie o tym, jakie rodzaje abstrakcji istnieją. Przejdźmy do cudzysłowów jeden po drugim i podaj przykład:

Można przekazać metody (lub " funkcje") jako parametry, lub można abstrakcyjne nad nimi. Możesz określić typy jako parametrów, albo można nad oni.

Funkcja Pass jako parametr: List(1,-2,3).map(math.abs(x)) wyraźnie abs jest tutaj przekazywana jako parametr. map sama abstrakcja nad funkcją wykonującą pewien specjalny rzecz z każdym elementem listy. val list = List[String]() określa typ paramter (String). Możesz napisać typ kolekcji, który zamiast tego używa elementów typu abstrakcyjnego: val buffer = Buffer{ type Elem=String }. Jedna różnica polega na tym, że musisz napisać def f(lis:List[String])..., ale def f(buffer:Buffer)..., więc Typ elementu jest jakby "ukryty" w drugiej metodzie.

Konsekwencja naszych transmisji wydarzeń bycie wartościami pierwszej klasy polega na tym, że my może nad nimi dominować.

W huśtawce zdarzenie po prostu "dzieje się" znikąd i musisz sobie z tym poradzić tutaj i teraz. Strumienie zdarzeń pozwalają wykonać wszystkie instalacje hydrauliczne i okablowanie w bardziej deklaratywny sposób. Np. gdy chcesz zmienić odpowiedzialnego słuchacza w swingu, musisz wyrejestrować Starego i zarejestrować nowego, a także znać wszystkie szczegóły (np. wątki). W przypadku strumieni zdarzeń, źródło zdarzeń staje się rzeczą, którą można po prostu przekazać, dzięki czemu nie różni się zbytnio od strumienia bajtów lub znaków, stąd bardziej "abstrakcyjna" koncepcja.

Typ abstrakcyjny członkowie zapewniają elastyczne sposób na abstrakcję nad konkretnymi rodzajami komponenty.

Powyższa Klasa bufora jest już tego przykładem.

Odpowiedzi powyżej dostarczają doskonałego wyjaśnienia, ale podsumowując je w jednym zdaniu, powiedziałbym:

abstrakcja nad czymś jest tym samym, co zaniedbywanie tego tam, gdzie nie ma znaczenia .