精华内容
下载资源
问答
  • this是一个非常灵活的关键字,不会...中有许多成员,大部分情况下中直接进行成员调用,但是为了清楚的描述调用是本类属性,会用this.属性表示。 class Person{ String name; int age; public Person(){} ...

    目录

    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,已归档

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

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

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

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

    展开全文
  • java外部如何调用内部属性和方法 解决方法: 直接看代码 public static void main(String[] args) { //调用静态内部的方式1 TestChild testChild = new TestChild(); testChild.test(); //...

    java外部类如何调用内部类的属性和方法

     

    解决方法:

        直接看代码

    public static void main(String[] args) {

          //调用静态内部类的方式1

          TestChild testChild = new TestChild();

          testChild.test();

          //调用静态内部类的方式2

          TestChild testChild2 = new TestFather.TestChild();

          testChild2.test();

         

          //调用非静态内部类的方式:http://www.yayihouse.com/yayishuwu/chapter/1955

    }

     

    展开全文
  • JAVA反射机制是在运行状态中,对于任意一个,都能够知道这个的所有属性和方法(类名,方法名,参数类型,返回值类型);对于任意一个对象,都能够调用它任意的一个方法和属性;这种动态获取的信息以及动态调用...
    • 反射的定义及概述

      JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法(类名,方法名,参数类型,返回值类型);对于任意一个对象,都能够调用它任意一个方法属性;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

       总结来说就是,反射就是把java类中的各种成分映射成一个个   java对象例如:一个类有:成员变量、方法、构造方法,包等信息,利用反射技术可以对一个类进行解剖,把各个组成部分映射成一个个对象

    • 反射的相关函数介绍:

      • 获取类的三种方法
        • 第一种方式-->Class.forName("类名字符串")

          • Class c1=Class.forName("com.edu.Student");

        • 第二种方式-->先创建对象,再用对象调用getClass()方法,即实例对象.getClass().返回运行时类

          • Student s=new Student();

          • Class c2 = s.getClass();

        • 第三种方式-->类名.class。返回Class的对象。(每个类都有class属性)

          • Class c2 = s.getClass();    

            (!!!Class类用于表示.class文件(字节码),获取某个类时的前提条件就是获取该类的Class)
      • 获取属性
      • 获取方法
      • 获取构造函数
      • 获取其他信息
    • 具体代码实现:

      • ​​​​​​​引入工程截图
        • ​​​​​​​
      • 获取类的类名
        • ​​​​​​​实体类Student 
          • ​​​​​​​略
        • 获取代码实现
      • 获取类的构造方法
        • ​​​​​​​Student类的构造方法
          • ​​​​​​​
        • 获取的代码实现
          • ​​​​​​​
      • 获取类的方法
        • ​​​​​​​Student类的方法
          • ​​​​​​​
        • 获取的代码实现
          • ​​​​​​​
      • 获取类的属性
        • ​​​​​​​Student类的属性
          • ​​​​​​​
        • 获取属性的代码实现
          • ​​​​​​​
      • 获取类的其他信息
        • ​​​​​​​获取的代码实现
          • ​​​​​​​

    参考文献:

    1. https://blog.csdn.net/sinat_38259539/article/details/71799078
    2. https://blog.csdn.net/ylyang12/article/details/53469957
    3. https://blog.csdn.net/qq_24341197/article/details/77964172

     

     

     

     

     

     

    展开全文
  • 前面介绍了,反射调用的构造方法来创建...在这里简单介绍,反射调用属性和方法会用到的新,Method和Field。 Method的常用API: getModifiers() : 获取方法的修饰符 getName(): 获取到方法的名称 getPar...

    前面介绍了,反射调用类的构造方法来创建类的实例对象。一个类的结构包含方法(构造,静态,非静态)和属性(静态和非静态)。按照循环渐进的方式,接下来,介绍反射类中属性和普通的方法。

    在这里简单介绍,反射调用属性和方法会用到的新类,Method类和Field类。

    Method类的常用API

    • getModifiers() : 获取方法的修饰符
    • getName(): 获取到方法的名称
    • getParameterTypes() : 获取到方法的全部参数类型
    • getReturnType(): 获取到方法的返回值类型
    • getException():获取方法中全部抛出的异常
    • invoke(Object obj,Object ... args):反射调用类中的方法

    Field类的常用API:

    • get(Object obj):获取到属性的具体内容
    • set(Object ,Object value):设置指定属性的具体内容
    • getModifiers() : 获取属性的修饰符
    • isAccessible():判断属性是否可以被外部访问
    • setAccessible(boolean flag):设置这属性可以被外部访问。

    案例实战


    1. 定义一个接口

    定义一些行为,作为抽象方法。用于测试,反射调用实现类(覆盖重写的)方法。

    package com.xingen.classdemo;
    
    public interface ClassTestInterface {
        void testMethod(String name,String work);
    }

    2. 构建一个父类

    添加一些属性,进行封装。用于测试,反射调用父类私有属性。

    package com.xingen.classdemo;
    
    import java.lang.reflect.Constructor;
    
    public class ClassTest2 {
        private String name;
        private String work;
    
        /**
         * 构建一个默认的构造方法
         */
        public ClassTest2() {
        }
    
        /**
         * 构建有参数构造方法
         *
         * @param name
         * @param work
         */
        public ClassTest2(String name, String work) {
            this.name = name;
            this.work = work;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getWork() {
            return work;
        }
    
        public void setWork(String work) {
            this.work = work;
        }
    
    }

    3. 创建一个子类

    该子类的作用有以下几点:

    • 继承父类

    • 实现若干接口,覆盖重写抽象方法,例如:testMethod(String name, String work)

    • 定义自己本身的私有属性,例如:age字段

    package com.xingen.classdemo;
    
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    
    public class ClassTest3 extends ClassTest2 implements ClassTestInterface {
    
        private int age;
    
        public ClassTest3() {
        }
    
        @Override
        public void testMethod(String name, String work) {
            this.setName(name);
            this.setWork(work);
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        @Override
        public String toString() {
            StringBuffer stringBuffer = new StringBuffer();
            if (getName() != null) {
                stringBuffer.append("name: ");
                stringBuffer.append(getName());
                stringBuffer.append("\n");
            }
            if (getWork() != null) {
                stringBuffer.append("work: ");
                stringBuffer.append(getWork());
                stringBuffer.append("\n");
            }
            if (getAge() > 0) {
                stringBuffer.append("age: ");
                stringBuffer.append(getAge());
            }
            return stringBuffer.toString();
        }
    
    }
    

    4. 各种常用的反射场景

    4.1 案例之反射获取父类的信息

    先获取到Class对象,然后调用getSuperclass()获取到父类的Class对象。
    众所众知,单继承,多实现,因此父类只有一个。这里,输出父类所属于的包信息。

        /**
         * 获取父类的信息
         */
        public static void testSuperClass() {
            try {
                Class<?> mClass = ClassTest3.class;
                //获取继承的父类
                Class<?> superClass = mClass.getSuperclass();
                System.out.println("获取继承父类的包路径:\n" + superClass.getName());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

    输出结果是:

    获取继承父类的包路径:
    com.xingen.classdemo.ClassTest2

    4.2 案例之反射获取实现接口的信息

    先获取到Class对象,然后调用getInterfaces()获取到全部实现接口的Class数组。因ClassTest3实现了一个接口,所以这里的数组索引值是0。接口的Class对象可以获取到接口中的完整信息,这里输出接口所属于的包信息。

        /**
         * 获取实现接口的信息
         */
        public static void testInterface() {
            try {
                Class<?> mClass = ClassTest3.class;
                /**
                 * 获得全部实现的接口:Class<?>[] getInterfaces()得到的数组中,接口对象顺序和这个对象所表示的类中implements子句中接口名的顺序,是一致的。
                 */
                Class<?>[] interfaceArray = mClass.getInterfaces();
                Class<?> interfaces = interfaceArray[0];
                System.out.println("获取实现接口的包路径: \n" + interfaces.getName());
    
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

    输出结果是:

    获取实现接口的包路径: 
    com.xingen.classdemo.ClassTestInterface

    4.3 案例之反射调用覆盖重写的方法

    先获取Class对象,然后通过getMethod()获取到指定的需要调用的方法。接下来,处理是否需要添加访问权限setAccessible(true),最后通过invoke()进行方法调用。

        /**
         * 测试覆盖重写的方法
         */
        public static void testSuperMethod() {
            try {
                Class<ClassTest3> mClass = ClassTest3.class;
                ClassTest3 instance = mClass.newInstance();
                Method method = mClass.getMethod("testMethod", String.class, String.class);
                if (!method.isAccessible()) {
                    method.setAccessible(true);
                }
                method.invoke(instance, "xinGen", "Android Lirary Developer");
                System.out.println("反射访问覆盖重写的方法:\n " + instance.toString());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

    输出结果是:

    反射访问覆盖重写的方法:
    name: xinGen
    work: Android Lirary Developer

    4.4 案例之反射调用本类定义的私有属性

    先获取到Class对象,然后通过getDeclaredField()获取到本类定义的私有属性,再调用setAccessible()赋予访问权限,最后调用set()对私有属性内容修改。

         /**
         * 测试调用本身定义的私有属性
         */
        public static void testSelfField() {
            try {
                Class<ClassTest3> mClass = ClassTest3.class;
                ClassTest3 instance = mClass.newInstance();
                Field field = mClass.getDeclaredField("age");
                field.setAccessible(true);
                field.set(instance, 24);
                System.out.println("反射访问本类中Private修饰的属性:\n " + instance.toString());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

    输出结果是:

    反射访问本类中Private修饰的属性:
    age: 24

    4.5 案例之反射调用父类中私有属性

    先获取到Class对象,然后通过getSuperclass()获取到父类的Class对象,再调用getDeclaredField()获取到父类的私有属性,最后调用set(),对私有属性进行内容修改。这里,最后输出修改后的内容。

      /**
         * 测试调用父类私有属性
         */
        public static void testSuperField() {
            try {
                Class<ClassTest3> mClass = ClassTest3.class;
                ClassTest3 instance = mClass.newInstance();
                Field field = mClass.getSuperclass().getDeclaredField("name");
                field.setAccessible(true);
                field.set(instance, "xinGen");
                System.out.println("反射访问父类中Private修饰的属性:\n " + instance.toString());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

    输出结果是:

    反射访问父类中Private修饰的属性:
    name: xinGen

    5. 运行main()入口程序

    package com.xingen.classdemo;
    
    public class Client {
    
        public static void main(String[] args) {
            useClassFieldAndMethod();
        }
        /**
         * 使用Class类:读写属性和方法
         */
        public static void useClassFieldAndMethod() {
            ClassTest3.testInterface();
            ClassTest3.testSuperClass();
            ClassTest3.testSuperMethod();
            ClassTest3.testSelfField();
            ClassTest3.testSuperField();
        }
    }

    反射调用属性的归纳总结

    1. 先判断该属性是否public修饰
    2. 若是,则使用getField()获取。
    3. 反之,则判断是否是类本身单独定义属性。
    4. 若是,则使用getDeclaredField()去获取。
    5. 反之,则先通过getSuperclass()获取到父类的Class对象,再去调用getDeclaredField()去获取。

    同理,反射调用方法和调用属性的思路类似。

    本案例的项目代码https://github.com/13767004362/JavaDemo/tree/master/ClassDemo

    展开全文
  • java的继承问题中,当子类与父类有相同的属性,子类重写了父类的某个方法,那么在创建实例的过程中,方法是如何调用属性值是什么样的呢?package test2; class father{ int i=0; public void m1(){ System...
  • Java调用第三方接口示范

    万次阅读 多人点赞 2018-10-08 15:03:53
    人工智能,零基础入门!...【1】准备工作:在项目的工具包下导入HttpClientUtil这个工具,或者也可以使用Spring框架的restTemplate来调用,上面有调用接口的方法【分为Get和Post方式的有参和无参调用】: pa...
  • java 调用类的构造函数

    千次阅读 2019-04-03 13:43:52
    一、·定义图书Book,包含属性(全部私有): 书名,作者,出版社,价格,ISBN, 构造函数1:通过参数传递书名给书名属性赋值; 构造函数2:通过参数传递书名、作者给相关属性赋值; 构造函数3:通过参数传递书名、...
  • JAVA属性和方法的调用

    千次阅读 2019-09-14 15:01:42
    #java属性和方法的调用 在JDK1.8的环境中: 非静态属性和方法可以通过对象调用 静态属性可以直接调用 静态方法既可以直接调用,也可以通过对象调用 public class Demo1 { static int b = 9;//定义一个静态属性 ...
  • kotlin的扩展方法,其实是以java的静态方法形式存在的,也就是说如果要用java调用kotlin的扩展方法,和调用静态函数一样 调用扩展属性也是相同的道理 举个例子,我们在某个kotlin文件(文件名为Utils.kt)里为...
  • Android java方法实现调用系统属性

    千次阅读 2016-09-06 14:44:27
    最近在写一个测试apk时需要调用Android的系统属性来设置相关的标志位,但在使用标准的java库中的System.getProperty和System.setProperty方法并不能获得Android中的系统属性,而且会出现空指针崩溃。查阅相关资料...
  • java调用内部的两种方法

    万次阅读 2018-11-06 19:31:36
    package com.fpi.safety; import java.lang.reflect.Field; import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class TestPrintList {    public static void main(S...
  • 定义 声明对象 创建对象 实例化对象 属性 对象调用属性或者方法 举例,下面定义了一个并声明属性,写了一个方法: class Person { public String name; //声明属性 public int age; //声明属性 ...
  • import java.lang.reflect.Method;/** * 通过反射调用类的private方法 * */public class ReflectByInvokePrivate { /** * @param args */ public static void main(String[] args) throws Exception { ...
  • Java调用一个的静态方法

    千次阅读 2019-01-04 16:07:20
    java调用一个的静态方法,不会实例化该,只是对该的进行了加载,并不会实例化,加载会对的静态属性初始化,和执行静态代码块中的代码,不会执行构造方法...
  • Java 调用 Kotlin

    千次阅读 2018-07-12 18:12:29
    Kotlin 和 Java 的互操作性是 Kotlin 的一大优点,Kotlin 调用 Java 已经基本不需要特别去注意什么了,但是 Java 调用 Kotlin 代码就不那么好看了。项目切换到 Kotlin 的过程中总会有两种语言交错的时候,最近切换 ...
  • Java动态调用类的方法案例

    千次阅读 2019-06-11 10:15:50
    需要根据编号动态给设置值,属性名为“f+费用编号”,例如f01表示编号为01的费用 public class MonitorDayFee implements Serializable { private static final long serialVersionUID = 1L; private Long ...
  • 前言 native方法虽然是native的,但毕竟是方法,那么就应该同其他方法一样,能够访问属性和方法。实际上,JNI的确可以做到这一点,我们通过几个例子来说明~ 原文链接请标明: ...本文出自:【stromxu的博客】 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,064,205
精华内容 425,682
关键字:

java调用类的属性

java 订阅