精华内容
下载资源
问答
  • - 传统方式初始化对象属性 - 初始化列表,用来初始化属性

    C++初始化对象属性的两种方法

    • 传统方式初始化对象属性
    • 初始化列表,用来初始化属性

    初始化列表语法:构造函数():属性1(值1),属性2(值2)... {}

    示例:

    class Person {
    public:
    
    	传统方式初始化
    	//Person(int a, int b, int c) {
    	//	m_A = a;
    	//	m_B = b;
    	//	m_C = c;
    	//}
    
    	//初始化列表方式初始化
    	Person(int a, int b, int c) :m_A(a), m_B(b), m_C(c) {}
    	void PrintPerson() {
    		cout << "mA:" << m_A << endl;
    		cout << "mB:" << m_B << endl;
    		cout << "mC:" << m_C << endl;
    	}
    private:
    	int m_A;
    	int m_B;
    	int m_C;
    };
    
    int main() {
    
    	Person p(1, 2, 3);
    	p.PrintPerson();
    
    
    	system("pause");
    
    	return 0;
    }
    
    展开全文
  • Java初始化对象属性值的方式 1、数据库设计 一般我们在数据库设计时很多字段都会设计一个非空值,如下sql: CREATE TABLE `student` ( `id` int(11) unsigned NOT NULL AUTO_INCREMENT, `name` Varchar(64) Not ...

    Java初始化对象属性值的方式

    1、数据库设计

    一般我们在数据库设计时很多字段都会设计一个非空值,如下sql:

    CREATE TABLE `student` (
      `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
      `name` Varchar(64) Not Null Default '' Comment '姓名',
      `age` int(11) Not Null Default 0 Comment '年龄',
      `addr` Varchar(64) Not Null Default '' Comment '地址',
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8 ROW_FORMAT=COMPACT;
    

    实体类对象,一般是通过某种工具自动生成,如下(我写的是jpa的写法,其他类似):

    @Data
    @Entity
    public class Student {
        @Id
        @GeneratedValue(strategy= GenerationType.IDENTITY)
        private Integer id;
    
        @Column(name = "name")
        private String name;
    
        @Column(name = "age")
        private Integer age;
    
        @Column(name = "addr")
        private String addr;
    }
    

    这个时候,我们在做对象插入的时候。以下面的某种写法

    Student student = new Student();
    student.setName("zhangsan");
    
    //InitValue2Obj.initZeroAndEnpty(student);
    studentReposity.save(student);
    

    很明显是不正确的,会报如下错误:

    Caused by: java.sql.SQLIntegrityConstraintViolationException: Column 'addr' cannot be null
    

    这样我们就只能硬性的把所有属性全部赋值。如果没有值就给一个空值或者默认值。但是当随着业务的开展,我们增加了一些列的时候,把一个列的属性设置为非空,这样对于前人的所有insert都要进行一个修改。因此写了一个默认工具类,设置一个初始属性值。

    2、设置对象初始属性值工具类

    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    import java.util.Date;
    
    public class InitValue2Obj {
    
        /**
         * 设置对象初始属性值
         * @param object
         * @throws Exception
         */
        public static void initZeroAndEnpty(Object object) throws Exception {
            Class cls = object.getClass();
            Field[] fields = cls.getDeclaredFields();
            Method[] methods = cls.getDeclaredMethods();
            for (Field field:fields
                 ) {
                Object o = getFieldValueByName(field.getName(), object);
                if (null == o) {
                    Method method = getMethod(field.getName(), methods);
                    if(field.getGenericType().getTypeName().equals("java.lang.String")) {
                        method.invoke(object, "");
                    }else if(field.getGenericType().getTypeName().equals("java.lang.Integer")) {
                        method.invoke(object, 0);
                    }else if(field.getGenericType().getTypeName().equals("java.lang.Long")) {
                        method.invoke(object,0L);
                    }else if(field.getGenericType().getTypeName().equals("java.util.Date")) {
                        method.invoke(object, new Date());
                    }else if(field.getGenericType().getTypeName().equals("java.lang.Boolean")) {
                        method.invoke(object, false);
                    }
                }
            }
        }
    
        /**
         * 获取相应属性的set方法
         * @param fieldName
         * @param methods
         * @return
         */
        private static Method getMethod(String fieldName, Method[] methods) {
            for(Method method: methods) {
                if(!method.getName().startsWith("set")) {
                    continue;
                }
                if(method.getName().toLowerCase().endsWith(fieldName.toLowerCase())) {
                    return method;
                }
            }
            return null;
        }
    
        /**
         * 获取相应属性的属性值
         * @param fieldName
         * @param o
         * @return
         */
        private static Object getFieldValueByName(String fieldName, Object o) {
            try {
                String firstLetter = fieldName.substring(0, 1).toUpperCase();
                String getter = "get" + firstLetter + fieldName.substring(1);
                Method method = o.getClass().getMethod(getter, new Class[] {});
                Object value = method.invoke(o, new Object[] {});
                return value;
            } catch (Exception e) {
                System.out.println("属性不存在");
                return null;
            }
        }
        
    }
    

    这样在我们调用insert方法时,只需要增加这一步

    InitValue2Obj.initZeroAndEnpty(student);
    

    后续列的变动将不会受到影响


    可能我不足,但我一直在成长

    展开全文
  • 第95课时: 类: 构造函数__init__ 用于初始化对象属性. 构造函数: init() Init左右两边各两个下划线。 类是抽象的,叫做“对象的模板” 前面提到过,python的对象包含三部分:id type value。 创建对象后,我们...

    第95课时: 类: 构造函数__init__ 用于初始化对象属性.



    构造函数: init()

    Init左右两边各两个下划线。

    类是抽象的,叫做“对象的模板”

    前面提到过,python的对象包含三部分:id type value。

    创建对象后,我们需要定义构造函数__init__()方法,是创建对象后来初始化对象相关属性的。

    init()的要点如下:

    1. 名称固定,必须为: init()

    2,第一个参数必须固定为self。
    如“def init(self,name,score):” 一样

    3,后面的阐述就是实例属性:name,score,且无返回值。

    比如:

    def __init__(self,name,score):
        self.name=name
        self.score=score

    name 和score就两个实例属性。

    不加 self. 就是内部的形式参数(不对象属性),加了self. 就是对象的属性。

    展开全文
  • 面向过程:将程序进行流程,即把程序的步骤整理清楚再一步步实现,但是拓展性差,程序的流程在写程序的时候已经决定好,后期更改程序会牵扯到有关联性的一些功能,理解:面向过程关注的是解决问题需要哪些步骤 ...


    前言:

    我们编程可分为两种编程思想:

    面向过程:将程序进行流程化,即把程序的步骤整理清楚再一步步实现,但是拓展性差,程序的流程在写程序的时候已经决定好,后期更改程序会牵扯到有关联性的一些功能。
    理解:面向过程关注的是解决问题需要哪些步骤


    面向对象:将程序的变量以及功能整合到一起成为:对象,程序的流程是在对象生成后决定的,后期拓展程序只需要更改对象(或实例化对象的类)即可
    理解:面向对象关注的是解决问题需要哪些对象

    但并不是说开发程序一定只用面向对象编程思想来进行开发,选取对我们更有优势的方式才是最好的!那么本篇就来介绍一下面向对象编程~

    本篇主要介绍面向对象的基础内容


    面向对象编程(OOP)

    Python作为设计之初就是作为一种面向对象的编程语言。

    什么是对象?目前可以理解为:有名称、属性、功能的集合体

    其实在我们平常所使用python时就已经接触到对象

    拿定义一个变量来举例:所列出的方法是x这个字符所具备的吗?
    在这里插入图片描述
    并不是,我们可以看成:x = int(10) 这样更利于理解,因为我们输入10,Python会检测到我们输入的内容进而帮我们转换为对应的数据类型。可以理解成:10是由int产生的,之后我们将10赋给一个变量,这个变量此时就可以称之为:对象

    那么我们来说一下如何产生对象。

    类与对象

    上序所说的int就是一个类名,Python中对象是由调用类而实例化出的

    类的定义:由class关键字产生

    class 类名:
    	<statement...>
    

    那么我们获取对象则是调用定义的类名

    class Person: # 类名的定义推荐采用驼峰体:即单词的首字母大写
    	age = 10 # 类的属性
    
    	def f(self):
    		print('Hello class')
    
    p = Person() # 那么我们通过调用Person这个类,实例化出一个名为:p的对象
    print(p.age) # 访问这个类的属性
    p.f() # 访问这个类的方法
    

    我们会注意到:在类里面def创建函数时,会自动产生一个self的参数。这个待往下了解会提到,暂时不用在意

    在定义类后,会产生一个名称空间,我们可以通过类名.__dict__来进行查看

    print(Person.__dict__)
    {'__module__': '__main__', 'age': 10, 'f': <function Person.f at 0x7fc95eb9edc0>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}
    
    # 可以看到一堆这样字典内容,__开头的我们不需要关注,这里看到age它是我们定义的一个类属性
    

    对象也具备__dict__可以查看其名称空间

    p = Person()
    print(p.__dict__)
    {}
    

    我们可以看到p这个对象,名称空间内并无任何内容,仔细观察上面调用时可以发现,我们调用的是类的属性,并不是自己的,这就涉及到一个查找属性的优先级:

    对象查找属性:优先查找自身是否具备这个属性,如果不具备则到对应的类中去查找,再未找到则报错,我们目前了解到这里即可,后续会涉及到继承查找


    对象绑定方法

    接着来把上序类里面方法有个一个参数名为self

    因为类里面的属性以及函数都是提供给对象使用的,而如果类本身来调用它就与普通函数无异了,该传递几个参数就传递几个。所以我们着重解释self的作用

    拿例子比喻:

    class Person:
    	age = 10
    
    	def f(self):
    		print('Hello class')
    
    p = Person()
    p.f() # 访问这个类的方法
    

    它的作用就是,我们这个p对象在调用类时,就会将类里面的f方法 绑定给p对象,在调用这个f方法时,会自动将与之绑定的对象传递进去,当然参数也可以不是self,但是在Python中约定通常使用self字符作为参数

    self(自己):这里也可以理解为,调用这个方法的对象

    类里面的方法是共享给所有对象的,谁来调用它,它就与之进行绑定,我们在这个方法里面就可以获取绑定对象的属性

    class Person:
    	age = 10
    
    	def f(self):
    		print('Hello class')
    
    p1 = Person()
    p2 = Person()
    print(Person.f)
    print(p1.f)
    print(p2.f)
    

    执行结果

    <function Person.f at 0x7f8059a9edc0>
    <bound method Person.f of <__main__.Person object at 0x7f8059a6dfd0>>
    <bound method Person.f of <__main__.Person object at 0x7f8059a6de80>>
    
    # 可以看到,通过类调用里面的函数它就只是普通函数
    # 我们通过对象调用它就成了方法,虽说方法只有一个,但是每次传递进去的对象都是不同的
    # 所以产生的效果也不同,self准确来说就是接收传递进来的对象
    

    定义对象的属性

    给对象添加一些属性,而不是去类里面拿,访问这个对象自身就能拿到值

    # 和上序一样的内容,我们做点手脚!
    class Person:
    	age = 10
    	def f(self):
    		print('Hello class')
    
    p = Person()
    p.age = 1
    print(p.age)
    # 此时我们打印出来的内容就是这个p对象本身的age属性值,而不是去类里面查找属性
    >>> 1
    

    就是说,当我们对象自身拥有这个属性时,就不会跑到类里面去找!
    再来绕一下,看看是否了解:根据下列代码说出打印内容

    p1 = Person()
    p1.age += 1
    
    p2 = Person()
    
    print(p1.age)
    print(p2.age)
    

    p1.age的执行为:先在p1这个对象里面查找,发现没有,再去类里面查找,找到内容以后+1后,将age这个属性赋给p1这个对象。p1具备了age这个属性,值为:11。
    而p2.age没有在自身这个对象找到,则去类里面找到,打印出来


    初始化属性

    在调用类的过程中将我们需要的属性就给定义好,实例化对象后,直接调用这个属性即可。

    类里面具备一个__init__方法,注意:是init ,因为类里面同样有一个极其相似的方法,就是int,不一样的方法,实现的效果不同,切记!

    定义方法:

    class Person:
    	def __init__(self):
    		给对象初始化的属性
    

    使用方式:在__init__里面接收我们在调用类时传递进来的参数再赋给对象

    class Person:
    	def __init__(self,name,age): # 在调用类时,自动触发这个方法的运行
    		self.name = name
    		self.age = age
    
    p = Person('jack',18)
    print(p.name)
    print(p.age)
    

    执行效果:可以看到p对象已经拥有自己的属性

    jack
    18
    

    经过了解绑定方法以后,我们可以知道,上序self可以代表p对象,而self.name = name则是给p对象添加一个name属性而属性值则是我们调用类时传递进去的。

    在类里面调用方法需要携带self

    class Person:
        def f1(self):
            print('f1')
    
        def f2(self):
            self.f1()
            print('f2')
    
    p = Person()
    p.f2()
    

    执行结果

    'f1'
    'f2'
    

    类与数据类型

    这是我们可以再来看平常所定义的列表

    l = [1,2,3,4,5] # 平常都是这样定义的,那么我们可以这样
    # l = list([1,2,3,4,5]) 其实就是经过了list这个类而产生的,只不过我们平时不会这样写,因为Python会帮我们转换
    # 那么这个l就属于一个对象了,因为它是经历过调用类而实例化出的,所以它也有一些方法
    

    l对象的方法都是由list这个类提供的,因为它本身就是由list类产生的
    在这里插入图片描述
    那么再来与我们上序讲到的对象绑定方法结合就能理解,定义两个列表(对象)

    l1 = [1,2,3,4,5]
    l2 = [5,4,3,2,1]
    
    l1.append(6)
    l2.append(0)
    

    那我们调l1对象里面的方法与l2对象无关吧?因为它们都是实例化出的对象,每一个都是独立的,哪个对象调用append()这个方法也只是将这个对象传递进去,第二步再将我们需要给这个对象属性增加的值传递进去。
    在这里插入图片描述
    可以看到,也是由self参数接收了我们调用这个方法的对象,再是跟传递进来内容,只是由于这是个内置类(或C语言写的进行过编译)方法,所以看不到源码,也不用在意

    原理就是

    l = [1,2,3,4,5]
    l.append(6) # 等同于 list.append(l,6) 第一个是对象,第二个是值
    
    # 可以明白,第一个是传入的对象,第二个才是传入的值,那么我们就可以调用list这个类给l对象追加值
    list.append(l,7)
    
    print(l)
    

    打印结果

    [1, 2, 3, 4, 5, 6, 7]
    

    重点:

    在前面我们经常使用type()来查看我们变量值的属性,其实在学习面向对象以后可以得知,它反馈的只是我们这个变量值是由哪个类而产生的

    l = [1,2,3,4,5]
    print(type(l))
    

    打印结果

    <class 'list'>
    

    Python统一了类与类型的概念:类就是类型


    面向对象基础小结

    面向对象并不会使代码有所减少,但是更利于调用与拓展,我们可以通过几个练习来观察面向过程与面向对象之间的区别。

    链接中存在3个源码文件:

    有两个爬取梨视频网页的源码,实现效果一直,但所写方法不同。
    有一个使用面向对象来模拟王者荣耀英雄对战的源码文件。

    百度网盘:https://pan.baidu.com/s/13jM3eNwhASAB20wONuKCVg?errmsg=Auth+Login+Sucess&errno=0&ssnerror=0&#list/path=%2F&parentPath=%2F
    提取码:mwql

    有兴趣可以尝试写一下!!有助于巩固面向对象的基础内容


    下一章 进阶篇:https://blog.csdn.net/m0_46958731/article/details/111603575


    技术小白记录学习过程,有错误或不解的地方请指出,如果这篇文章对你有所帮助请点赞 收藏+关注 子夜欢迎您的关注,谢谢支持!

    展开全文
  • 如何进行Java的属性初始化步骤 1 : 对象属性初始化对象属性初始化有3种声明该属性的时候初始化构造方法中初始化初始化块.public class Hero {public String name = "some hero"; //声明该属性的时候初始化protected ...
  • 对象属性初始化

    2020-11-19 14:25:33
    对象属性初始化 1.声明该属性的时候初始化。 2.构造方法中初始化。 3.初始化块。 public class Hero2 { public String name="well done";//声明时初始化 protected float hp; float maxHP; { maxHP=100;//初始...
  • 步骤 1 : 对象属性初始化 对象属性初始化有3种 1. 声明该属性的时候初始化 2. 构造方法中初始化 3. 初始化块 package charactor; public class Hero { public String name = "some hero"; //声明该属性的...
  • 属性初始化

    2020-06-21 00:14:28
    对象属性初始化 对象属性初始化一共有3种 1.声明该属性的时候初始化 2.构造方法中初始化 3.初始化块 代码实例 public class Hero{ public String name ="some hero" ; //声明该属性的时候初始化 public Hero(){ ...
  • 1-对象属性初始化对象属性初始化有3种1. 声明该属性的时候初始化 2. 构造方法中初始化3. 初始化块代码比较复制代码1234567891011121314151617package charactor; public class Hero { public String name = ...
  • 对象属性初始化

    千次阅读 2018-05-12 11:40:38
    对象属性初始化有三种方式把初始化块,放在构造方法下面,问题:这三种方式执行顺序,构造方法-&gt;初始化块-&gt;声明时public class Hero { public String name = "some hero";//声明该属性的...
  • 文章目录2.2 类与对象属性初始化2.2.1对象属性初始化2.2.2 类属性初始化 2.2 类与对象属性初始化 2.2.1对象属性初始化 声明的同时初始化初始化(声明后初始化) 通过构造方法初始化 package charactor; ...
  • 对象属性初始化有3种 声明该属性的时候初始化 构造方法中初始化 初始化块 public class hero { public String name = "郭靖";//声明的时候初始化 { int hp = 500; //初始化块 } public hero() { int ...
  • 目录ES5ES6 对象属性简写属性初始化器(试验性写法) ES5 var obj = { method: function() {} } ES6 对象属性简写 var obj = { method() {} } 属性初始化器(试验性写法) 目前要使用babel编译babel编译 var obj...
  • 在python 中通常都会用__intit__方法来初始化对象,为对象添加属性,网上搜索都是讲怎么去初始化操作,举例中也没有看出什么大的差异,就想知道为什么要用初始化对象的方式来添加属性
  • 步骤1:对象属性初始化步骤2:类属性初始化步骤3:练习-属性初始化步骤4:答案-属性初始化 步骤1:对象属性初始化 对象属性初始化有3种 1. 声明该属性的时候初始化 2. 构造方法中初始化 3. 初始化块 ...
  • Java 属性初始化

    千次阅读 2018-12-16 12:58:54
    步骤 1 : 对象属性初始化 对象属性初始化有3种 1. 声明该属性的时候初始化  2. 构造方法中初始化 3. 初始化块 package charactor; public class Hero { public String name = "some hero"; //声明...
  • 0、目录1、对象属性初始化2、类属性初始化3、练习:属性初始化4、参考链接 1、对象属性初始化 对象属性初始化有3种 声明该属性的时候初始化 构造方法中初始化 初始化块 package charactor; public class Hero ...
  • Java-对象没有实例输出变量、对象
  • java 对象属性初始化顺序

    千次阅读 2018-05-30 16:19:56
    1、为静态属性分配内存并赋值(后面大括号语句不执行,这里是初始化,只是添加变量和值)   或 执行静态代码块(立刻执行大括号里面的语句)  为什么这样说呢,因为谁在前先加载谁,包括静态属性之间,和静态块...
  • JAVA类属性和对象属性初始化顺序

    千次阅读 2016-07-14 16:11:50
    1)类属性(静态变量)定义时的初始化,如:static String ="string-a"; 2)static块中的初始化代码,如 ...3)对象属性(非静态变量)定义时的初始化,如:static c="string -c"; 4)构造方法(函数)中的初始化代码,
  • 推荐使用初始化列表初始化 初始化列表我们不写,但是编译器依然会自动初始化一次 ———》针对自定义类型 声明和定义,声明是告诉程序我要定义这个东西 定义是实际开辟空间,分配内存 初始化列表可以认为初始化...
  • python类初始化属性在def init()中定义,实例化对象后可直接调用 python类非初始化属性在def func()中定义,实例化对象后,先调用调用函数,再调用属性 class Mdata(object): def __init__(self): self.mydata1 = ...
  • vue对象属性关联select,初始化select值 vue对象的某一个属性关联select,初始化select值,之后select选中其他下拉值没有选中显示在select种,有以下2种解决办法 在项目中如果select的v-model关联使用对象的某一个...
  • 在平常做项目的过程中,总是会遇到需要对一个已经定义过的对象属性值进行初始化,且对象属性值的类型有多种(string、number、array、object、boolean),为了方便自己就简单封装了一个函数。 objInit(obj) {...
  • 对象属性初始化有3种 声明该属性的时候初始化 构造方法中初始化 初始化块 package charactor; public class Hero { public String name = "some hero"; //声明该属性的时候初始化 protected float ...
  •  将实现联系人(Contact)业务类,创建对象后,将使用默认值初始化对象。 由上图我们可以知道,我们需要初始化的属性包括: 简单属性(名字(First Name)、尊称(Title Of Country))  引用属性(...
  • Java初始化对象

    2018-12-22 21:10:29
    初始化对象:给对象的属性赋值 ** 1:直接赋值法 不常用(除非是那种固定不变值只有一个的) 直接在成员变量的后面赋值 2:类名 对象名 = new 类名(); 不常用 对象名.属性名 3:构造器初始化 Dog dog = new Dog(); ...
  • JS初始化对象

    2020-05-14 18:11:37
    什么是初始化对象? 顾名思义,我们创建对象时便已调用默认编写的init方法,实现初始化。 我们要求调用say方法时,能输出init里的属性。 实现 一、 先调用init方法 输出: wc 1 这种方法每次需要手动输入,不满足...
  • 初始化列表(初始化属性) 语法: 构造函数():属性1(值),属性2(值),属性3(值)… class Stu { public: int grade; string name; string six; Stu(string a,int b,string c) :name(a), grade(b), six(c) { //...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,627
精华内容 5,850
关键字:

初始化对象属性