精华内容
下载资源
问答
  • JAVA类之间方法调用

    万次阅读 多人点赞 2018-11-02 23:39:15
    JAVA类方法调用一、静态方法调用其他方法:1. 静态方法调用非静态方法2.静态方法调用静态方法二、非静态方法调用其他方法1.非静态方法在同一类内调用其他方法2.非静态方法在不同类之间调用其他方法 注:调用方法...

    注:调用方法——调用另一方法的方法
    被调用方法——被调用的方法

    一、静态方法调用其他方法:

    1. 静态方法调用非静态方法

    无论是否在同一类内,均需要通过对象调用

    //Test类
    package main;
    
    public class Test {
    
        public void IsSon1(){//非静态方法
            System.out.println("java大爷,你成功调用了你非静态方法里的儿子1");
        }
    
        public static void main(String[] args) {
            Test son1=new Test();
            son1.IsSon1();//静态方法通过对象调用此类中的非静态方法
            Son son=new Son();//静态方法通过对象调用Son类中的非静态方法
            son.IsSon();
        }
    }
    
    //Son类
    package main;
    
    public class Son {
        public  void IsSon(){
            System.out.println("java大爷,你成功的调用了你另一个类里的儿子");
        }//Son类里的非静态方法
    }
    

    输出结果

    2.静态方法调用静态方法

    同一类内直接调用,不同类内直接通过类名.方法名(参数表)调用

    package main;
    
    public class Test {
    
        public static void IsSon2(){//静态方法
            System.out.println("java大爷,你成功调用了你静态方法里的儿子2");
        }
    
        public static void main(String[] args) {
            IsSon2();//静态方法直接调用类内的静态方法
            Son.IsSon3();//静态方法通过类名直接调用Son类中的静态方法
        }
    }
    
    package main;
    
    public class Son {
        public  static void IsSon3(){
            System.out.println("java大爷,你成功的调用了你另一个类里的静态儿子3");
        }//Son类里的静态方法
    }
    
    

    输出结果

    二、非静态方法调用其他方法

    1.非静态方法在同一类内调用其他方法

    在同一类内,非静态方法可以直接调用静态方法和非静态方法

    package main;
    
    public class Test {
    
        public void Son1(){//非静态方法
            System.out.println("java大爷,你成功调用了你非静态方法里的儿子1");
        }
        public static void Son2(){//静态方法
            System.out.println("java大爷,你成功调用了你静态方法里的儿子2");
        }
        public void alloutput(){
            Son1();//非静态方法直接调用类内的非静态方法△
            Son2();//非静态方法直接调用类内的静态方法△
        }
        public static void main(String[] args) {
            Test test = new Test();
            test.alloutput();//前边已学静态方法通过对象调用非静态方法
        }
    }
    

    输出结果

    2.非静态方法在不同类之间调用其他方法

    在不同类之间,非静态方法需要通过对象才能调用非静态方法。
    非静态方法既可以通过对象调用静态方法又可以通过类名直接调用(由于对象的调用方式属于非静态调用方式,所以建议使用类名直接调用静态方法)

    package main;
    
    public class Test {
    
        public void output(){
            Son.IsSon1();//通过类名直接调用Son类中的静态方法,不建议使用对象调用静态方法
            Son son = new Son();
            son.IsSon2();//通过对象调用Son类中的非静态方法
        }
    
        public static void main(String[] args) {
            //同一类中的静态方法调用非静态方法output,前边已经涉及到
            Test test = new Test();
            test.output();
        }
    }
    
    package main;
    
    public class Son {
    
        public  static void IsSon1(){//Son类里的静态方法
            System.out.println("java大爷,你成功的调用了你另一个类里的静态儿子1");
        }
    
        public  void IsSon2(){//Son类里的非静态方法
            System.out.println("java大爷,你成功的调用了你另一个类里的非静态儿子2");
        }
    }
    
    

    输出结果

    借鉴前人的经验1

    借鉴前人的经验2
    小白上路,如有问题希望各路神手指教 /抱拳

    展开全文
  • 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,已归档

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

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

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

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

    展开全文
  • JSP中调用java类中的方法 调用步骤 1、新建一个项目,在src文件夹下添加一个包:如:myjava 2、再在包中添加一个类: package myjava; public class myTestJava { public String getInfo(){ return "我是...
                                 JSP中调用java类中的方法
    

    调用步骤

    1、新建一个项目,在src文件夹下添加一个包:如:myjava

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    2、再在包中添加一个类:

    package myjava;
    public class myTestJava {
     	 public String getInfo(){
    	 return "我是java类中的字符串";
    	 }
    }
    

    在这里插入图片描述
    在这里插入图片描述

    3、新建一个test.jsp文件,在jsp文件的开头引入

    <%@   page   import= "myjava.* "%>
    

    4、在jsp文件 中添加相应的java代码,如:

    <%
    		String str;
    		myTestJava mTJ = new myTestJava();
    	%>
    	<%=mTJ.getInfo()%>
    

    在这里插入图片描述

    5、 运行结果

    在这里插入图片描述

    6、完整的示例源码

    test.jsp:

    <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <%@   page import="myjava.* "%>
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>JSP中调用java类中的方法</title>
    </head>
    <body>
    	<%
    		String str;
    		myTestJava mTJ = new myTestJava();
    	%>
    	<%=mTJ.getInfo()%>
    </body>
    </html>
    

    mytestjava.java:

    package myjava;
    
    public class myTestJava {
    	 public String getInfo(){
    	 return "我是java类中的字符串";
    	 }
    }
    

    JavaWeb学习目录(持续更新。。。)

    展开全文
  • java 类方法和实例方法 调用关系

    万次阅读 多人点赞 2018-04-20 23:49:55
    java 类方法和实例方法 1. 类方法 也可称静态方法,使用static修饰的类中方法; 2.实例方法 非静态方法,没有用static修饰的方法。 3.测试案例 public class Test { private int a = 5; private ...

    java 类方法和实例方法

    1. 类方法

    也可称静态方法,使用static修饰的类中方法;

    2.实例方法

    非静态方法,没有用static修饰的方法。

    3.测试案例

    public class Test {
    
        private int a = 5;
        private static int b = 10;
    
        public static void yiStatic()
        {
    //        a = 10;//静态方法无法访问非静态成员变量
            System.out.println("yiStatic");
        }
    
        public void yiInstance()
        {
            a = 10;
            b = 5;//非静态方法可以访问静态变量
            System.out.println("yiInstanc");
        }
    
        public void yiInstance2()
        {
            yiStatic();//非静态方法可以访问非静态方法
            yiInstance();//非静态方法可以访问静态方法
            System.out.println("yiInstance2");
        }
    
        public static void yiStatic2()
        {
            yiStatic();//静态方法可以访问静态方法
    //        yiInstance();//静态方法不可以访问非静态方法
            System.out.println("yiStatic2");
        }
    }
    
    

    通过这么测试我们发现,实例方法即非静态方法可以访问类中的任何变量和方法(包
    括静态和非静态的),而静态方法中只能访问静态变量和静态方法。
    究其原因,我们可以从jvm层面来理解实例方法和静态方法的区别:

    实例方法

    在jvm加载类的字节码文件到memory中时,并没有把类的所有方法都立即分配入口地址,例如实例方法即非静态方法,只有当我们创建对象时,类的实例方法才会被分配访问地址。同时,只要创建类的第一个对象时,类的实例方法的入口地址就会被分配,之后再创建此对象时不再给实例方法的分配新的地址,而是共享第一个对象被创建时分配的实例方法的入口地址,并且,只有当类的最后一个实例对象被销毁时才会将地址回收。

    类方法(静态方法)

    在jvm加载类的字节码文件到memory中时,类方法就会被分配入口地址,所以,类方法可以通过类来直接访问,而不需要对象创建后才能访问,而且由此知道,类方法的入口地址分配比实例方法要早,由此就可以解释上述程序中,为什么静态方法无法访问非静态变量和实例方法:

    a.类方法中不能访问非静态变量和实例方法

    因为非静态成员变量跟实例方法一样,只有在对象创建时才分配入口地址,而静态方法的入口地址分配又比实例方法早,导致此时非静态成员变量和实例方法还没有被分配到内存,所以无法访问

    b.类方法中也不能访问super和this关键字

    显然,我们知道this是指代本类的对象,super是出现继承时指向父类的对象,显然两者都依托于类的实例对象的创建,因为,静态方法中不能访问。

    c.实例方法没有上述限制

    显然通过实例方法和类方法分配内存的先后顺序显然知道

    参考文献:https://blog.csdn.net/mhady/article/details/51377579

    展开全文
  • Java调用本类方法(this关键词)

    千次阅读 2018-11-11 16:35:03
    public class Person{ private String name; private int age; public Person(String name,int age){ this.name=name; this.age=age;... //调用本类方法 } public void print(){ System.out....
  • Java动态调用类方法案例

    千次阅读 2019-06-11 10:15:50
    需要根据编号动态给设置值,属性名为“f+费用编号”,例如f01表示编号为01的费用 public class MonitorDayFee implements Serializable { private static final long serialVersionUID = 1L; private Long ...
  • 我现在用xml传以下字段到服务器:class是的完整名称,action是要调用方法名,para的子元素是方法形参,data的子元素是方法实参。 ``` <user><class>...
  • 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...
  • Java中子类调用父类方法

    万次阅读 2019-05-11 10:06:20
    当一个继承于另一个,子类中没有父类的方法时。用子类的对象调用方法时,会首先在子类中查找,如果子类中没有该方法,再到父类中查找。 当一个方法只在父类中定义时,调用方法时会使用父类中的属性。 如果该...
  • Java main函数调用当前类方法

    千次阅读 2019-06-18 23:12:55
    import java.util.Scanner; public class MethodDemo { public static void main(String[] args) { Scanner scan = new Scanner(System.in); System.out.println("请输入第一个值"); int a = ...
  • java工具类调用Service层类的方法

    千次阅读 2019-02-28 15:23:41
    在spring mvc 模式中,Service层的被非Service或者非Controller层的代码调用后,是不能直接使用的。比如在工具或者配置中如果需要调用Service层的代码,则需要在该上添加@Component注解。然后使用以下写法:...
  • Java基础知识面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 12:11:27
    文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JRE和JDK的关系什么是跨平台性?原理是什么Java语言有哪些特点什么是字节码?采用字节码的最大好处是什么什么是Java程序的主类?应用程序和小程序的...
  • Java中实现在一个方法调用另一个方法

    万次阅读 多人点赞 2019-04-20 15:39:17
    不同的之间,无论调用方法是非静态还是静态,如果被调用方法是: 静态方法,则通过类名与对象都可以调(但通过对象的方式不建议使用,因为它属于非静态调用的方式) 非静态方法,则只能通过对象才可以调用它...
  • java外部如何调用内部的属性和方法 解决方法: 直接看代码 public static void main(String[] args) { //调用静态内部的方式1 TestChild testChild = new TestChild(); testChild.test(); //...
  • java开发中调用一个接口的方法时是怎么调用到该接口的实现的?
  • java 关于调用一个的私有方法

    千次阅读 2018-12-21 11:06:55
    调用私有方法:getDeclaredMethod() //可以调用类中的所有方法(不包括父类中继承的方法) 代码: Class cl=Class.forName("com.");//括号中是需要调用私有方法的类路径 Method method=cl....
  • Java-反射以及反射调用类方法

    千次阅读 2018-12-02 18:15:12
    在默认情况下,必须要先导入一个包,而后才能产生的实例化对象。 如下就是一个正操作。 import java.util.Date;//导入的包 public class Test{ public static void main(String[] args){ Date date = new...
  • Java通过反射调用一个的私有方法

    万次阅读 多人点赞 2018-07-13 11:50:17
    获得私有方法的流程是 (1)获取目标类 (2)获取目标方法  Method method=clazz.getDeclaredMethod(name);//可以调用类中的所有方法(不包括父类中继承的方法)  Method method=clazz.getMethod(name);//...
  • Java中main()函数调用类方法限制

    万次阅读 多人点赞 2018-01-04 22:00:25
    今天在自学java的基础语法时,出现一个错误:提示main()调用方法不是静态的。由于才刚接触java没两天,不知道是什么原因,就度娘了下。原来main()的调用,还有很多的规定和限制。
  • 类方法调用本类的类方法时可直接调用 C. 在类方法中只能调用本类中的类方法 D. 在类方法中绝对不能调用实例方法 java中的一些bug题目,有的出题的也没有试过总结了一下 在类方法中可 用this来调用本类的类方法...
  • Java 反射调用类的函数,并传递参数

    千次阅读 2019-04-01 20:03:43
    文章目录Java 反射调用类的函数,并传递参数示例 Java 反射调用类的函数,并传递参数 通过类的包路径和函数名称以及已知参数类型,进行传参函数调用 示例 被调用函数 public class Test { public void testInvoke...
  • Java抽象及子类方法调用顺序

    千次阅读 2017-05-05 15:16:05
    2) 抽象中的方法调用子类实现的抽象方法方法 3) 抽象可以在子类未实例化时调用子类实现的抽象方法; 4) 在抽象的构造方法调用了自己未实现的抽象方法,那么对应子类实现了此方法;在抽象实例化之后,子类未...
  • Java通过反射机制调用某个方法

    万次阅读 2018-06-02 08:03:51
    通过反射机制调用类方法,主要用到下面的方法: public Object invoke(Object obj, Object... args) 参数: obj是调用基础方法的实例对象 调用基础方法索要传递的参数,参数是一个变长类型 下面是一个具体...
  • Java初识:抽象方法调用机制

    千次阅读 2017-11-04 13:53:59
    Java抽象类方法调用机制 什么是抽象类? 抽象类的作用? 父类创建子类对象时为什么不能直接调用子类独有的额方法?
  • java一个类调用另一个类In Java, we can call a class from another class. There are two ways to access a class from another class, 在Java中,我们可以从另一个类中调用一个类 。 有两种方法可以从另一个班级...
  • 定义两个:TestMethod和TestMet,TestMethod内容如下: package test; public class TestMethod { public static void main(String[] args) { TestMet testMet=new TestMet(); testMet
  • Java调用一个的静态方法

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

    万次阅读 2019-05-26 15:05:31
    Java中main函数调用其他中的方法 java
  • 在mybatis的映射xml文件调用java类方法: 使用的是OGNL表达式,表达式格式为:${@prefix@methodName(传递参数名称)} 1.如下代码所示:方法必须为静态方法;以下我只是演示如何使用,随便用到了一个工具类 ...
  • 关于Java中子类调用父类方法

    万次阅读 多人点赞 2016-12-06 22:07:38
    当一个继承于另一个,子类中没有父类的方法时。用子类的对象调用方法时,会首先在子类中查找,如果子类中没有改方法,再到父类中查找。 当一个方法只在父类中定义时,调用方法时会使用父类中的属性。 如果该...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,051,533
精华内容 820,613
关键字:

java本类怎么调用本类方法

java 订阅