精华内容
下载资源
问答
  • 实例化
    千次阅读
    2022-05-07 14:38:35

    1.什么是对象实例化

    在写代码时,我们用关键词class定义一个类其实只是定义了一个类的模板,没有在内存中实际产生一个类的实例对象,也没有分配内存空间。要想在内存中产生一个类的实例对象就需要使用new关键字申请分配内存空间,加上类的构造方法提供申请空间的大小规格,在内存中实际产生一个类的实例,一个类使用 new 加 此类的构造方法,执行之后就在内存中分配了一个此类的内存空间,有了内存空间就可以向里面存放定义的数据和进行方法的调用了,这就是对象的实例化。

    大致就是给这个类赋予对应意义的过程吧,比如

    Person p = new Person();

    对象:纸上的一个机器草图,不占用任何空间

    实例化:将纸上的机器制作出来,实际占用空间

    2.java对象实例化的五种方式

    1. ⽤new语句创建对象,这是最常见的创建对象的⽅法;
    2. 通过⼯⼚⽅法返回对象,如:String str = String.valueOf(23);
    3. 运⽤反射⼿段,调⽤java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例⽅法。如:Object obj =Class.forName("java.lang.Object").newInstance();
    4. 调⽤对象的clone()⽅法;
    5. 通过I/O流(包括反序列化),如运⽤反序列化⼿段,调⽤java.io.ObjectInputStream对象的 readObject()⽅法。
    更多相关内容
  • 创建类的方法是 class 变量名:,实例化方法是 类名() ,分配属性的方法是 实例名.属性名 = 值 #(1)创建类 class Item: # 创建类的方法是 class 类名: pass # 不执行任何内容 #(2)实例化 item1 = Item() # ...

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

    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....实例化 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBeanInstance protected BeanWrapper createBeanInstance(String beanNa.

    在这里插入图片描述

    创建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;
    			}
    		}
    ... ...
    
    展开全文
  • 什么是实例化实例化、声明、初始化的区别

    千次阅读 多人点赞 2020-04-26 21:40:29
    实例化(instantiate)是指在面向对象的编程中,把用类创建对象的过程称为实例化。是将一个抽象的概念类,具体到该类实物的过程。实例化过程中一般由类名 对象名 = new 类名(参数1,参数2...参数n)构成。 简介 ...

    实例化(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为对象分配内存的过程

    展开全文
  • C++类模板实例化

    千次阅读 2021-09-04 13:32:18
    C++类模板实例化 文章目录C++类模板实例化1. 简介2. 类模板实例化2.1 隐式实例化(Implicit instantiation)2.2 显示实例化(Explicit instantiation)2.3 类模板中的静态成员 1. 简介 该文章主要总结C++类模板实例...
  • 在c++和java中我们会定义很多类,但是我们会遇到在对类进行new实例化时会遇到“不能实例化抽象类”或者“抽象类不能实例化”,针对这个问题要首先理解两个内容“抽象类”和“实例化” 如果只是想单纯的理解,那么...
  • python--类的实例化

    千次阅读 2021-01-14 18:50:08
    1、类的定义和语法View Code2、self关键字self这个关键字相当于实例化对象本身(self相当于d),在实例化过程中,把自己传进去了3、函数__init__() 、__del__()在类中__init__()函数叫构造函数,又叫构造方法,也可以...
  • Unity 创建/实例化对象

    千次阅读 2021-09-23 11:40:30
    在程序运行过程中创建、实例化对象物体需要用到Object类中的 Instantiate 函数,例如,我们场景中有一个物体A: 现在我们想要在场景中创建五个该物体,则用Instantiate函数将该物体作为参数传入: using ...
  • c++三种实例化对象方式

    千次阅读 2022-04-16 18:47:15
    1.隐式创建 首先我们定义一个测试类 class Person { private: int ...而new出来的指针对象可以在方法之间传递,且该指针对象所指向的堆中的对象实例仍然存在。 5.频繁调用场合并不适合new,就像new申请和释放内存一样。
  • 什么是java实例化

    千次阅读 2021-02-12 11:12:21
    什么是java实例化Persion p1 = new Persion();java实例化就是使用new关键字创建一个对象的过程,例如“new Persion()”就代表实例化了一个Persion对象,其中Persion末尾的括号代表立即调用Persion类的构造函数来进行...
  • Java让泛型实例化的方法

    千次阅读 2021-02-12 14:07:52
    泛型对象可以实例化吗?不可以,T t=new T()是不可以的,编译器会报错。由于泛型擦除,编译器在编译时无法确定泛型所对应的真实类型解决方法使用反射新建实例Type superclass = getClass().getGenericSuperclass();...
  • Java 泛型的实例化总结

    千次阅读 2021-09-21 17:51:44
    Java 泛型的实例化总结 前言: 当我们在做项目的时候 ,搭建框架的时候,会经常用到泛型类来封装一些通用类或工具类。在封装泛型类的过程中,为了提升开发效率及代码简洁,会经常运用泛型内部进行实例化,用以减少...
  • 关于java:无法实例化类型List

    千次阅读 2021-03-09 01:39:09
    接口不能直接实例化,您应该实例化实现此类接口的类。 尝试这个: NameValuePair[] params = new BasicNameValuePair[] { new BasicNameValuePair("param1", param1), new BasicNameValuePair("param2", param2), }...
  • java 实例化是什么及五种实例化方法

    千次阅读 2020-06-30 19:08:16
    实例化是什么 1.在Java中,使用已经定义好的类,创建该类对象的过程称为“实例化”。 2.实例化就是在堆中分配内存的过程,分配的内存即对象。 3.只有实例化后的对象,才能访问到类中的成员变量和方法。 实例化的特点...
  • Java对象在内存中实例化的过程

    千次阅读 多人点赞 2020-07-27 15:08:52
    Java对象在内存中实例化的过程 在讲 Java 对象在内存中的实例化过程前,先来说下在类的实例化过程中,内存会使用到的三个区域:栈区、堆区、方法区。 堆区: 存储的全部都是对象,每个对象包含了一个与之对应的 ...
  • python:类的定义、实例化对象

    千次阅读 2021-02-03 12:24:54
    定义:类的定义使用关键字 ,class 关键字: 封装:类可以把各种对象组织在一起,作为类的属性,通过 . (点)运算符来调用类中封装好的对象 属性:变量在类中称为属性,... 标签: python 、类class、实例化 #python#
  • String类的两种实例化方式

    千次阅读 2021-02-05 13:11:15
    面试常见问题:比较String类的两种实例化方式
  • 学Java· 从new说对象实例化

    千次阅读 多人点赞 2022-03-31 12:05:37
    就可以实例化一个对象,这个对象就有Student类中的所以成员变量。可是 对象student1 和 类Student到底是怎样建立联系的,在内存中到底发生了什么? 想要知道内存中发生了什么,我们先来了解两个内存概念 堆...
  • 内部类及静态内部类的实例化

    千次阅读 2021-03-10 01:12:29
    内部类的实例化如果内部类未声明为static,在实例化时首先需要new一个外部类的对象。并通过p.new Inner()的方式new 内部类,表明这个内部类指向该外部类。内部类的class类型为:Parent.Inner,而不是p.Inner,这个...
  • 实例化servlet类时出错

    千次阅读 2021-03-15 20:49:12
    例外 javax.servlet.ServletException:实例化servlet类student.StudentSurveyFormSubmit org.jboss.as.web.security.SecurityContextAssociationValve.invoke(SecurityContextAssociationValve.java:153)org....
  • 隐式实例化: 显式实例化: 显示具体化: 详细理解 显示实例化 显示具体化 总体概念 隐式实例化: 在使用模板之前,编译器不生成模板的声明和定义实例。只有当使用模板时,编译器才根据模板定义生成相应...
  • 极智Coding | C++ 类实例化的方法

    千次阅读 2021-10-19 16:44:45
    本文介绍一下 C++ 中类实例化的几种方法。
  • python类的定义与实例化

    千次阅读 2020-11-03 22:42:48
    类的定义与实例化 在Python中,通过class关键字定义一个类,比如我们需要定义一个人的类。按照 Python 的编程习惯,类名以大写字母开头。因此可以这样定义: class Person: pass 注意,在这个Person类的定义里面,...
  • Servletle类实例化错误

    千次阅读 多人点赞 2020-09-10 20:42:28
    Servletle类实例化错误我的探索历程环境:历程:Tomcat和Servlet HTTP状态 500 - 内部服务器错误 类型 异常报告 消息 实例化Servlet类[servlet.ServletHello]异常 描述 服务器遇到一个意外的情况,阻止它完成请求...
  • Java类的 初始化 和 实例化区别

    千次阅读 多人点赞 2020-09-23 17:13:30
    类的实例化:是指创建一个对象的过程。这个过程中会在堆中开辟内存,将一些非静态的方法,变量存放在里面。在程序执行的过程中,可以创建多个对象,既多次实例化。每次实例化都会开辟一块新的内存。 1.主要区别 ...
  • 创建(实例化)对象的五种方式

    万次阅读 2018-08-28 10:16:52
    Java中创建(实例化)对象的五种方式 用new语句创建对象,这是最常见的创建对象的方法。 通过工厂方法返回对象,如:String str = String.valueOf(23); 运用反射手段,调用java.lang.Class或者java.lang....
  • 实例化和初始化的区别

    千次阅读 2019-09-02 11:00:54
    一、实例化和初始化的区别 实例化:只是单纯的把对象 new 一下就行了 例:Student st=new Student();这样就行了 初始化:是在实例化的基础上,并且对 对象中的值进行赋一下初始值(这样的好处是避免当你没有赋值的...
  • C++的使用:实例化对象

    千次阅读 2021-06-19 10:46:47
    实例化对象有两种方式,一种是在栈上实例化,另一种是在堆上实例化。 示例代码 2 int main() { // 栈上实例化 Student stu1; stu1.setName("jake"); stu1.setAge(15); cout << "My name is " <<...
  • @staticmethod 和 @classmethod 用法一般来说,要使用某个类的方法,需要先实例化一个对象再调用方法。而使用@staticmethod或@classmethod,就可以不需要实例化,直接类名.方法名()来调用。这有利于组织代码,把某些...
  • Spring官网阅读(一)容器及实例化

    万次阅读 多人点赞 2020-03-10 23:22:08
    实例化总结: 对象实例化,只是得到一个对象,还不是一个完全的Spring中的Bean,我们实例化后的这个对象还没有完成依赖注入,没有走完一系列的声明周期,这里需要大家注意 Spring官网上指明了,在Spring中实例化一...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,039,560
精华内容 1,215,824
关键字:

实例化