最近很多小伙伴都在问pyhon中类的复杂继承--------类的基础和八这两个问题，那么本篇文章就来给大家详细解答一下，同时本文还将给你拓展C++类的复合和继承关系（C++继承类和封闭类的关系）、JA

最近很多小伙伴都在问pyhon中类的复杂继承--------类的基础和八这两个问题，那么本篇文章就来给大家详细解答一下，同时本文还将给你拓展C++类的复合和继承关系（C++继承类和封闭类的关系）、JAVA基础学习之路（八）[1]String类的基本特点、Python 基础（八）、Python 基础（八）进阶等相关知识，下面开始了哦！

• pyhon中类的复杂继承--------类的基础（八）（python中类的继承）
• C++类的复合和继承关系（C++继承类和封闭类的关系）
• JAVA基础学习之路（八）[1]String类的基本特点
• Python 基础（八）
• Python 基础（八）进阶

pyhon中类的复杂继承--------类的基础（八）（python中类的继承）

def who(obj):
    print(id(obj),type(obj))

class A(object):
    def method(self):
        who(self)
        print("A.method\n")

class B(A):
    def method(self):
        who(self)
        print("B.method\n")

class C(B):
    def method(self):
        who(self)
        print("C.method\n")
''''''super(): same as super(__class__,<first argument>)
   super(type):unbound super object
   super(type,object):bound super object,requires isinstance(obj,type)
   super(type,type2):bound super object,requires issubclass(type2,type)''''''
class D(C):
    def __init__(self):
        super().method()
        super(__class__,self).method()

        super(C,self).method()# call C的 parent''s method,print B.method
        
        super(B,self).method()# call B的 parent''s method,print A.method

        super(B,C()).method()#calling B的parent''s method,print A.method
                             #with instance of C

d = D()
#c  = C() 
print("\n Instance of D:\n")
who(d)

super(D,d).method()#从外部使用super方法，调用D的父类.method,通过产生d的实例

C++类的复合和继承关系（C++继承类和封闭类的关系）

class CPoint{
    double x,y;  //点的坐标
};

class CCircle: public CPoint{
    double radius;  //半径
};

class CCircle
{
    CPoint center;  //圆心
    double radius;  //半径
}

class CDog;
class CMaster  //主人
{
    CDog dogs[10];
    int dogNum;  //狗的数量
};
class CDog
{
    CMaster m;
};

class CDog;
class CMaster
{
    CDog* dogs[10];
    int dogNum;  //狗的数量
};
class CDog
{
    CMaster m;
};

class CMaster;
classCDog
{
    CMaster* pm;
};
class CMaster
{
    CDog dogs[10];
    int dogNum;
};

class CMaster
{
    CDog* dogs[10];
    int dogNum;
};

JAVA基础学习之路（八）[1]String类的基本特点

String类的两种定义方式：

1. 直接赋值

2. 通过构造方法赋值 

//直接赋值
public class test2 {
    public static void main(String args[]) {
        String str = "hello"; 
        System.out.println(str);
    }    
}


//通过构造方法
public class test2 {
    public static void main(String args[]) {
        String str = new String("hello");
        System.out.println(str);
    }    
}

但是，两种方法却有着极大的区别

主要体现在内存上

一个简单的例子：

public class test1 {
    public static void main(String args[]) {
        int a = 10;
        int b = 10;
        String str_1 = "hello";
        String str_2 = "hello";
        String str_3 = new String("hello");
        System.out.println(a==b);
        System.out.println(str_1==str_2);
        System.out.println(str_1==str_3);
        System.out.println(str_2==str_3);    
    }
}   //输出为true true  false false

按道理来说，应该是四个true,因为他们的值都是相等的啊.......但是.....

上图解释了两个通过直接赋相同值产生的字符串使用“”==“”为什么返回true。

为什么会全部指向一块堆内存而不是分别指向自己的堆内存呢？？？

共享设计模式：

在JVM底层有一个对象池，里面有包括String在内的许多对象，当代码之中使用了直接赋值的方式定义了一个String类对象时，会将此字符串使用的匿名对象加入对象池。之后若有采用直接赋值的方式定义字符串，并且赋了相同的值，那么不会开辟新的堆内存空间，而是使用已有的对象（堆内存）进行继续使用。

上图解释了为什么直接赋值和构造方法赋相同的值，然而返回值却为false。因为使用构造方法定义字符串，使用了new关键字，意味着产生一块新的堆内存。那么两种方法各自开辟了一块堆内存，“==”符号对于字符串来说，比较的是地址值。两块堆内存的地址不同，所以返回值为false。

若要比较字符串的内容，而不是地址，应该使用str_a.equals(str_b)

字符串常量就是String类的匿名对象，所谓的直接赋值实际上就是为匿名对象加了一个名字。但是String类的匿名对象是由系统自动生成的，不用用户自己创建

public class test1 {
    public static void main(String args[]) {
        String str = "hello";
        System.out.println("hello".equals(str));    
    }
}
//返回值为true

tips：

防止空指向异常（使用了未实例化的对象）:将字符串写在输入的前面

public class test1 {
    public static void main(String args[]) {
        String input = null;
        System.out.println(input.equals("hello"));    
    }
}
//Exception in thread "main" java.lang.NullPointerException
    at test.test1.main(test1.java:6)  空指向异常


public class test1 {
    public static void main(String args[]) {
        String input = null;
        System.out.println("hello".equals(input));    
    }
}
//false

两种定义方法的优劣：

直接赋值节约空间

然而构造方法却会产生大量垃圾，如下图：

代码从右向左看，产生的第一块堆内存会成为垃圾

构造方法实例化的方法除了浪费内存外，其定义的对象不会保存在对象池之中，若要保存，需要手动入池（使用inner（）方法）

public class test1 {
    public static void main(String args[]) {
        String str_1 = new String("hello").intern();
        String str_2 = "hello";
        System.out.println(str_1==str_2);    
    }
}
//true

返回值为true，证明入池成功。

Python 基础（八）

1 模块

1.1 模块

模块是一个 Python 文件，其中包含对象定义与语句等，多个模块再加上__init__.py 就变成了一个包。

1.2 模块存在形式

模块可以分成两种：

• 非内置模块
• 内置模块

1.2.1 非内置模块

非内置模块以.py 文件的形式存在，放在对应的包下。

1.2.2 内置模块

内置模块就是内置到解释器中的模块，为了提高性能内置模块采用 C 语言而不是 Python 编写。

1.3 模块使用

先导入再调用里面的函数，可以一次导入整个模块，或者选择性导入其中的函数。

1.3.1 导入整个模块

import math
import cmath as cm

使用 as 设置模块别名。

1.3.2 导入模块中的某个函数

from math import sin
from cmath import sqrt as cs

使用 as 设置函数别名。

1.4 查看内置模块

import sys
sys.builtin_module_names

2 包

2.1 包

包是含有一个特殊的__init__.py 文件的文件夹，通常还含有其他.py 文件，表示不同的模块。

2.2 包管理

包的下载、安装、更新、删除可通过包管理器进行操作，常用的包管理器为 pip 与 Conda。pip 设计目的是仅管理 Python 语言的包，对应的包服务器为 PyPI，Conda 设计目的是管理多种语言的包，对应的包服务器为 Conda。

2.3 包管理命令

2.3.1 列出已安装的包

pip list
conda list

2.3.2 更新包

pip install --upgrade package_name
conda upgrade package_name

2.3.3 删除包

pip uninstall package_name
conda uninstall package_name

2.3.4 安装包

pip install package_name
conda install package_name

Python 基础（八）进阶