精华内容
下载资源
问答
  • JS_创建对象+调用对象方法

    千次阅读 2017-07-07 14:12:06
    12th_test 这是一个标题 这是一段文字 var person = { //person是一个对象 firstName: "John", lastName: "Doe", ... toString: function() //toString()是person对象的一个方法 { return this.firs
    <!DOCTYPE html>
    <html>
    <head>
    <title>12th_test</title>
    <meta charset="gb2312">
    </head>
    
    <body>
    <h1>这是一个标题</h1>
    <p id="demo">这是一段文字</p>
    
    <script>
    	var person = {  //person是一个对象
    	firstName: "John",
    	lastName: "Doe",
    	age: 50,
    	eyeColor: "blue",
    	toString: function()   //toString()是person对象的一个方法
    	{
    		return this.firstName + " 现在 " + this.age + " 岁<br>";
    	}
    	};
    	document.getElementById("demo").innerHTML = person.toString();  //调用person对象的toString()方法
    </script>
    </body>
    </html>

    output:

    这是一个标题
    
    John 现在 50 岁

    展开全文
  • 对象 调用方法

    千次阅读 2018-09-12 16:52:26
    class Cat: # 定义类 对象必须有对应的类 类名使用大驼峰命名法 # 定义对象方法 对象方法需要在对应的类中定义 def eat(self): # 定义...创建对象 cat1 = Cat() 调用对象方法 引用对象的变量名.方法名() ca...

    class Cat: # 定义类 对象必须有对应的类 类名使用大驼峰命名法
    # 定义对象方法 对象方法需要在对应的类中定义
    def eat(self): # 定义对象方法和定义函数类似,只不过对象方法的第一个形参必须是self
    print(“吃东西”)

    创建对象
    cat1 = Cat()
    调用对象方法 引用对象的变量名.方法名()
    cat1.eat() # 定义对象方法时必须设置第一个形参为self,但是调用时不要设置self对应的实参

    class Cat: # 定义类
    pass

    创建对象
    cat1 = Cat()
    定义属性 首次赋值就会被定义
    cat1.type = “猫”
    print(cat1.type)
    cat1.type = “卡通猫” # 再次赋值,只是改变记录的数据
    print(cat1.type)

    class Cat: # 定义类
    # 定义方法
    def eat(self):
    print(“吃东西”)

    同一个类可以创建多个对象
    创建对象
    tom = Cat()
    tom.eat() # 同一个类的不同对象都可以调用对象方法(可以有相同的行为)
    tom.type = “卡通猫” # 同一个类的不同对象中的属性记录的数据可能是不同的(每个个体对应的数据不同)
    print(tom.type)

    创建另一个对象
    jiafei = Cat()
    jiafei.eat()
    jiafei.type = “家猫”
    print(jiafei.type)

    class Cat:
    def introduce(self): # self 指的是 调用该方法的对象
    “”“自我介绍”“”
    print(“我是 %s” % self.type)
    self.age = 10 # self也可以作为对象来定义对象属性

    创建对象1
    tom = Cat()
    tom.type = “卡通猫”
    tom.introduce() # 解释器 会自动将调用方法的对象作为方法的第一个实参进行传递
    print(tom.age)

    创建对象2
    jiafei = Cat()
    jiafei.type = “家猫”
    jiafei.introduce()
    print(jiafei.age)

    class Cat:
    def init(self, type): # init可以设置自定义参数,用于实现属性的不同初始值
    # 初始化方法
    self.type = type

    def introduce(self):
        """自我介绍"""
        print("我是 %s" % self.type)
    

    创建对象1
    tom = Cat(“卡通猫”) # init自定义形参对应的实参在创建对象的()中传递
    调用对象方法
    tom.introduce()
    print(tom.type)

    jiafei = Cat(“家猫”)
    print(jiafei.type)

    class Cat:
    def init(self, name, age):
    self.name = name
    self.age = age

    def __str__(self):  # 实现该方法后,返回什么内容,打印对象时就显示对应的内容
        return "我的名字 %s, 年龄 %d" % (self.name, self.age)
    

    tom = Cat(“汤姆”, 60)
    print(tom)

    展开全文
  • java基础-反射3(反射,反射创建对象,操作对象属性,调用对象方法)前面通过学习,我们了解的运行时类型信息的基本原理,以及通过Class对象和反射来获取运行时类型信息。下面来了解通过反射来创建对象,以及操作...

    java基础-反射3(反射,反射创建对象,操作对象属性,调用对象方法)

    前面通过学习,我们了解的运行时类型信息的基本原理,以及通过Class对象和反射来获取运行时类型信息。下面来了解通过反射来创建对象,以及操作对象的属性和方法

    首先还是创建一个person类

    
    @Service
    public class Person1 extends PersronParent implements PersonInterfance ,Cloneable{
        public  String name;
        public  double weight;
        protected  double height;
        private Integer age;
    
        public Person1(){}
    
        protected Person1(String name){
        }
        public void publicShow() throws Exception{
            System.out.println("publicShow()");
        }
        protected void disPlay(){
            System.out.println("disPlay()");
    
        }
    
        private String privateShow(String paramter1,String paramter2) throws NullPointerException{
            StringBuffer stringBuffer  = new StringBuffer(paramter1);
            return stringBuffer.append(paramter2).toString();
        }
        @Deprecated
        private int testParamter(String paramter1,String paramter2) throws NullPointerException{
            return 1;
        }
    
        @Deprecated
        public int testPublicParamter(String paramter1,String paramter2) throws NullPointerException{
            return 1;
        }
    
        @Override
        public void parentSay(){
            super.parentSay();
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public double getWeight() {
            return weight;
        }
    
        public void setWeight(double weight) {
            this.weight = weight;
        }
    
        public double getHeight() {
            return height;
        }
    
        public void setHeight(double height) {
            this.height = height;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", weight=" + weight +
                    ", height=" + height +
                    ", age=" + age +
                    '}';
        }

    通过反射来创建对象

    通常在java中我们有以下4中方式创建对象

    1. 通过new 关键字 创建对象
    2. 通过Object clone();方法
    3. 通过反序列化
    4. 通过反射创建

    这里我们来了解通过反射来创建对象和调用方法

    首先我们来看通过反射来创建对象
    我们通过newInstance()来创建对象,如果对于无参数的构造方法我们直接用Class的对象的newInstance()就可以创建对象
    如果对于有参数的构造方法,我们需要先获取带参数的构造器(注意权限修饰符),然后通过构造器的newInstance()方法创建对象。

    public class TestReflect {
    
        public static void main(String[] agrs){
    
                Class<Person> personClass = Person.class;
                try {
                    /**
                     * 通过无参数的构造方法创建对象
                     */
                    Person personOne =   personClass.newInstance();
                    /**
                     * 通过有参数的构造方法创建对象
                     */
                    Constructor constructor = personClass.getDeclaredConstructor(String.class);
                    Person personTwo =   (Person) constructor.newInstance("带参数");
    
                } catch (InstantiationException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (NoSuchMethodException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                }
    
        }
    
    }
    

    运行结果如下
    这里写图片描述

    这样我们就可以通过反射来创建对象。
    通过反射创建对象后可以通过反射来给操作对象的属性

    通过反射操作对象属性

    上一篇文章说过,类的属性在反射中使用java.lang.reflect.Field表示,当然也使用这个类来操作对象的属性,在java中属性的访问涉及到权限修饰的修饰,具体如下:
    这里写图片描述

    所以在操作对象的属性的需要注意对目标类属性访问的权限,如下
    如果当前类对目标对象有访问的权限(如目标类属性为public)

    1. 通过Class对象的getField()获取Field。
    2. 然后通过Field的set()方法对目标对象赋值。

    如果当前类对目标对象没有访问的权限(如目标类属性为private)

    1. 通过Class对象的getDeclaredField()获取Field。
    2. 调用Field 的setAccessible(true)方法,设置为可访问(如果不设置为true,则在当前类中不能访问目标类的属性,在为目标对象赋值时会报错)
    3. 然后通过Field的set()方法对目标对象赋值。
    4. 调用Field 的setAccessible(false)方法复原。

    具体操作如下

    public class TestFileId2 {
        public static void main(String agrs[]) throws NoSuchFieldException {
            try {
                //获取Class 对象
                Class<Person> personClass  = Person.class;
                //创建目标对象(注意,我们这里直接用的object,更体现了运行时类型信息)
                Object person = personClass.newInstance();
                //在没有通过反射赋值之前
                System.out.println("person对象在没有赋值之前");
                System.out.println(person.toString());
                System.out.println();
    
                System.out.println("当前类可以操作目标类的属性:比如public权限的属性");
                //获取有权限操作的属性(当前类可以操作目标对象的属性:比如public)
                Field name = personClass.getField("name");
                //为person 对象 的 name属性赋值为 TestName
                name.set(person,"TestName");
                System.out.println(person.toString());
                System.out.println();
    
                System.out.println("当前类不能够操作目标类的属性:比如private权限的属性");
                Field age = personClass.getDeclaredField("age");
                //为person 对象 的 age 属性设置为可访问
                age.setAccessible(true);
                //为person 对象 的 age属性赋值为 10
                age.set(person,10);
                age.setAccessible(false);
                System.out.println(person.toString());
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
    }

    运行结果如下
    这里写图片描述

    通过反射调用对象方法

    反射能够操作对象的属性,当然也可以操作对象的方法,方法通过java.lang.reflect.Method表示,由于访问权限的限制,对于方法也有如下操作
    如果当前类对目标对象有访问的权限(如目标类方法为public)

    1. 通过Class对象的getMethod()获取Method。
    2. 然后通过Method的invoke()方法对目标对象赋值。

    如果当前类对目标对象没有访问的权限(如目标类方法为private)

    1. 通过Class对象的getDeclaredMethod()获取Method。
    2. 调用Method的setAccessible(true)方法,设置为可访问(如果不设置为true,则在当前类中不能访问目标类的方法,在调用目标类的方法时会报错)
    3. 然后通过Method的invoke()方法对目标对象赋值。
    4. 调用Method的setAccessible(false)方法复原。

    具体操作如下:

    public class TestMethod2 {
        public static void main(String agrs[]) throws NoSuchFieldException, NoSuchMethodException, InvocationTargetException {
            try {
                //获取Class 对象
                Class<Person> personClass = Person.class;
                //创建目标对象
                Object person = null;
                person = personClass.newInstance();
    
                System.out.println("当前类可以操作目标类的方法:比如public权限的方法");
                //获取有权限操作的方法(当前类可以操作目标对象的方法:比如public)
                Method publicShow = personClass.getMethod("publicShow");
                //通过Method 的invoke 调用person 的 publicShow方法
                publicShow.invoke(person);
    
    
                System.out.println("当前类不能够操作目标类的方法:比如private权限的方法");
                Method privateShow = personClass.getDeclaredMethod("privateShow", String.class, String.class);
                //为person 对象 的 privateShow 方法设置为可访问
                privateShow.setAccessible(true);
                //通过Method 的invoke 调用person 的 privateShow方法
                String result = (String) privateShow.invoke(person, "参数1", "参数2");
                System.out.println(result);
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
    
    }
    

    运行结果如下:
    这里写图片描述

    以上就是通过反射操作对象的基本方式。

    反射的基础知识就是以上几篇文章,反射相对于其他知识来说比较简单,但是反射应用很多,比如很多框架,以及java中的动态代理等都涉及到了,所以反射在java中还是很重要的。

    展开全文
  • 由输出结果可见,当创建子类对象时首先调用了父类的构造方法,再调用子类的构造方法,值得注意的是传给父类构造方法的this指针和传给子类构造方法的this指针完全相同,也就是说调用父类构造方法的并不是父类的对象,...


    如下实例提出问题:

    class T{
        T(){
            System.out.println("T()");
        }
       void foo(){this.bar();}
       void bar(){
           System.out.println("T.bar");
       }
    }
    class B extends T{
        B(){
            System.out.println("B()");
        }
       void foo(){
           super.foo();
       }
       void bar(){
           System.out.println("B.bar");
       }
    }
    public  class test {


        public static void main(String[] args) {
            B b=new B();
            b.foo();
        }
    }

    结果输出如下:


    其实我相信这样的结果可能大家都是惊讶的,b.foo()实际是调用了父类中的foo()方法,方法主体为this.bar

    由结果可以得到this实际指的是子对象。

    分析:

    由输出结果可见,当创建子类对象时首先调用了父类的构造方法,再调用子类的构造方法,值得注意的是传给父类构造方法的this指针和传给子类构造方法的this指针完全相同,也就是说调用父类构造方法的并不是父类的对象,所以在创建子类对象时并没有创建父类对象。this指向的仍然是子对象,同时由于子类重写了父类的bar()方法,所以输出为B.barr

    在原代码上做轻微改动如下:

    class T{
        T(){
            System.out.println("T()");
        }
       void foo(){this.bar();}
       void bar(){
           System.out.println("T.bar");
       }
    }
    class B extends T{
        B(){
            System.out.println("B()");
        }
       void foo(){
           super.foo();
       }
     /*void bar(){
           System.out.println("B.bar");
       }*/
    }
    public  class test {
        public static void main(String[] args) {
            B b=new B();
            b.foo();
        }

    }

    输出结果如下:


    由于此时子类并未重写父类方法,故输出为T.bar

    展开全文
  • 定义类 声明对象 创建对象 实例化对象 属性 对象调用属性或者方法 举例,下面定义类了一个类并声明属性,写了一个方法: class Person { public String name; //声明属性 public int age; //声明属性 ...
  • callComponentPB方法调用中会创建HttpProtobufComponentExecutor对象,并且调用invokeTainluRpcService方法,该方法由上面的mock逻辑模拟 */ Object result = this.callComponentPB("mdmQueryAcct", params); ...
  • Python创建对象:对象名称=类() class Point: pass p1 = Point() p2 = Point() 在创建对象时,Python解释器会自动执行以下操作: 1.创建对象----为对象在内存中分配空间; 2.初始化方法(init)—为对象的属性设置...
  • 初学反射,在个人理解中,他的主要目的是为了让系统实现可扩展 可配置。 反射+配置文件+工厂 为例 先来一个接口类 public interface IShowFun ...一个集成该接口的方法 public class ShowGirlFun:IShowFun {
  • C# 反射详解 定义 动态创建对象调用实例方法 1、反射的定义及功能介绍:审查元数据并收集关于它的类型信息的能力。元数据(编译以后的最基本数据单元)就是一大堆的表,当编译程序集或者模块时,编译器会创建一个...
  • Java创建对象详解:Java创建对象的几种方法

    万次阅读 多人点赞 2019-05-10 20:01:32
    对象是对类的实例化。对象具有状态和行为,变量用来表明对象的状态,方法表明对象所具有的行为。Java 对象的生命周期包括创建...这是常用的创建对象方法,语法格式如下: 类名 对象名=new 类名(); 2. 调用 java....
  • Java抽象类不可创建对象,但可以调用静态方法将建一个对象,利用多态创建子类对象上转成父类类型。 附代码: public abstract class Dog { private int age; private String sex; private String name; public int...
  • java的类加载顺序和创建对象时的调用顺序类的加载顺序创建对象的过程注意 类的加载顺序 有父子关系的类在加载时 先调用父类静态初始化块,静态属性,但不包括静态方法,然后再是,子类静态初始化块,静态属性,但...
  • new创建对象是否调用构造函数和析构函数

    千次阅读 多人点赞 2019-11-18 19:43:25
    1.指针不会调用构造和析构函数,只是定义了一个指针,没有申请内存:...使用new创建对象时,申请分配内存,调用构造函数: 当我们使用new为指针开辟空间,然后用delete释放掉空间会分别调用构造和析构函数: ...
  • 2.实例化一个servlet 创建Servlet对象 3.init方法 做一些初始化工作..比如从web.xml文件中读取配置信息 4.service方法 来处理客户端请求 判断请求类型get 调用doGet,post 调用doPost 在该方法中完成 5.destroy...
  • java中创建对象方法

    万次阅读 2020-02-17 22:46:52
    有4种显式地创建对象的方式: 1.用new语句创建对象,这是最常用的创建对象的方式。 2.运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法。 3.调用对象的clone()方法...
  • 1.在java中创建对象和c语言中有很大不同, 基本数据类型不需要new而直接定义,而引用数据类型在定义实例 时需要new实例对象。 调用方法有不同方式: 当一个方法被声明为static时,就可以直接使用"类名....
  • Python如何使用类对象调用实例方法

    千次阅读 2020-05-06 15:29:40
    在前面的学习中,我总结了...我们知道,实例对象可以调用这三种方法,而类对象只能调用类方法和实例方法,既然如此为何我们还要研究类对象调用实例方法呢?我们先看一个例子: class Dog: def action(self): ...
  • 子类继承父类时,创建对象,构造方法调用问题

    万次阅读 多人点赞 2017-11-03 21:05:00
    在学习继承的时候,遇到一些小问题,这里总结一下,有错误望指正: 先来看一段代码: //标准父类 class Father{ ... //构造方法 //空参 public Father(){ } //有参 public Father(String nam
  • 通常情况下在父类中不能直接调用子类中的方法(重写的除外),但是在某些特殊的情况下,需要根据一个父类的对象调用子类的方法,原理就使用java的反射原理。例如:Person类,有一个name属性 public class Person { ...
  • VB中可以直接用CreateObject("ProgID"或者"CLSID")就可以创建com对象,然后直接使用它的方法和属性,但是c#... 后续的对象函数的调用能够通过InvokeMember方法来实现。 如在VB中的源代码如下: Public Sub TestCre
  • 对象从xib中创建初始化完毕的时会调用方法/** * 当一个对象从xib中创建初始化完毕的时候就会调用一次 */ -(void)awakeFromNib {}// 注:通过代码创建初始化一个对象的时候,才会调用init方法
  • d = u2.connect() #该方法返回一个UIAutomatorServer类的实例 d(discription = 'Books').click() # ???wtf,怎么对象名字后面带个括号,什么操作? 为了搞懂这个原因,我把代码里原来正确的参数description随便改成...
  • 编写类A,该类创建对象包含一个方法f输出英文字母表,再编写一个A类的子类B,要求必须继承A类的方法f(不允许重写),子类创建对象不仅可以调用方法f输出英文字线表,而且调用子类新增的方法g输出希腊字母表(α...
  • JS 创建自定义对象方法

    万次阅读 2020-04-22 13:46:40
    优点:接受参数,可以无数次的调用这个函数,创建Person对象,而每次他都可以返回一个包含三个属性一个方法对象。 缺点:虽然解决了创建多个相似对象的问题,但是没有解决对象识别的问题(即怎么知道一个对象的...
  • JavaScript创建对象的4种方法

    千次阅读 2018-11-28 15:02:24
    JavaScript 创建对象的4种方法 所谓对象就是用来帮助你完成一些事情是,对象是有特征和行为的,是具体特指的某一个事物。使用对象可以使程序更加整洁 通过Object()方法来创建 Object()是JavaScript内部的对象...
  • java中,静态方法可以直接被类调用,非静态方法直接被对象调用,如下。 public class Person { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub ...
  • 问题:创建子类对象时,父类构造函数中调用被子类重写的方法为什么调用的是子类的方法,而被子类重载的方法不会调用? public class Basic{ public void add(int i) { System.out.println("Basic add"); } ...
  • Java中调用对象方法的执行过程

    千次阅读 2017-09-25 20:09:08
    编译器查看对象的声明类型和方法名。假设调用x.f(param),且隐式参数x声明为C类的对象。需要注意的是:有可能存在...接下来,编译器将查看调用方法时提供的参数类型。如果在所有名为f的方法中存在一个与提供的参数类型

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,690,575
精华内容 1,076,230
关键字:

创建对象调用方法