tmp

go/stepik/course_3/base/embed_interface.go

@@ -0,0 +1,56 @@
+package main
+
+import (
+	"fmt"
+)
+
+// ------------------------
+
+type Payer interface {
+	Pay(int) error
+}
+
+type Ringer interface {
+	Ring(string) error
+}
+
+type NFCPhone interface {
+	Payer
+	Ringer
+}
+
+type Phone struct {
+	Money int
+}
+
+func (p *Phone) Pay(amount int) error {
+	if p.Money < amount {
+		return fmt.Errorf("Не хватает денег на телефоне")
+	}
+	p.Money -= amount
+	return nil
+}
+
+func (p *Phone) Ring(number string) error {
+	if number == "" {
+		return fmt.Errorf("Please, enter phone")
+	}
+	return nil
+}
+
+func PayForMetWithPhone(phone NFCPhone) {
+	err := phone.Pay(1)
+	if err != nil {
+		fmt.Printf("Ошибка при оплате %v\n\n", err)
+		return
+	}
+	fmt.Printf("Турникет открыт через %T\n\n", phone)
+}
+
+// ------------------------
+
+func main() {
+	myPhone := &Phone{Money: 9}
+	PayForMetWithPhone(myPhone)
+
+}

go/stepik/course_3/base/empty_interface.go

@@ -0,0 +1,61 @@
+package main
+
+import (
+	"fmt"
+	"strconv"
+)
+
+func main() {
+	foo1()
+}
+
+type Payer interface {
+	Pay(int) error
+}
+
+type Stringer interface {
+	String() string
+}
+
+type Wallet struct {
+	Cash int
+}
+
+func (w *Wallet) Pay(amount int) error {
+	if w.Cash < amount {
+		return fmt.Errorf("Не хватает денег на кошельке")
+	}
+	w.Cash -= amount
+	return nil
+}
+
+func (w *Wallet) String() string {
+	return "Кошелек в котором " + strconv.Itoa(w.Cash) + " денег"
+}
+
+func Buy(in interface{}) {
+	var p Payer
+	var ok bool
+	if p, ok = in.(Payer); !ok {
+		fmt.Printf("%T не является платежным интерфейсом\n\n", in)
+		return
+	}
+
+	err := p.Pay(10)
+	if err != nil {
+		fmt.Printf("Ошибка при оплате %T: %v\n\n", p, err)
+		return
+	}
+	fmt.Printf("Спасибо за покупку через %T\n\n", p)
+}
+
+func foo1() {
+	myWallet := &Wallet{Cash: 100}
+	// fmt.Printf("Raw payment : %#v\n", myWallet)
+	// fmt.Printf("Способ оплаты: %s\n", myWallet)
+
+	Buy(myWallet)
+	Buy([]int{1, 2, 3})
+	Buy(3.14)
+
+}

go/stepik/course_3/base/interface.go

@@ -0,0 +1,96 @@
+package main
+
+import "fmt"
+
+func main() {
+	foo1()
+}
+
+type Payer interface {
+	Pay(int) error
+}
+
+// -----------------------------------------------------------------------------
+
+type Wallet struct {
+	Cash int
+}
+
+func (w *Wallet) Pay(amount int) error {
+	if w.Cash < amount {
+		return fmt.Errorf("Не хватает денег в кошельке")
+	}
+	w.Cash -= amount
+	return nil
+}
+
+// -----------------------------------------------------------------------------
+
+type Card struct {
+	Balance    int
+	ValidUntil string
+	Cardholder string
+	CVV        string
+	Number     string
+}
+
+func (c *Card) Pay(amount int) error {
+	if c.Balance < amount {
+		return fmt.Errorf("Не хватает денег на карте")
+	}
+	c.Balance -= amount
+	return nil
+}
+
+// -----------------------------------------------------------------------------
+
+type ApplePay struct {
+	Money   int
+	AppleID string
+}
+
+func (a *ApplePay) Pay(amount int) error {
+	if a.Money < amount {
+		return fmt.Errorf("Не хватает денег на аккаунте")
+	}
+	a.Money -= amount
+	return nil
+}
+
+// -----------------------------------------------------------------------------
+
+// Здесь напрямую нельзя обриться к полю структуры, реализующей интерфейс.
+// Поэтому нужно делать преобразвание.
+func Buy(p Payer) {
+	switch p.(type) {
+	case *Wallet:
+		fmt.Println("Oplata наличными?")
+	case *Card:
+		plasticCard, ok := p.(*Card)
+		if !ok {
+			fmt.Println("Не удалось преобразовать к типу *Card")
+		}
+		fmt.Println("Вставляйте карту,", plasticCard.Cardholder)
+	default:
+		fmt.Println("Что-то новое!")
+	}
+
+	err := p.Pay(10)
+	if err != nil {
+		fmt.Println(err)
+	} else {
+		fmt.Printf("Спасибо за покупку через %T\n\n", p)
+	}
+}
+
+func foo1() {
+	// myWallet := &Wallet{Cash: 100}
+	// Buy(myWallet)
+
+	var myMoney Payer
+	myMoney = &Card{Balance: 100, Cardholder: "rvasily"}
+	Buy(myMoney)
+
+	myMoney = &ApplePay{Money: 9}
+	Buy(myMoney)
+}