面向对象及三大特征

最新推荐文章于 2022-07-05 08:19:51 发布

workingman_li

最新推荐文章于 2022-07-05 08:19:51 发布

阅读量167

点赞数

分类专栏：后端基础

后端基础专栏收录该内容

20 篇文章 0 订阅

订阅专栏

面向对象 oop : object oriented programming
面向过程和面向对象，是两种不同的编程方式
对比面向过程的特点了解，可以更好的了解什么是面向对象

过程和函数(都是对一段功能的代码进行封装)
过程：是早期的一个编程概念
过程类似于函数，只能执行，但是没有返回值
函数：不仅能执行，还可以返回结果(return)

面向过程和面向对象的基本概念

面向过程：—侧重于怎么做？
1.把完成某一个需求的所有步骤从头到尾逐步实现
2.根据开发要求，将某些功能独立的代码封装成一个又一个函数
3.最后完成的代码，就是顺序的调用不同的函数
特点：
1.注重步骤与过程，不注重职责分工
2.如果需求复杂，代码会变得很复杂
3.开发复杂项目，没有固定的套路，开发难度很大

面向对象：–谁来做?
相比较函数，面向对象是更大的封装，根据职责在一个对象中封装多个方法
1.在完成某一个需求前，首先确定职责–要做的事(方法)
2.根据职责确定不同的对象，在对象内部封装不同的方法(多个)即我们所说的函数。
3.最后完成代码，就是顺序的让不同的对象调用不同的方法
特点：
1.注重对象和职责，不同的对象承担不同的职责
2.更加适合对复杂的需求变化，是专门应对复杂项目的开发，提供的固定套路
3.需要在面向过程的基础上，再学习一些面向对象的语法

熟悉面向对象编程
python java c++

类:是对一群具有相同特征或行为的事物的一个统称（抽象），不能直接使用(比如：飞机制造图纸不能飞上天)
特征:属性
行为：方法
对象：由类创建出来的一个具体的存在，可以直接使用(用图纸制造出来的飞机可以飞上天)

注意！！！在程序开发中：应该先有类再有对象

类的设计
1.类名：这类事物的名字，满足大驼峰命名法
大驼峰命名法
每一个单词的首字母大写
单词与单词之间没有下划线
2.属性：这个类创建出的对象有什么样的特征
3.方法：这个类创建出的对象有什么样的行为

注意！！！面向对象的三大特点：
1.封装：根据职责将属性和方法封装到一个抽象的类中

2.继承:实现代码的重用，相同的代码不需要重复的写

3.多态：(以封装和继承为前提)，不同的子类对象调用相同的方法，产生不同的执行结果

封装

1.封装是面向对象编程的一大特点

2.面向对象编程的第一步将属性和方法封装到一个抽象的类中(为什么说是抽象的，因为类不能直接使用)

3.外界使用类创建对象，然后让对象调用方法

4.对象方法的细节都被封装在类的内部

例1、

#定义一个Person类

public class Person {

private String name ;

private Integer age ;

private Double weight ;

//空参数构造，继承父类构造
public Person() {
	super();
	// TODO Auto-generated constructor stub
}

//含参数构造（全参数构造）
public Person(String name, Integer age, Double weight) {
	super();
	this.name = name;
	this.age = age;
	this.weight = weight;
}
//getter/setter方法
}
//含有的方法
public void run(String name) {
	
	System.out.println(name + "跑的方法");
}
	public void eat(String name) {
	
	System.out.println(name + "吃的方法");
}

同一个类创建出来的多个对象之间，属性互不干扰

Person xm = new Person('小丽',18， 45.0)；
xm.run()
xm.eat()

注意：对于两个类等的使用且相互有使用和被使用的关系，则被使用的类应该先开发

继承

单继承

继承的概念:子类拥有父类的所有属性和方法,目的是实现代码的重用，相同的代码不需要重复的写。

继承的语法

class 类名(父类)：

     使用关键字**extends**标识java中两个类之间的继承关系

例1：

创建一个Animal类

public class Animal {
	public String name ;
	
	public Integer age ;
	
	public void eat(){
		
	}
	
}

#创建一个Cat类（其中Cat类是Animal类的子类）

子类继承父类的所有属性和方法并且子类创建自己独特的属性方法

class Cat extends Animal{
	
	private String color;
	
	public void catchMouse(){
		
	}
}

Cat lily =new Cat()；
lily.eat()
lilyatchMouse()

总结：

子类继承自父类，可以直接享受父类中已经封装好（非私有的）的属性和方法

子类中应该根据自己的职责，封装子类特有的属性和方法

注意：

以上所说的继承，可以有以下两种说法，意思是一样的

说法1：Cat类是Animal类的子类，Animal类是Cat类的父类，Cat从Animal类继承

说法2：Cat类是Animal类的派生类，Animal类是Cat类的基类，Cat类从Animal类派生

应该注意：平级之间没有任何必然联系

总结：

继承的传递性，子类拥有父类的父类的属性和方法

继承的传递性：（爷爷父亲儿子）

1.Muyang类从Dog类继承，Dog类又从Animal类继承

2.那么Muyang类就具有Dog类和Animal类的所有属性和方法

子类Muyang拥有父类以及父类的父类中封装的所有属性和方法

例3：

重写父类方法 1：

    1.覆盖父类的方法

    class Animal:
        def eat(self):
            print '吃'
     
        def drink(self):
            print '喝'
     
        def run(self):
            print '跑'
     
        def sleep(self):
            print '睡'
     

class Cat(Animal):
    # 子类拥有父类的所有属性和方法
    def call(self):
        print '喵喵'
 
class Hellokitty(Cat):
    def speak(self):
        print '我可以说中文'
 
    def call(self):
        # 针对子类特有的需求，编写代码，这种情况下子类重写了父类的方法
        print '你很调皮'
        kt = Hellokitty()

如果子类中，重写了父类的方法，在运行中，只会调用在子类中重写的父类的方法而不会调用父类的方法

kt.call()

例4：

重写父类方法2：

    2.扩展父类的方法

class Animal:
    def eat(self):
        print '吃'
 
    def drink(self):
        print '喝'
 
    def run(self):
        print '跑'
 
    def sleep(self):
        print '睡'
 
class Cat(Animal):
    # 子类拥有父类的所有属性和方法
    def call(self):
        print '喵喵'
 
class Hellokitty(Cat):
    def speak(self):
        print '我可以说中文'
 
    def call(self):
        # 针对子类特有的需求，编写代码
        print '你很调皮'
        # 调用原本在父类中封装的代码
        Cat.call(self)
        # 增加其他的子类代码
        print '@#￥Y%……&**&……%Y￥#@'
 
kt = Hellokitty()
kt.call()

总结：

若重写了父类的方法，则调用的时候只调用子类而不调用父类；

但若子类在写的时候还调用了父类，则相当于父类的扩展，调用的时候子类重写的方法和父类已有的方法一起调用。

例5：

定义属性注意的事项：

class Bird:
    def __init__(self):
        self.hungry = True
 
    # 鸟吃过了以后就不饿了
    def eat(self):
        if self.hungry:
            print 'I am eating'
            self.hungry = False
        else:
            print 'No thanks'
 
class SongBird(Bird):
    def __init__(self):
        self.sound = 'Zd0ci!'
        #注意：
        Bird.__init__(self)
 
    def sing(self):
        print self.sound
 
little_bird = SongBird()
little_bird.eat()
little_bird.sing()


例5：

        多继承可以让子类对象，同时具有多个父类的属性和方法

class A(object):
    def test(self):
        print 'A-----test 方法'

    def demo(self):
        print 'A-----demo 方法'

class B(object):
    def test(self):
        print 'B------test 方法'

    def demo(self):
        print 'B-------demo方法'

class C(B, A):
    """多继承可以让子类对象，同时具有多个父类的属性和方法"""
    pass

创建子类对象

c = C()
c.test()
c.demo()

若将上面的class C(B, A)换成class C(A, B)

则结果为：

多态：

    (以封装和继承为前提)，不同的子类对象调用相同的方法，产生不同的执行结果

例如：

定义一个类

人类
work(self):

创建两个子类
程序员设计师
这两个子类调用了相同的方法

产生的结果如下：

class Dog(object):
    def __init__(self, name):
        self.name = name
 
    def work(self):
    print '%s 正在工作' % self.name



class xiaotiandog(Dog):
    # 父类方法不能满足子类的方法，重写game方法
    def game(self):
        # 在使用继承时，子类拥有父类的所有属性和方法
        print '%s 飞到天上玩...' % self.name
 

     
    class Person(object):
        def __init__(self, name):
        self.name = name
 
    def game_with_dog(self, dog):
        print '%s 和 %s 快乐的玩耍' % (self.name, dog.name)
        # 让狗玩耍
        dog.game()