Java 同一类中方法和变量之间的调用关系

一、同一个JAVA类中方法可以调用变量

       1、构造方法中调用实例变量、静态成员变量、局部变量

         （1）.可以访问实例变量，默认this.实例变量，this.可以省略。
                   出现成员变量隐藏的情况时，强制调用被隐藏的实例变量值时，this不可以省略
         （2）.可以访问静态成员变量，默认类名.静态变量，或this.静态变量，类名和this.可省略。  
         （3）.可以访问自己的局部变量，直接局部变量名称

      2、实例方法中调用实例变量、静态成员变量、局部变量

         （1）.可以方法实例变量，默认this.实例变量，this.可以省略

                   出现成员变量隐藏的情况，强制调用被隐藏的实例变量值时，this.不可以省略

         （2）.可以访问静态成员变量，默认类名.静态变量，或this.静态变量，类名和this.可省略

         （3）.可以访问自己的局部变量，直接局部变量名称

      3、静态方法中调用静态成员变量、局部变量

          （1）.不可以访问当前类中实例变量

          （2）.不可以使用this.

          （3）.可以访问静态成员变量，默认类名.静态变量，类名可以省略

          （4）.可以访问自己的局部变量，直接局部变量名称

     

public class Student {
    //定义一个实例变量
    public int age = 10;
    //定义一个静态成员变量
    static String name = "张三";
    //定义一个无参数构造方法
    public Student(){
//        //构造方法中调用实例变量
//        //构造方法中可以访问实例变量，默认this.实例变量，this.可以省略。
//        System.out.println("构造方法中，用this.实例变量 方式，我今年"+this.age+"岁");
//        System.out.println("构造方法中，省略this.实例变量，我今年"+age+"岁");
//        //构造成员变量隐藏
//        int age = 45;
//        //如果出现成员变量隐藏，那么调用成员变量的时候this.不可省略
//        System.out.println("构造方法中，成员变量隐藏，用this.实例变量 方式，我今年"+this.age+"岁");
//        System.out.println("构造方法中，成员变量隐藏，省略this. 方式，我今年"+age+"岁");
//
//        //构造方法中调用静态成员变量
//        //构造方法中可以访问静态成员变量，默认类名.静态变量，也可以this.静态变量,类名和this.可以省略.
//        System.out.println("构造方法中，用this.静态成员变量 方式，我叫"+this.name);
//        System.out.println("构造方法中，用类名.静态成员变量 方式，我叫"+Student.name);
//        System.out.println("构造方法中，省略类名和this. 方式，我叫"+name);
//        //构造方法直接调用局部变量
//        int id = 1001;
//        System.out.println("构造方法中，直接调用局部变量，我的学号是"+id);
//

    }
    //定义一个无参数的实例方法
    public void shiLi(){
        //实例方法中调用实例变量
        //实例方法中可以访问实例变量，默认this.实例变量，this.可以省略。
        System.out.println("实例方法中，用this.实例变量 方式，我今年"+this.age+"岁");
        System.out.println("实例方法中，省略this.实例变量，我今年"+age+"岁");
        //构造成员变量隐藏
        int age = 45;
        //如果出现成员变量隐藏，那么调用成员变量的时候this.不可省略
        System.out.println("实例方法中，成员变量隐藏，用this.实例变量 方式，我今年"+this.age+"岁");
        System.out.println("实例方法中，成员变量隐藏，省略this. 方式，我今年"+age+"岁");

        //实例方法中调用静态成员变量
        //实例方法中可以访问静态成员变量，默认类名.静态变量，也可以this.静态变量,类名和this.可以省略.
        System.out.println("实例方法中，用this.静态成员变量 方式，我叫"+this.name);
        System.out.println("实例方法中，用类名.静态成员变量 方式，我叫"+Student.name);
        System.out.println("实例方法中，省略类名和this. 方式，我叫"+name);
        //实例方法直接调用局部变量
        int id = 1001;
        System.out.println("实例方法中，直接调用局部变量，我的学号是"+id);


    }
    //定义一个无参数的静态方法
    public static void staticFangFa(){
        //静态方法中调用实例变量
        //静态方法中不可以访问实例变量
        //System.out.println("静态方法中，用this.实例变量 方式，我今年"+this.age+"岁");//不能访问实例变量
        //System.out.println("静态方法中，省略this.实例变量，我今年"+age+"岁");//不能访问实例变量
        //构造成员变量隐藏
        int age = 45;
        //如果出现成员变量隐藏，那么调用成员变量的时候只能通过对象
        //System.out.println("静态方法中，成员变量隐藏，用this.实例变量 方式，我今年"+this.age+"岁");//不能使用this.
        System.out.println("静态方法中，成员变量隐藏，省略this. 方式，我今年"+new Student().age+"岁");

        //静态方法中调用静态成员变量
        //静态方法中可以访问静态成员变量，默认类名.静态变量，类名可以省略.
        //System.out.println("静态方法中，用this.静态成员变量 方式，我叫"+this.name);//不能使用this.
        System.out.println("静态方法中，用类名.静态成员变量 方式，我叫"+Student.name);
        System.out.println("静态方法中，省略类名 方式，我叫"+name);
        //静态方法中直接调用局部变量
        int id = 1001;
        System.out.println("构造方法中，直接调用局部变量，我的学号是"+id);

    }
}

public class TeatMain {
    public static void main(String[] args) {
        //创建一个Student类的对象
        Student stu=new Student();
        stu.shiLi();
        //用类名调用静态方法
        Student.staticFangFa();
    }
}

二、同一个JAVA类中的方法可以调用方法

       1.构造方法中调用其他的构造方法、实例方法、静态方法

           （1）、构造方法可以调用其他构造方法，用new关键字

           （2）、构造方法可以调用实例方法，用this.实例方法，this.可以省略

           （3）、构造方法可以调用静态方法，用类名.静态方法，或this.静态方法，类名和this.可以省略

       2.实例方法中调用构造方法、其他实例方法、静态方法

           （1）、实例方法可以调用构造方法，用new关键字

           （2）、实例方法可以调用其他的实例方法，用this.实例方法，this.可以省略

           （3）、实例方法可以调用静态方法，用类名.静态方法，或this.静态方法，类名和this.可以省略

       3.静态方法中调用构造方法、其他静态方法

           （1）、静态方可以调用构造方法，用new关键字

           （2）、静态方法不能调用实例方法，不能使用this.

           （3）、静态方法可以调用其他静态方法， 用类名.静态方法，类名可以省略

public class People {
    //定义一个构造方法
    public People(){
        System.out.println("我是无参数的构造方法");
        //构造方法中，调用实例方法
        //构造方法中可以访问当前类中实例方法,默认this.实例方法,this可以省略
        this.shiLi();
        shiLi();
//        //构造方法中调用静态方法
//        //构造方法中调用静态方法，可以用类名，也可以用this. 类名和this.都可以省略
//        this.staticFangFa();
//        People.staticFangFa();
//        staticFangFa();
//        //调用构造方法，不能掉自己，否则会死掉，用new关键字创建对象调用
        new People("李四");

    }
    public People(String name){
        System.out.println("我是有参数的构造方法,参数是"+name);
    }
    //定义一个实例方法
    public void shiLi(){
        System.out.println("我是实例方法");
        //调用有参数的构造方法
//        new People("张三");
//        //实例方法调用有参数的实例方法
//        //实例方法调用同一java类中的其他实例方法，可以通过this.实例方法名称，this.可以省略
//        this.shiLi1(2234);
//        shiLi1(4455);
//        //实例方法调用静态方法
//        //实例方法中可以调用同一java类中的静态方法，可以通过类名.静态方法名称，也可以使用this.静态方法，this. 和类名可以省略
//        People.staticFangFa();
//        this.staticFangFa();
//        staticFangFa();
    }
    public void shiLi1(int id){
        System.out.println("我是有参数的实例方法，参数是"+id);
    }
    //定义一个静态方法
    public static void staticFangFa(){
        System.out.println("我是静态方法");
        //静态方法中调用构造方法，通过new关键字
        new People();
        //静态方法中调用实例方法
        //静态方法中不能调用实例方法
       // this.shiLi();
        //shiLi();
        //静态方法中调用其他静态方法
        //用类名可以调用其他静态方法，类名可以省略
        People.staticFangFa1(23);
        staticFangFa1(45);

    }
    public static void staticFangFa1(int age){
        System.out.println("我是有参数的静态方法，参数是"+age);
    }
}

public class TeatMain {
    public static void main(String[] args) {
       People pe = new People();
       pe.shiLi();
       People.staticFangFa();
    }
}

总结：

一、同一JAVA类中方法调用变量：

       1、构造方法、实例方法均可调用实例变量，通过this.实例变量，静态方法不能调用实例变量

       2、构造方法、实例方法、静态方法均可调用静态变量

             构造方法与实例方法均可通过：类名.静态变量  / this.静态变量 （类名、this.可以省略）

             静态方法只能通过类名.静态变量 （类名可以省略），不能使用this.

       3、构造方法、实例方法、静态方法均可调用自己的局部变量，直接局部变量名称

二、同一JAVA类中方法调用方法：

       1、构造方法、实例方法、静态方法均可调用构造方法，都是通过关键字new实现

       2、构造方法、实例方法均可调用实例方法：都是通过this.实例方法，this.可以省略

             静态方法不能调用实例方法

       3、构造方法、实例方法、静态方法均可调用静态方法

             构造方法与实例方法均可：类名.静态方法 / this.静态方法 ，类名与this.可省略

             静态方法：类名.静态方法，类名可以省略