精华内容
下载资源
问答
  • 调用方法或函数 方法1: class B { public A a=new A();//要实例化。 } 方法2(A是静态方法,直接调用,不用实例化了): class A {  static void a(){}; } class B {  A.a; } 方法3: 调用委托   ...

    一、调用方法或函数

    方法1:

    class B
    {
    public A a=new A();//要实例化。
    }

    方法2(A是静态方法,直接调用,不用实例化了):

    class A

    {
        static void a(){};
    }

    class B
    {
        A.a;
    }

    方法3:

    调用委托

     

    二、调用属性

    方法1:

    public class A
    {
        private string name;//字段,用私有保护
      
        public string Name//属性,用public以便访问,修改。
        {
            get
            {
               return name;
            }
            set
            {
                name = value;
            }
        }
    
        public string Name()//方法,注意它是多了一对括号。
        {
         
        }    
    }
    
    public class B
    {
        A.Name;//调用属性,即可调用字段name
        A.Name();//调用方法
    }

    展开全文
  • this是一个非常灵活的关键字,不会明确表示一个固定概念,比如int,它就是表示一个整型。 1、调用类属性 中有许多成员,大部分情况下中直接进行成员调用,但是为了清楚的描述调用是本类属性,会用this.属性...

    目录

    1、调用本类属性

    2、调用本类方法

    3、表示当前对象


    this是一个非常灵活的关键字,不会明确表示一个固定概念,比如int,它就是表示一个整型。

    1、调用本类属性

    类中有许多成员,大部分情况下类中直接进行成员调用,但是为了清楚的描述调用是本类属性,会用this.属性表示。

        class Person{
            String name;
            int age;
            public Person(){}
            public Person(String name, int age) {
                name = name;
                age = age;
            }
        }

    如上定义的类,构造方法按上述写法,对象中不会保存我们定义的内容,而是默认值,因为程序以{}为界定范围,如果在此范围内有指定的变量名称,则会直接调用,若没有,则会调用类中的相应属性。

    当参数与属性名称相同时,则会出现混淆,则需要用户自己手动明确调用的是属性还是方法中的参数,若是属性,则需要加this.属性,标准程序开发中都会以此方式进行:

        class Person{
            String name;
            int age;
            public Person(){}
            public Person(String name, int age) {
                this.name = name;
                this.age = age;
            }
        }

    2、调用本类方法

    一个类中存在普通方法和构造方法,this调用本类方法时,对应的语法不同:

    1)调用本类中的其他方法:this.方法()

    一个类中可能存在很多方法,这些方法之间可以直接进行调用,但是不够标准,应用this.方法()调用,标准化风格。

    2)调用本类其他构造方法:this()

    一个类中可以有多个方法,且可以重载,并且构造方法在实例化对象时只能被调用一次。

    若现在需求:Person类中中有三个构造方法,无论调用哪个构造方法,都要求执行语句"**********"。

    【举例】:原始实现方式

        class Person{
            String name;
            int age;
            public Person(){
                System.out.println("********");
            }
            public Person(String name, int age) {
                this.name = name;
                this.age = age;
                System.out.println("********");
            }
        }

    程序设计的一个重要原则,避免重复代码。按照这个原则,以上的代码并不符合开发要求,这时可以使用this()形式实现,调用本类无参构造。

    class Person{
            String name;
            int age;
            public Person(){
                System.out.println("********");
            }
            public Person(String name) {
                this();
                this.name = name;
            }
            public Person(String name, int age) {
                this(name);
                this.name = name;
                this.age = age;
            }
        }

    需要注意的是,this()形式只能放在构造方法的首行。在使用this()调用本类其他构造方法时,应该避免循环调用。

    下面通过实例说明构造方法互调的意义所在。

    【举例】:写一个雇员的信息类,类中提供如下四个属性:姓名、职位、部门、工资,还有4个构造方法:

    • 无参构造:姓名未知、职位待定、部门后勤、工资为0;
    • 单参构造(姓名):职位主管、部门技术部、工资10;
    • 双参构造(姓名、部门):职位工程师、工资5;
    • 四参构造。

    针对以上要求可以有两种代码实现方法:

    第一种:传统实现

    protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
    
            Emp emp = new Emp();
            System.out.println(emp.getInfo());
    
        }
    
    
        class Emp{
            private String name;
            private String job;
            private String dept;
            private double sal;
    
            public Emp(){
                this.name ="未知";
                this.job = "待定";
                this.dept = "后勤";
                this.sal = 0.0;
            }
            public Emp(String name){
                this.name =name;
                this.job = "主管";
                this.dept = "技术部";
                this.sal = 10.0;
            }
            public Emp(String name,String dept){
                this.name =name;
                this.job = "工程师";
                this.dept = dept;
                this.sal = 5.0;
            }
    
            public Emp(String name,String job, String dept, double sal){
                this.name =name;
                this.job =job;
                this.dept = dept;
                this.sal = sal;
    
    
            }
            public String getInfo(){
                return "姓名:"+this.name+"职位:"+this.job+"部门:"+this.dept+"工资:"+this.sal;
            }
        }

    以上程序重复的代码太多,过于冗余。

    第二种:使用this改进

     protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
    
            Emp emp = new Emp();
            System.out.println(emp.getInfo());
    
        }
    
    
        class Emp{
            private String name;
            private String job;
            private String dept;
            private double sal;
    
            public Emp(){
                this("未知","待定","后勤",0.0);
            }
            public Emp(String name){
                this(name,"主管","技术部",10.0);
            }
            public Emp(String name,String dept){
                this(name,"工程师",dept,5.0);
            }
    
            public Emp(String name,String job, String dept, double sal){
                this.name =name;
                this.job =job;
                this.dept = dept;
                this.sal = sal;
            }
            public String getInfo(){
                return "姓名:"+this.name+"职位:"+this.job+"部门:"+this.dept+"工资:"+this.sal;
            }
        }

    以上代码消除了很多重复代码,实际开发中应用较多。

    3、表示当前对象

    一个类,可以生成若干个对象,每个对象都可调用类中的方法,类中实际上很难描述某一个具体的对象,为了能区分出当前正在操作类中的方法是哪一个,可以使用this完成。

    【举例】:观察

        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
    
            Person perA = new Person();
            Person perB = new Person();
    
            System.out.println("MainActivity类中对象输出:"+perA);
            System.out.println("MainActivity类中对象输出:"+perB);
    
        }
    
        class Person{
        }

    protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
    
            Person perA = new Person();
            Person perB = new Person();
    
            System.out.println("MainActivity类中对象输出:"+perA);
            perA.print();
            System.out.println("--------------------------------");
            System.out.println("MainActivity类中对象输出:"+perB);
            perB.print();
    
        }
    
        class Person{
    
            void print(){
                System.out.println("Person类中的输出,this="+this);
            }
        }

    由以上可知,由perA调用print()方法时,this=perA,由perB调用print()方法时,this=perB, 所以,this的对象引用会随着调用类方法对象的不同而不同,属于相对性的概念。

    进一步考虑,this.属性表示的就是当前对象中的属性。

     

    作于202004051735,已归档

    ———————————————————————————————————

    本文为博主原创文章,转载请注明出处!

    若本文对您有帮助,轻抬您发财的小手,关注/评论/点赞/收藏,就是对我最大的支持!

    祝君升职加薪,鹏程万里!

    展开全文
  • 一个c#调用类“PlayerManager”中的方法 : PlayerManager.Instance.SyncAnimation(userId, "Shot", 1); 在PlayerManager中 public static PlayerManager Instance {  get {  return instance;  } ...

    1.  

    在一个c#类中调用类“PlayerManager”中的方法 : PlayerManager.Instance.SyncAnimation(userId, "Shot", 1);

    在PlayerManager类中

    public static PlayerManager Instance {
      get {
            return instance;
      }
     }

     void Awake() {
      instance = this;
     }

     

    2.

    在一个c#类中调用类“NetworkTransform”中的方法    NetworkTransform.FromTransform(thisTransform);

    在“NetworkTransform”类中:

     public static NetworkTransform FromTransform(Transform transform) {
      NetworkTransform trans = new NetworkTransform();
        
      trans.position = transform.position;
      trans.angleRotation = transform.localEulerAngles;
        
      return trans;
     }

     

    3.

             ScriptName other;
             other = gameObject.GetComponent("ScriptName") as ScriptName;
             other.DoSomething();

     

    4.通过SendMessage方法调用


    private void CheckRaycastWithEnemy() {
      Ray ray = Camera.main.ViewportPointToRay(new Vector3(0.5f, 0.5f, 0));
      RaycastHit hit;
      if (Physics.Raycast (ray, out hit, Mathf.Infinity, 1<<(int)GameLayers.TargetLayer)) {
       hit.collider.SendMessage("RaycastMessage", SendMessageOptions.DontRequireReceiver);
       
      }
     } 

    在Enemy类中有方法“RaycastMessage”:

    void RaycastMessage() {
      timeSinceLastRaycast = 0;
     }

    展开全文
  • 1、在A中调用name的过程中发现报错Type The field Item.name is visible,原因在于两个不在同一个包中不能调用,要求父类的属性为public,子类的对象才能够通过 **“.属性”**进行调用并赋...

    1、调试程序说明:

    编写类A(Armor)继承类B(Item)的属性,并在A类中创建A的对象调用B类的属性以及A自己的属性。
    类B:
    在这里插入图片描述
    类A:
    在这里插入图片描述

    2、问题说明、解决:

    1、在类A中调用name的过程中发现报错Type The field Item.name is visible,原因在于两个类不在同一个包中不能调用,要求父类的属性为public,子类的对象才能够通过 **“.属性”**进行调用并赋值。

    在这里插入图片描述
    在这里插入图片描述
    将类Item改为如下图所示即可。
    在这里插入图片描述

    2、在其他类中创建A的对象进行调用ac时(如下代码块所示),如果ac并没有定义为public或private或其他的,就是默认的default,即不加任何访问修饰符,通常称为“默认访问模式“。该模式下,只允许在同一个包中进行访问。此时调试会报错Type The field Item.name is visible。将ac的定义为public即可(如下图)。

    在这里插入图片描述

    package code.Hero;
    import code.armor.Armor;
    
    public class Hero {
    	float hp;		
    	public static void main(String []arges)
    	{						
    		Armor bujia = new Armor();
    		bujia.name = "布甲";
    		bujia.price = 300;
    		bujia.ac = 15;						
    	}
    
    }
    
    

    关于修饰符public、private、protect、default。

    public: Java语言中访问限制最宽的修饰符,一般称之为“公共的”。被其修饰的类、属性以及方法不仅可以
    跨类访问,而且允许跨包(package)访问。
    private: Java语言中对访问权限限制的最窄的修饰符,一般称之为“私有的”。被其修饰的类、属性以及方法只能被该类的对象访问,其子类不能访问,更不能允许跨包访问。
    protect: 介于public 和 private 之间的一种访问修饰符,一般称之为“保护形”。被其修饰的类、属性以及方法只能被类本身的方法及子类访问,即使子类在不同的包中也可以访问。
    default:即不加任何访问修饰符,通常称为“默认访问模式“。该模式下,只允许在同一个包中进行访问。

    写在最后:

    其实问题1、2是一样的原因,只是不同发生情况,如果两个类在同一个包中是可以调用的,充分学习细节知识,就能解决问题。
    文中有不当之处,请多指教,谢谢!
    如还有不理解的话,参考链Java权限修饰符private、default(一般省略)、public、protected ,写的很详细,应该能帮到你(我看了之后帮到我了)。

    展开全文
  • 在继承之外,在C++中一个成员函数调用一个类成员的方法主要有:的组合,友元的前向声明,单例模式等,下面主要讲讲这4种方法的实现 方法1:利用的组合 组合通俗来讲就是B有A的属性,如声明一个...
  • python---调用类属性方法

    万次阅读 2018-03-23 17:26:15
    简单看下调用使用的方法吧。 来看例子:目录结构: 我们现在要在do_class.py这文件里调用class_learn.py里的代码(do_class.py):#!/usr/bin/env python3#coding=utf-8'''@Author:Jock'''from all_python_...
  • C++中一个成员函数调用一个类成员的方法

    万次阅读 多人点赞 2018-10-31 23:13:01
    在C++中一个成员函数调用一个类成员的方法主要有:的组合,友元,单例模式等,下面主要讲讲这三种方法的实现 方法1:利用的组合 组合通俗来讲就是B有A的属性,如声明一个Person,再声明一个...
  • IDEA 查看属性调用

    千次阅读 2020-04-07 19:06:40
    IDEA提供的 Find Usages是一个查看调用链非常好用的方法,它的快捷键是Alt+F7 Find Usages可以查看方法属性调用链 1.1.1 查看方法属性调用链 选中需要查看的方法属性 的名称,然后右键选择...
  • 静态方法调用 非静态方法调用 静态属性 static $name = 'xiaoming' self::$name self::$name 非静态属性$name = 'xiaoming' 不能,报Fatal error,不能使用self::调用非静态属性,也不能使用$this ...
  • java外部如何调用内部属性方法 解决方法: 直接看代码 public static void main(String[] args) { //调用静态内部的方式1 TestChild testChild = new TestChild(); testChild.test(); //...
  • 彻底搞懂Python类属性方法调用

    万次阅读 多人点赞 2020-03-29 15:22:35
    Python从设计之初就已经是一门面向对象的语言,正因为如此,在Python中创建一个类和对象是很容易的。 一、、对象概述 在面向对象程序设计中,把数据以及对数据的操作封装在一起,组成一个整体(对象),不同对象...
  • C# 窗体中一个类调用一个窗体的控件或方法

    万次阅读 多人点赞 2017-06-17 16:43:03
    设有form1和from2,假如form1调用form2的控件,在form1的代码窗口定义一个form2的对象,把你想要调用的form2的控件的属性Modifier改为Publlic就可以在form1的窗体调用了。 一种是创建窗体对象的方式,通过对象...
  • 种是创建窗体对象的方式,通过对象调用控件或方法种是不创建窗体对象 在窗体下定义静态变量,构造方法中引用窗体
  • Python 通过字符串调用类方法或方法

    千次阅读 2019-04-08 14:22:42
    今天遇到个问题,在一个类里面,想要通过字符串调用类里面的方法,即(注意,以下为错误代码演示,只是为了表述问题): class A(object): def a(self): print('xxxxx') def b(self): c= 'a' self.c() ...
  • Python中内部 class MyOuter: age=18 def __init__(self,name): self.name=name class MyInner: def __init__(self,inner_name): self.inner_name=inner_name out=MyOute...
  • php里调内部调用及外部调用类中的属性和函数的方法
  • 【Python—】 同一个类一个函数里调用一个函数的方法 class Solution: def a(self): self.b() # 注意这种写法:self.类名 def b(self): print('在这里') a = Solution() a.a()
  • java 关于调用一个类的私有方法

    千次阅读 2018-12-21 11:06:55
    工作中为了不重复造轮子,使用java反射机制来调用已经写好的私有方法,防止代码冗余,反射是不错的选择! 调用私有方法:getDeclaredMethod() //可以调用类中的所有方法(不包括父类中继承的方法) 代码: ...
  • #定义一个类a class a(): def __init__(self,input): #定义一个实例属性 self.height = input ... #定义另一个实例方法,该方法需要方法A中的返回值,则在方法B中这样调用 def B(self): print(a.A(self))
  • 多态 父类的引用可以调用子类中重写的父类的方法,但不能调用子类中独有的方法,即不能调用父类中不存在,子类中存在的方法
  • class Gun: def __init__(self,model): # 枪的类型 self.model = model # 子弹数量 self.bullet_number = None # 查询子弹数量 def queryBulletsNum(self): return self.bu...
  • python初始化属性在def __init__()中定义,实例化对象后可直接调用 python非初始化属性在def func()中定义,实例化对象后,先调用调用函数,再调用属性 代码 class Mdata(object): def __init__(self): ...
  • property: set 方法注入,name属性是所要注入的属性名称,value属性是所要注入的属性值,ref表示引用一个对象 --> <constructor-arg name="username" value="maxiao"></constructor-arg> ...
  • 类方法不能直接访问自己的属性 即 ...在类方法中要访问自己的属性,必须要在中实例化一个对象,然后再调用; 如下方代码: [objc] view plain copy //  // F
  • 对象 调用方法

    千次阅读 2018-09-12 16:52:26
    class Cat: # 定义 对象必须... def eat(self): # 定义对象方法和定义函数类似,只不过对象方法的第一个形参必须是self print(“吃东西”) 创建对象 cat1 = Cat() 调用对象方法 引用对象的变量名.方法名() ca...
  • 20.python-类属性类方法

    千次阅读 2019-11-28 00:49:06
    类属性类方法 目标 的结构 类属性和实例属性 类方法和静态方法 01. 的结构 1.1 术语 —— 实例 使用面相对象开发,第 1 步是设计 使用类名()创建对象,创建对象的动作有两步: 1) 在内存中为对象...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 901,081
精华内容 360,432
关键字:

引用一个类的属性或调用其方法