C++ OOP Black-Scholes

OOP & Java

3 Key characters of Object Oriented Programming with examples

Posted by Chauncey on May 23, 2020

封装 Encapsulation

public class Person{
    private String name;
    private int age;

    public int getAge(){
      return age;
    }

    public String getName(){
      return name;
    }

    public void setAge(int age){
      this.age = age;
    }

    public void setName(String name){
      this.name = name;
    }
}
  • 这段代码中，将 name 和 age 属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。
  • 代码中的这些public方法是外部类访问该类成员变量的入口。通常情况下，这些方法被称为getter和setter方法。因此，任何要访问类中私有成员变量的类都要通过这些getter和setter方法。

继承 Inheritance

概述

子类继承父类的特征和行为

“is-a“原则：

  • 食肉动物 is a 动物
  • Every manager is an employee

class 父类 {
}
 
class 子类 extends 父类 {
}


public class Manager extends Employee { 
  added methods and fields 
}

为什么要继承

  • 避免重复代码，代码简洁
  • 维护性提高

Manager 中很多fields 和 method可以直接用它的父类（Employee）中的

public class Penguin { 
    private String name; 
    private int id; 
    public Penguin(String myName, int  myid) { 
        name = myName; 
        id = myid; 
    } 
    public void eat(){ 
        System.out.println(name+"正在吃"); 
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() { 
        System.out.println("大家好！我是"         + id + "号" + name + "."); 
    } 
}

public class Mouse { 
    private String name; 
    private int id; 
    public Mouse(String myName, int  myid) { 
        name = myName; 
        id = myid; 
    } 
    public void eat(){ 
        System.out.println(name+"正在吃"); 
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() { 
        System.out.println("大家好！我是"         + id + "号" + name + "."); 
    } 
}

Penguin和Mouse具有相同的 属性（姓名，id），方法（吃，睡，自我介绍），冗余重复 可以建立一个Animal类就作为父类，然后企鹅类和老鼠类继承这个类之后，就具有父类当中的属性和方法

public class Animal { 
    private String name;  
    private int id; 
    public Animal(String myName, int myid) { 
        name = myName; 
        id = myid;
    } 
    public void eat(){ 
        System.out.println(name+"正在吃"); 
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() { 
        System.out.println("大家好！我是"         + id + "号" + name + "."); 
    } 
}

public class Penguin extends Animal { 
    public Penguin(String myName, int myid) { 
        super(myName, myid); 
    } 
}

public class Mouse extends Animal { 
    public Mouse(String myName, int myid) { 
        super(myName, myid); 
    } 
}

特性

继承类型

Java 的继承是单继承，但是可以多重继承，这是 Java 继承区别于 C++ 继承的一个特性。

多态 Polymorphism

多态是同一个行为具有多个不同表现形式或形态的能力。

现实中，比如我们按下 F1 键这个动作：

  • 如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；
  • 如果当前在 Word 下弹出的就是 Word 帮助；
  • 在 Windows 下弹出的就是 Windows 帮助和支持。

同一个事件发生在不同的对象上会产生不同的结果。

父类 name = new 子类()

“编译看左边，运行看右边”

public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 对象调用 show 方法
      show(new Dog());  // 以 Dog 对象调用 show 方法
                
      Animal a = new Cat();  // 向上转型  
      a.eat();               // 调用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下转型  
      c.work();        // 调用的是 Cat 的 work
  }  
            
    public static void show(Animal a)  {
      a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

重写 Override & 重载 Overload

方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载可以理解成多态的具体表现形式。

抽象类

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

  • 由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。

  • 成员变量、成员方法和构造方法的访问方式和普通类一样

以下代码摘抄自燕十八公益课堂，虽是php，但是想表达的逻辑可以借鉴一下

/*
春秋战国时期,燕零七 飞行器专家,能工巧匠. 
他写了一份图纸---飞行器制造术 
飞行器秘制图谱 
1: 要有一个有力的发动机，喷气式. 
2: 要有一个平衡舵，掌握平衡 
他的孙子问: 发动机怎么造呢? 
燕零七眼望夕阳: 我是造不出来,但我相信后代有人造出来 
燕零七的构想在当时的科技造不出来,即这个类只能在图纸化,无法实例化.
***/ 

// 此时这个类没有具体的方法去实现,还太抽象. 
// 因此我们把他做成一个抽象类 
abstract class FlyIdea { 
    // 大力引擎,当时也没法做,这个方法也实现不了,因此方法也是抽象的 
    public abstract function engine();
   
    // 平衡舵 
    public abstract function blance(); 
    /* 
        注意:抽象方法 不能有方法体 
        下面这样写是错误的 
        public abstract function blance() { 
        } 
        Fatal error: Abstract function FlyIdea::engine() cannot contain body 
    */ 
} 

/* 
抽象类不能 new 来实例化 
下面这行是错误的 
$kongke = new FlyIdea(); 
Cannot instantiate abstract class FlyIdea 
*/ 

// 到了明朝,万户用火箭解决了发动机的问题 
abstract class Rocket extends FlyIdea { 
    // 万户把engine方法,给实现了,不再抽象了 
    public function engine() { 
        echo '点燃火药,失去平衡,嘭!<br />'; 
    } 
    // 但是万户实现不了平衡舵,因此平衡舵对于Rocket类来说,还是抽象的,类也是抽象的 
    // 此处由于继承父类的也是抽象类,所以可以不必完成抽象类中的所有抽象方法;
} 

/* 
到了现代,燕十八亲自制作飞行器 
这个Fly类中,所以抽象方法,都已经实现了,不再是梦想. 
*/  

//到了这个类就必须要完成所有的抽象方法;
class Fly extends Rocket{ 
    public function engine() { 
        echo '有力一扔<br />'; 
    } 
    public function blance() { 
        echo '两个纸翼保持平衡~~~'; 
    } 
    public function start() { 
        $this->engine(); 
        for($i=0;$i<10;$i++) { 
            $this->blance(); 
            echo '平稳飞行<br />'; 
        } 
    } 
} 
$apache = new Fly(); 
$apache->start();

应用场景

  • 如果你拥有一些方法并且想让它们中的一些有默认实现，那么使用抽象类吧。
  • 如果你想实现多重继承，那么你必须使用接口。由于Java不支持多继承，子类不能够继承多个类，但可以实现多个接口。因此你就可以使用接口来解决它。
  • 如果基本功能在不断改变，那么就需要使用抽象类。如果不断改变基本功能并且使用接口，那么就需要改变所有实现了该接口的类。
/***  
====笔记部分====  
面向对象的一个观点:  
做的越多,越容易犯错  
抽象类{就定义类模板}--具体子类实现{china,japan,english}  
接口:  
***/   

// 抽象的数据库类   
/*  
创业做网站  
到底用什么数据库?  mysql, oracle,sqlserver,postgresql?  
这样:先开发网站,运行再说.  
先弄个mysql开发着,正式上线了再换数据库也不迟  
引来问题:  
换数据库,会不会以前的代码又得重写?  
答:不必,用抽象类  
开发者,开发时,就以db抽象类来开发.  
*/   
abstract class db {   
    public abstract function connect($h,$u,$p);   
    public abstract function query($sql);   
    public abstract function close();   
}   
/*   
// 下面这个代码有误  
// 因为子类实现时, connect和抽象类的connect参数不一致  
class mysql extends db {  
    public function connect($h,$h) {  
        return true;  
    }  
    public function query($sql,$conn) {  
    }  
    public function close() {  
    }  
}  
*/   
/*  
下面这个mysql类,严格实现了db抽象类  
试想: 不管上线时,真正用什么数据库  
我只需要再写一份如下类  
class oracle extends db {  
}  
class mssql extends db {  
}  
class postsql extends db {  
}  
业务逻辑层不用改?  
为什么不用改?  
因为都实现的db抽象类.  
我开发时,调用方法不清楚的地方,我就可以参考db抽象类.  
反正子类都是严格实现的抽象类.  
*/   
class mysql extends db {   
    public function connect($h,$h,$u) {   
        return true;   
    }   
    public function query($sql) {   
    }   
    public function close() {   
    }   
}   

/*  
接口 就更加抽象了  
比如一个社交网站,  
关于用户的处理是核心应用.  
登陆  
退出  
写信  
看信  
招呼  
更换心情  
吃饭  
骂人  
捣乱  
示爱  
撩骚  
这么多的方法,都是用户的方法,  
自然可以写一个user类,全包装起来  
但是,分析用户一次性使不了这么方法  
用户信息类:{登陆,写信,看信,招呼,更换心情,退出}  
用户娱乐类:{登陆,骂人,捣乱,示爱,撩骚,退出}  
开发网站前,分析出来这么多方法,  
但是,不能都装在一个类里,  
分成了2个类,甚至更多.  
作用应用逻辑的开发,这么多的类,这么多的方法,都晕了.  
*/   
interface UserBase {   
    public function login($u,$p);   
    public function logout();   
}   
interface UserMsg {   
    public function wirteMsg($to,$title,$content);   
    public function readMsg($from,$title);   
}   
interface UserFun {   
    public function spit($to);   
    public function showLove($to);   
}   
/*  
作为调用者, 我不需要了解你的用户信息类,用户娱乐类,  
我就可以知道如何调用这两个类  
因为: 这两个类 都要实现 上述接口.  
通过这个接口,就可以规范开发.  
*/   
/*  
下面这个类,和接口声明的参数不一样,就报错,  
这样,接口强制统一了类的功能  
不管你有几个类,一个类中有几个方法  
我只知道,方法都是实现的接口的方法.  
*/   
class User implements UserBase {   
    public function login($u) {   
    }   
}
CATALOG
    FEATURED TAGS
    Black-Scholes Python DataFrame AI for Trading Pandas T-test Factor Alpha C++ OOP High Frequency Trading Notes Strategy
    FRIENDS