各位同学好，本章节和大家分享一下面向对象编程的一些方法，通过一些案例带大家由浅入深掌握面向对象的编程。

1. 最基本的类实例化

创建类的方法是 class 变量名: ，实例化方法是 类名() ，分配属性的方法是 实例名.属性名 = 值  

#（1）创建类
class Item:  # 创建类的方法是   class 类名:
    pass  # 不执行任何内容

#（2）实例化
item1 = Item()  # 创建Item类的实例化对象item1

#（3）给实例化对象分配属性
item1.name = 'phone'
item1.price = 100
item1.quantity = 5

#（4）打印结果
print(type(item1))  # <class '__main__.Item'>
print(type(item1.name))  # <class 'str'>
print(type(item1.price))  # <class 'int'>
print(type(item1.quantity))  # <class 'int'>

2. 在类中创建方法

在类的内部定义的函数，我们称之为方法，它可以运用于所有的类实例化对象上。我们在类的内部定义的函数，它的第一个参数默认是 self，代表类实例化对象，下面代码中是指item1。在类的外部调用类的内部定义的方法：对象名.方法名(参数) 

#（1）定义类
class Item:  # 创建类的方法是   class 类名:
    
    #（2）在类中创建方法
    # 当调用这个方法时，将对象本身作为第一个参数self传递
    def calculate_total_price(self, x, y):  
        return x * y  # 返回乘积

#（3）实例化
item1 = Item()  # 创建Item类的实例化对象item1

#（4）给实例化对象分配属性
item1.name = 'phone'
item1.price = 100
item1.quantity = 5

#（5）调用方法，self代表item1，传入两个参数x代表价格，y代表数量，
res = item1.calculate_total_price(item1.price, item1.quantity)
print(res)  # 500

# 再实例化一个
item2 = Item()  # 创建Item类的实例化对象item1
item2.name = 'MacBook'
item2.price = 1000
item2.quantity = 3
print(item2.calculate_total_price(item2.price, item2.quantity))
# 输出 3000

3. 类的初始化

3.1 初始化无默认值

在类实例化之后，需要分别给每个对象分配属性，如上一节的第（4）步。如果对象很多的话，极大增加了工作量。因此我们希望在类实例化对象的时候就能自动给对象分配属性。初始化方法：在类中定义 def __init__(self, 参数): ，在类实例化时，会自动执行初始化函数中的所有内容，自动完成属性分配。

#（1）定义类
class Item:   # 创建一个类
    
    #（2）初始化，实例化这个类时，会自动执行init内容
    def __init__(self, name, price, quantity):
        
        # 动态属性分配
        self.name = name  # 给实例化属性赋值，相当于item1.name = 'phone'
        self.price = price  # 相当于item1.price = 100
        self.quantity = quantity  # 相当于item2.quantity = 3
        
#（3）实例化，创建Item类的实例化对象item1
# 自动执行初始化中的内容，不需要一个一个去定义 
item1 = Item('Phone', 100, 5)  
item2 = Item('MacBook', 1000, 3)

# 打印结果
print('name1:', item1.name, 'price1:', item1.price, 'quantity1:', item1.quantity)
print('name2:', item2.name, 'price2:', item2.price, 'quantity2:', item2.quantity)
# name1: Phone price1: 100 quantity1: 5
# name2: MacBook price2: 1000 quantity2: 3

3.2 初始化有默认值

在初始化的过程中，可以给属性设置默认值。那样的话，在实例化时，如果不给定某个属性的值，那么这个属性就被赋予默认值。如下面在初始化时，已经给定了price和quantity这两个属性的默认值，因此item1就直接使用这两个属性的默认值，item2改变这两个属性的默认值。

#（1）创建类
class Item:   # 创建一个类
    
    #（2）初始化，实例化这个类时，会自动执行init内容
    # price和quantity存在默认值，可以不用传值
    def __init__(self, name, price=50, quantity=10): 
        
        # 动态属性分配
        self.name = name  # 给实例化属性赋值，相当于item1.name = 'phone'
        self.price = price  # 相当于item1.price = 100
        self.quantity = quantity  # 相当于item2.quantity = 3
        
#（3）实例化，创建Item类的实例化对象item1
# 自动执行初始化中的内容，不需要一个一个去定义 
item1 = Item('Phone')  # 使用默认值的price和quantity
item2 = Item('MacBook', 1000, 3)  # 不使用默认值，自己赋值

# 打印结果
print('name1:', item1.name, 'price1:', item1.price, 'quantity1:', item1.quantity)
print('name2:', item2.name, 'price2:', item2.price, 'quantity2:', item2.quantity)
# name1: Phone price1: 50 quantity1: 10
# name2: MacBook price2: 1000 quantity2: 3

4. 初始化后调用类中定义的方法

接着类初始化之后，在类中定义方法，第一个参数默认是实例化对象 self，这时候不需要传入额外参数。因为经初始化之后的对象，就已经被赋予了属性及属性值，可直接通过 self.属性名 读取该属性值。

#（1）定义类
class Item: 
    
    #（2）初始化，如果实例化时不给定实例化属性的值，那就使用默认值
    def __init__(self, name, price=100, quantity=10):
        
        # 给实例化对象分配属性
        self.name = name
        self.price = price
        self.quantity = quantity
        
    #（3）在类中定义方法，self代表实例化对象
    def calculate_total_price(self):
        
        # 实例化对象在初始化过程中已经附有了属性，可直接在定义的方法中计算
        return self.price * self.quantity

#（4）创建Item类的实例化对象item1
item1 = Item('Phone', 100, 5)  # 自定义各个属性的值

#（5）调用类中定义的方法，将item1作为对象self传入该方法
res = item1.calculate_total_price()
print(res)  # 500

# ==2== 补充
# 这里在实例化对象过程中没有指定数据类型，如果我们传入的price属性的值是字符串会发生什么呢
item1 = Item('Phone', '100', 5) # 传入各个属性的值
res = item1.calculate_total_price()  # 调用类方法计算price和quantity的乘积
# 相当于'100'*5，即把字符串100打印5次
print(res)  # 100100100100100

可是，如果在类实例化的时候，传入的属性值的类型不符合要求，就得不到想要的结果。比如传入的price是字符串类型的'100'，而quantity是整型的5，这两个不同的数据类型相乘，'100'*5表示将字符串'100'打印5次，得到的不是我们预期的结果。下面讲一下如何处理这种情况。

5. 初始化时，指定传入的数据类型

在初始化函数中指定数据类型，属性名: 数据类型，在类实例化的时候会提醒需要的什么样的数据类型。如下，name属性指定数据类型为str字符串类型，price属性为浮点类型，quantity属性已经赋予默认值，那么它的数据类型和默认值的数据类型相同。

#（1）创建类
class Item:  

    #（2）初始化，self代表实例化对象
    # 指定name属性的值为字符串类型，price属性的值为浮点类型，
    # quantity属性已经附有默认值，不需要再指定类型，因为quantity的数据类型就是默认值的数据类型
    def __init__(self, name: str, price: float, quantity=10):
        
        # 给实例化对象分配属性
        self.name = name
        self.price = price
        self.quantity = quantity
        
    #（3）定义类方法
    def calculate_total_price(self):
        
        # 计算乘积
        return self.price * self.quantity
    
#（4）创建Item类的实例化对象
item1 = Item('Phone', 100)  # 指定name属性和price属性，quantity属性使用默认值

#（5）调用类中的方法
res = item1.calculate_total_price()
print(res)  # 1000

6. 初始化时，检查输入值是否符合预期

这里用到 assert 方法。在上一节中，我们规定了数据类型，但如果数据类型输入对了，但是值的范围不满足要求那要怎么办呢。方法： assert 条件, 报错内容

如下面代码中的 assert price >= 0, f'Price {price} is not greater or equal to 0' 。意思是，如果price接收的属性值大于等于0，那就正常运行；如果price的值小于0，程序就报错，报错内容是逗号后面的内容。

#（1）创建一个类
class Item:  
    
    #（2）初始化，self代表实例化对象，指定实例化属性的数据类型
    def __init__(self, name:str, price:float, quantity=10):
        
        #（3）判断输入值是否满足要求，不满足则报错，报错内容是逗号后面的
        # 比如，要求每个实例的价格属性price是大于0的，满足要求则不显示逗号后面的内容
        assert price >= 0, f'Price {price} is not greater or equal to 0'   
        assert quantity >= 0, f'Quantity {quantity} is not greater or equal to 0'
        
        #（4）给每个实例属性赋值
        self.name = name
        self.price = price
        self.quantity = quantity
        
    #（5）定义类方法
    def calculate_total_price(self):
        
        # 计算乘积
        return self.price * self.quantity
    
#（6）Item类的实例化对象item1
item1 = Item('Phone', -100, 3)

#（7）调用类实例化方法
res = item1.calculate_total_price()
print(res)

创建Bean的入口：org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean。

实例化

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBeanInstance

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
	// Make sure bean class is actually resolved at this point.
	Class<?> beanClass = resolveBeanClass(mbd, beanName);

	if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
		throw new BeanCreationException(mbd.getResourceDescription(), beanName,
				"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
	}

	Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
	if (instanceSupplier != null) {
		return obtainFromSupplier(instanceSupplier, beanName);
	}

	// 如果factory-method属性不为空，则使用factory-method方式实例化
	if (mbd.getFactoryMethodName() != null) {
		return instantiateUsingFactoryMethod(beanName, mbd, args);
	}

	// Shortcut when re-creating the same bean...
	boolean resolved = false;
	boolean autowireNecessary = false;
	if (args == null) {
		synchronized (mbd.constructorArgumentLock) {
			if (mbd.resolvedConstructorOrFactoryMethod != null) {
				resolved = true;
				autowireNecessary = mbd.constructorArgumentsResolved;
			}
		}
	}
	if (resolved) {
		if (autowireNecessary) {
			return autowireConstructor(beanName, mbd, null, null);
		}
		else {
			return instantiateBean(beanName, mbd);
		}
	}

	// Candidate constructors for autowiring?
	// 找到构造方法
	Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
	if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
			mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
		return autowireConstructor(beanName, mbd, ctors, args);
	}

	// Preferred constructors for default construction?
	ctors = mbd.getPreferredConstructors();
	if (ctors != null) {
		// 构造器注入
		return autowireConstructor(beanName, mbd, ctors, null);
	}

	// No special handling: simply use no-arg constructor.
	// 使用默认的构造方法实例化
	return instantiateBean(beanName, mbd);
}

如果BeanDefinition的factory-method属性不为空，那么使用factory-method的实例化过程。

设置属性

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
	... ...
	if (hasInstAwareBpps) {
		if (pvs == null) {
			pvs = mbd.getPropertyValues();
		}
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof InstantiationAwareBeanPostProcessor) {
				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
				// 调用各个BeanPostProcessor.postProcessProperties对属性进行设置
				/**
				 * AutowiredAnnotationBeanPostProcessor处理@Autowired
				 * CommonAnnotationBeanPostProcessor处理@Resource
				 *
				 * @see AutowiredAnnotationBeanPostProcessor#postProcessProperties(org.springframework.beans.PropertyValues, java.lang.Object, java.lang.String)
				 * @see org.springframework.context.annotation.CommonAnnotationBeanPostProcessor#postProcessProperties(org.springframework.beans.PropertyValues, java.lang.Object, java.lang.String)
				 */
				PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
				
	... ...
}

初始化

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
	if (System.getSecurityManager() != null) {
		AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
			invokeAwareMethods(beanName, bean);
			return null;
		}, getAccessControlContext());
	}
	else {
		// 调用aware方法
		// BeanNameAware/BeanClassLoaderAware/BeanFactoryAware对应的setXxx方法
		invokeAwareMethods(beanName, bean);
	}

	Object wrappedBean = bean;
	if (mbd == null || !mbd.isSynthetic()) {
		// 处理EnvironmentAware/EmbeddedValueResolverAware/ResourceLoaderAware/
		// ApplicationEventPublisherAware/MessageSourceAware/ApplicationContextAware
		// 处理@PostConstruct
		wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
	}

	try {
		// InitializingBean.afterPropertiesSet()
		// 调用init-method
		invokeInitMethods(beanName, wrappedBean, mbd);
	}
	catch (Throwable ex) {
		throw new BeanCreationException(
				(mbd != null ? mbd.getResourceDescription() : null),
				beanName, "Invocation of init method failed", ex);
	}
	if (mbd == null || !mbd.isSynthetic()) {
		wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
	}

	return wrappedBean;
}

factory-method的实例化过程

spring中可以使用factory-method向容器中注入实例。

使用另一个类的实例方法注入

package com.morris.spring.entity;

import lombok.AllArgsConstructor;
import lombok.Data;

@Data
public class Boy {

	private String name;
	
	public Boy(String name) {
		this.name = name;
	}
}

package com.morris.spring.service;

import com.morris.spring.entity.Boy;

public class BoyService {

	public Boy newInstance() {
		return new Boy("morris");
	}

}

<bean id="boyService" class="com.morris.spring.service.BoyService"/>
<bean id="boy" factory-bean="boyService" factory-method="newInstance"/>

使用本类的静态方法实例化

package com.morris.spring.entity;

import lombok.Data;

@Data
public class Boy {

	private String name;

	public Boy(String name) {
		this.name = name;
	}

	public static Boy newInstance() {
		return new Boy("bob");
	}

}

<bean id="boy2" class="com.morris.spring.entity.Boy" factory-method="newInstance"/>

源码分析

org.springframework.beans.factory.support.ConstructorResolver#instantiateUsingFactoryMethod

public BeanWrapper instantiateUsingFactoryMethod(
		String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {

	BeanWrapperImpl bw = new BeanWrapperImpl();
	this.beanFactory.initBeanWrapper(bw);

	Object factoryBean;
	Class<?> factoryClass;
	boolean isStatic;

	String factoryBeanName = mbd.getFactoryBeanName();
	if (factoryBeanName != null) {
		// factoryBeanName不为空说明使用的是另一个类的实例方法来创建实例
		if (factoryBeanName.equals(beanName)) {
			throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
					"factory-bean reference points back to the same bean definition");
		}
		// 根据factoryBeanName获取另一个类的实例
		factoryBean = this.beanFactory.getBean(factoryBeanName);
		if (mbd.isSingleton() && this.beanFactory.containsSingleton(beanName)) {
			throw new ImplicitlyAppearedSingletonException();
		}
		this.beanFactory.registerDependentBean(factoryBeanName, beanName);
		factoryClass = factoryBean.getClass();
		isStatic = false; // 非静态
	}
	else {
		// factoryBeanName为空说明使用的是本类的静态方法来创建实例
		// It's a static factory method on the bean class.
		if (!mbd.hasBeanClass()) {
			throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
					"bean definition declares neither a bean class nor a factory-bean reference");
		}
		factoryBean = null;
		factoryClass = mbd.getBeanClass();
		isStatic = true; // 静态
	}

	Method factoryMethodToUse = null;
	ArgumentsHolder argsHolderToUse = null;
	Object[] argsToUse = null;

	if (explicitArgs != null) {
		argsToUse = explicitArgs;
	}
	else {
		Object[] argsToResolve = null;
		synchronized (mbd.constructorArgumentLock) {
			factoryMethodToUse = (Method) mbd.resolvedConstructorOrFactoryMethod;
			if (factoryMethodToUse != null && mbd.constructorArgumentsResolved) {
				// Found a cached factory method...
				argsToUse = mbd.resolvedConstructorArguments;
				if (argsToUse == null) {
					argsToResolve = mbd.preparedConstructorArguments;
				}
			}
		}
		if (argsToResolve != null) {
			argsToUse = resolvePreparedArguments(beanName, mbd, bw, factoryMethodToUse, argsToResolve);
		}
	}

	if (factoryMethodToUse == null || argsToUse == null) {
		// Need to determine the factory method...
		// Try all methods with this name to see if they match the given arguments.
		factoryClass = ClassUtils.getUserClass(factoryClass);

		List<Method> candidates = null;
		if (mbd.isFactoryMethodUnique) {
			if (factoryMethodToUse == null) {
				factoryMethodToUse = mbd.getResolvedFactoryMethod();
			}
			if (factoryMethodToUse != null) {
				candidates = Collections.singletonList(factoryMethodToUse);
			}
		}
		if (candidates == null) {
			candidates = new ArrayList<>();
			Method[] rawCandidates = getCandidateMethods(factoryClass, mbd);
			for (Method candidate : rawCandidates) {
				// 找到factory-method方法
				if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate)) {
					candidates.add(candidate);
				}
			}
		}

		if (candidates.size() == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
			Method uniqueCandidate = candidates.get(0);
			if (uniqueCandidate.getParameterCount() == 0) {
				mbd.factoryMethodToIntrospect = uniqueCandidate;
				synchronized (mbd.constructorArgumentLock) {
					mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
					mbd.constructorArgumentsResolved = true;
					mbd.resolvedConstructorArguments = EMPTY_ARGS;
				}
				// 调用factory-method方法进行实例化
				bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, uniqueCandidate, EMPTY_ARGS));
				return bw;
			}
		}
... ...

实例化（instantiate）是指在面向对象的编程中，把用类创建对象的过程称为实例化。是将一个抽象的概念类，具体到该类实物的过程。实例化过程中一般由类名 对象名 = new 类名（参数1，参数2...参数n）构成。

简介

在面向对象的编程中，通常把用类创建对象的过程称为实例化，其格式如下：

如 Date date=new Date();就是用日期类创建了一个日期的对象，就叫对象的实例化。

多数语言中，实例化一个对象就是为对象开辟内存空间，或者是不用声明，直接使用new 构造函数名，建立一个临时对象。

例:Java

public class A{
    public static void main(String[] args){
        B b = new B();//实例化
        b.print();
    }
}

class B{
    public void print(){
        System.out.println("Hello,World!");
    }
}

例: c#

namespace test
{
    class A
    {
        public int Sub(int a)
        {
            return a++;
        }
    }


    class B
    {
        public void Main(String[] args)
        {
            int p = (new A()).Sub(1);
            System.Console.WriteLine(p);
            System.Console.ReadKey();
        }
    }
}

使用方法

以PHP为例。

类不同于函数，定义完之后无法直接使用，因为类只是一个抽象的概念，需要通过关键字new来实例化类，才可以使用。类实例化的语法格式如下：变量名=new 类名（[构造函数]）。其中，变量名可以为任何PHP变量的名称，构造参数取决于类的构造函数，若无构造函数，则圆括号中为空。 

实例化一个类后即可使用该类。

例如：

<?php
     class People{
         public $name;  
         public function introduceMySelf(){
             echo '内容'，$this->name.‘内容2’;
         }
      }
      $p=new People();
 ?>

如果要在类外使用类的属性和方法(前提是该属性或方法是可访问的)，需要使用操作符->，语法格式如下：

• 实例化的类变量名->属性名；

• 实例化的类变量名->方法名（[方法参数]）；

使用类的方法与调用函数一样，在圆括号中给出函数参数(没有参数时当然就不用写了)。需要特别注意的是，在使用操作符->引用属性时，属性名是不加符号$的。 

类模板与函数模板实例化

函数模板实例化

以C++为例，C++标准除支持隐式实例化模板函数外，还支持显式实例化。其语法格式如下： 

template 返回类型 函数名<类型实参列表>（实参类型列表）；

例如，若有以下函数模板：

template<typename T>
void swap(T a ,T b){
     T tempt=a;
     a=b;
     b=tempt;
};

那么，以下语句是该函数模板的一个显式实例化：

template void swap<int>(int,int);

说明：template关键字之后不再跟"<>"，否则就成了函数模板的特化。

类模板的实例化

与函数模板相似，类模板只是一个虚的“图纸”。只有在编译期间，编译器根据给定的模板类型实参生成实实在在的模板类，这才是真实存在的类代码。函数模板实例化后会生成模板函数，类模板实例化后则会生成模板类。

在为不同模板实参类型实例化生成模板类时，编译器会为每种数据类型都生成一个模板代码的副本，所以结果会导致代码体积增大。因此，在实际调用过程中，编译器会有选择的实例化类模板中的成员函数，只有那些被调用了的函数，它对应的类模板成员函数才会被编译器实例化并生成。这就是类模板的“选择性实例化”。 

声明、初始化、实例化的区别

声明是指使用一个对象的时候，先定义属于哪个类型，比如string _str;

_str是声明（定义）了一个string类型的对象。

初始化可以理解为给声明的对象赋值的过程。string _str ="hello";

_str现在已经被初始化了，实例化后它具有“hello”这个值。

实例化是类用到的，A a = new A();当new的时候为对象分配内存，这个过程是对象的实例化。

总结：

声明，只生成对象不赋值的过程。

初始化，是给对象赋值的过程。

实例化，是使用new为对象分配内存的过程。