day15-面向对象总结

Posted 2023-03-30 王薇蕴

Code Mind

根据面对问题不同人层显出来的思维模式不同，可以将编程思维分为三种：

1. 面向过程编程(穷人思想) - 遇到问题马上想到是解决这个问题的具体逻辑和步骤

2. 函数式编程(小资思想) - 遇到问题马上想到有没有一个已经存在的函数可以解决这个问题，如果没有就造一个 （一个函数只具备一个功能） - 函数

3. 面向对象编程(富豪思想) - 遇到问题马上想到有没有一个具有这个功能的对象，如果没有就造对象（一个对象可以同时具有多个功能）- 类和对象

---

Class And Object

1. 什么是类？什么是对象？

类：

类就是拥有相同功能或者相同属性的对象的集合。 (类是抽象的概念)

对象：

对象就是类的实例。(对象是类具体的表现)

2.定义类 - 创建类

• 1）定义类： 用来代码来描述你的这个类是拥有哪些相同功能(用函数)和哪些相同属性(用变量)的对象的集合。

• 2）语法：

  class 类名:
      类的说明文档
      类的内容(包含方法和属性)
  

• 3）说明：

  • a. class - 关键字；固定写法
  • b. 类名 - 由程序员自己命名
    两个要求：是标识符；不是关键字
    规范：见名知义；不使用系统的函数名、类名和模块名; 猜用驼峰式命名(大驼峰)
  • c. 类的说明文档 - 本质就是一个多行注释
  • d. 类的内容 - 包含定义在类中的函数(方法)和定义在类中的变量(属性)
    方法包括：对象方法、类方法、静态方法
    属性包括：类属性、对象属性

user_name - PEP8

userName - 小驼峰

UserName - 大驼峰

class Dog:
    """这是狗"""
    pass

3.创建对象

对象是通过类来创建的。

语法： 类名()

dog1 = Dog()
dog2 = Dog()
print(dog1)
print(dog2)

---

Method

1.什么是方法

定义在类中函数就是方法

2. 不同的方法的使用

• 1）对象方法
  • a.怎么定义: 直接定义在类中的函数就是对象方法
  • b.怎么调用: 以 对象.xxx() 的形式来调用
  • c.特点：自带参数self，调用函数的时候self不需要传参，系统自动将当前对象传给self(谁调用self指向谁)
• 2）类方法
  • a.怎么定义: 定义函数前添加装饰器 @classmethod
  • b.怎么调用: 以 类名.xxx()'的形式来调用
  • c.特点: 自带参数cls，调用函数的时候cls不需要传参，系统会自动将当前类传给cls
• 3）静态方法
  • a.怎么定义：定义函数前添加装饰器 @staticmethod
  • b.怎么调用：以 类名.xxx()'的形式来调用
  • c.特点：没有特点

class A:
    # func1、func2是对象方法
    def func1(self):
        # self = a1
        print(f'self:self')
        print('对象方法')

    def func2(self, a, b=2):
        print(f'对象方法2，a:a, b:b')

    # func3是类方法
    @classmethod
    def func3(cls):
        print(f'cls:cls')
        print('类方法')

    # func4是静态方法
    @staticmethod
    def func4():
        print('静态方法')



a1 = A()
a2 = A()
print(f'a1:a1')
print(f'a2:a2')

# 通过对象调用对象方法
a2.func1()
a1.func2(100)
a1.func2(100, 200)
a1.func2(b=2000, a=1000)

# 通过类调用类方法
print(f'A:A')
A.func3()

# 通过类调用静态方法
A.func4()


class Math:
    @staticmethod
    def sum(n1, n2):
        pass

    @staticmethod
    def factorial(num):
        pass

class C:
    def func1(self):
        print('对象方法')

    def __init__(self):
        print(f'========self:self==========')
        print('魔法方法1')
        print(100)

    def __gt__(self, other):
        print('魔法方法2')
        return False

    # def __repr__(self):
    #     print('魔法方法3')
    #     return 'abc'


c1 = C()
# c1.func1()
c2 = C()

print(c1 > c2)

print(c1)

---

Init Method

1. 魔法方法

• 1)魔法方法的特点：

  • a.函数名以 __ 开头，并且以` __ 结尾
  • b.魔法方法不需要程序员自己调用，系统会在特地情况下自动调用

• 2)两个常见的魔法方法

  • a.__init__
    如果在类中添加了__init__方法，那么在创建当前类的对象的时候就会自动调用它;
    创建对象的时候需不需要实参，需要几个实参，由类中的__init__决定

  • b.__repr__
    如果类中添加了__repr__方法，打印类的对象的时候会自动调用这个方法，并且将这个方法对应返回作为打印结果进行打印。
    在类中添加__repr__方法的时候，这个方法的返回值必须是字符串。

class A:
    def __init__(self):
        print('init方法被调用')


a1 = A()
a2 = A()
print(a1)

class B:
    def __init__(self, m, n):
        print(f'm:m, n:n')

    def __repr__(self):
        return '<B的对象>'


b1 = B(10, 20)
b2 = B(m=100, n=200)

print(b1)

class Student:
    def __init__(self, name, age=18, gender='男'):
        self.name = name
        self.age = age
        self.gender = gender

    def __repr__(self):
        # self = stu1
        return f'姓名:self.name, 年龄:self.age, 性别:self.gender'


stu1 = Student('小明')
stu2 = Student('小花', 17, '女')
print(stu1)
print(stu2)

---

Attribute

属性 - 定义在类中变量

1.类中的属性分为：类属性、对象属性

• 1)类属性

  • a.怎么定义：直接在类中定义的变量就是类属性
  • b.怎么使用：以 类名.xxx 的方式使用
  • c.什么时候用：如果属性值不会因为对象不同而不一样，就定义成类属性

• 2)对象属性

  • a.怎么定义：以 self.属性名 = 属性值的形式定义在__init__方法中
  • b.怎么使用：以 对象.xxx的方式使用
  • c.什么时候用：属性值会因为对象不同而不一样，就定义成对象属性

class A:
    # m、name是类属性
    m = 10
    name = '张三'

    # x和n是对象属性
    def __init__(self):
        self.x = 10
        self.n = 'hello'


# 通过类使用类属性
print(A.m)
print(A.name)

# 通过对象使用对象属性
a1 = A()
print(a1.x)
print(a1.n)




class Dog:
    def __init__(self, name, breed, age=3, gender='公'):
        self.name = name
        self.age = age
        self.gender = gender
        self.breed = breed


# dog1 = Dog()
# dog1.name = '小黑'

# dog2 = Dog()
# dog2.name = '土豆'

dog1 = Dog('小黑', '土狗')
dog2 = Dog('土豆', '泰迪')
print(dog1.name, dog2.name)


class Circle:
    pi = 3.1415926

    def __init__(self, r=0):
        self.r = r

    # 如果对象方法中需要用到对象属性，由self来提供
    def area(self):
        return Circle.pi * self.r ** 2


c1 = Circle(10)
print(c1.area())

c1.r = 20
print(c1.area())

---

Inherit

1.继承

继承： 让子类直接拥有父类的属性和方法
子类 - 继承者
父类 - 被继承的类

2. 继承语法

语法：
class 类名(父类1, 父类2, 父类3,...):
    类的说明文档
    类的内容

注意：定义类的时候没有写父类，那么这个类会默认继承 object(基类)注意：定义类的时候没有写父类，那么这个类会默认继承 object基类)

class A:
    m = 100

    def __init__(self):
        self.n = 200

    def func1(self):
        print('对象方法')

    @classmethod
    def func2(cls):
        print('类方法')

    @staticmethod
    def func3():
        print('静态方法')


class B(A):
    # 添加新的类属性
    x = 'hello'

    # 添加新的对象属性
    def __init__(self):
        super().__init__()     # 调用当前类的父类的__init__
        # super(B, self).__init__()
        self.p = 1000

    # 添加新的方法
    def func11(self):
        print('对象方法2')

    @classmethod
    def func22(cls):
        print('类方法2')

    @staticmethod
    def func33():
        print('静态方法2')


b1 = B()

# 使用A中的内容
print(B.m)
print(b1.n)
b1.func1()
B.func2()
B.func3()

# 使用B中的内容
print(B.x)
b1.func11()
B.func22()
B.func33()
print(b1.p)

java基础学习_面向对象(上)01_day07总结

=============================================================================
=============================================================================
涉及到的知识点有：
1：面向对象(掌握)
　　(0)面向过程和面向过程开发
　　(1)面向对象思想概述
　　(2)面向对象的思想特点
　　(3)把大象装进冰箱(理解)
　　(4)类与对象的关系
　　(5)类的定义及使用
　　(6)案例
　　(7)内存图
　　(8)Java程序的开发、设计和特征
=============================================================================
=============================================================================
1：面向对象(掌握)
　　(0)面向过程和面向过程开发
　　　　面向过程：每一个具体步骤中我们都是参与者(执行者)，并且需要面对具体的每一个步骤和过程。
　　　　面向过程开发：其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。
　　(1)面向对象思想概述
　　　　面向对象是基于面向过程的编程思想。
　　(2)面向对象的思想特点：
　　　　A:是一种更符合我们思考习惯的思想。
　　　　B:把复杂的事情简单化。
　　　　C:让我们从执行者(参与者)变成了指挥者。(角色发生了转换)

　　　　举例：
　　　　　　买电脑：
　　　　　　　　面向过程：我先了解电脑-->了解我自己的需求：学习用-->找对应的参数信息-->去中关村买电脑-->讨价还价-->买回电脑。
　　　　　　　　面向对象：我知道我要买电脑-->班长去给我买-->班长就买回来了。
　　　　　　洗衣服：
　　　　　　　　面向过程：把衣服脱下-->找一个盆-->放点洗衣粉-->加点水-->把衣服扔进去-->搓一搓-->清洗衣服-->拧干-->晾起来。
　　　　　　　　面向对象：把衣服脱下-->打开全自动洗衣机-->扔进去-->一键即可-->晾起来。
　　　　　　吃饭：
　　　　　　　　面向过程：去超市买菜-->摘菜-->洗菜-->切菜-->炒菜-->盛起来-->吃。
　　　　　　　　面向对象：去饭店-->服务员(点菜)-->厨师(做菜)-->服务员(端菜)--吃。

　　　　　　　　万事万物皆对象！

　　　　　　　　家常事物、买洗衣机和去饭店太不划算了，所以，找个对象。
　　(3)把大象装进冰箱(理解)
　　　　A:面向过程实现
　　　　B:面向对象实现

　　　　注意：如何让我们的操作更符合面向对象思想呢?
　　　　　　A:有哪些类呢？
　　　　　　B:每个类有哪些东西呢？
　　　　　　C:类与类之间的关系是什么呢？
　　(4)类与对象的关系：
　　　　我们学习编程语言，是为了模拟现实世界的事物的。
　　　　　　A:现实世界的事物，我们如何表示呢？
　　　　　　　　属性 　　该事物的基本描述信息
　　　　　　　　行为 　　该事物的功能(该事物能够做什么)
　　　　　　B:Java语言中最基本的单位是类。所以，我们就应该把事物用一个类来体现
　　　　　　C:类
　　　　　　　　成员变量 ==> 事物属性
　　　　　　　　成员方法 ==> 事物行为
　　　　　　D:    类：是一组相关的属性和行为的集合。是一个抽象的概念。
　　　　　　　　对象：是该类事物的具体体现(存在)，是一个具体的实例。(对象)

　　　　　　　　类：可以理解为构造对象的一个蓝图或者模版，是抽象的概念。
　　　　　　　　对象：是以类为模型创建的具体实例，是对类的一种具体化。

　　　　　　举例：
　　　　　　　　类     -->  学生(抽象的)
　　　　　　　　对象 -->   班长就是一个对象(具体的)
如下图所示01：

　　(5)类的定义及使用：
　　　　A:类的定义：定义一个类其实就是定义该类的成员(成员变量和成员方法)
　　　　　　成员变量 　　定义格式和以前一样，就是位置不同，在类中，方法外。
　　　　　　成员方法 　　定义格式和以前一样，就是去掉了static。
　　　　B:如何使用类的内容？
　　　　　　在一个java文件中写两个类：一个基本的类，一个测试类。
　　　　　　　　注意：文件的名称和测试类的名称一致。
　　　　　　a:创建对象使用。格式如下：
　　　　　　　　类名 对象名 = new 类名();
　　　　　　b:如何使用成员变量和成员方法呢？
　　　　　　　　对象名.成员变量
　　　　　　　　对象名.成员方法()
　　(6)案例：
　　　　A:学生类的定义和使用
　　　　B:手机类的定义和使用
　　(7)内存图：
　　　　A:一个对象的内存图
　　　　B:二个对象的内存图
　　　　C:三个对象的内存图
如下图所示02：

　　(8)Java程序的开发、设计和特征
　　　　A:开发：就是不断的创建对象，通过对象调用功能。
　　　　B:设计：就是管理和维护对象间的关系。
　　　　C:特征
　　　　　　a:封装
　　　　　　b:继承
　　　　　　c:多态
=============================================================================