8.静态成员变量,实例变量,方法

1.什么是成员变量的隐藏？
成员变量--定义在类中方法之外的变量
成员变量的特征：
        1.定义在类中方法之外
        2.必须有访问限制修饰
        3.可以有初始值也可以没有，如果没有系统会自定赋予默认的初始值
        4.可以在当前类中的任意一个方法中使用。

局部变量--定义在类中的方法里面/方法的参数
局部变量的特征：
        1.方法里面/方法的参数
        2.一定没有访问限制修饰
        3.必须有初始值
        4.只能在当前方法中使用。
成员变量的隐藏:在同一个类中某一个局部变量的名称与当前类中的某一个成员变量的名称相同,此时这个局部变量就将成员变量的数据值隐藏。
    注意:1.同一个类中
             2.变量的名称相同，与变量的数据类型没有关系。

package com.wangxing.test1;
 
public class MyClass {
    //定义一个成员变量
    public  String testname="zhangsan";
    
    //测试方法
    public void  testMethod(){
        //定义一个局部变量
        char testname='Z';
        /*
         * 在同一个类中某一个局部变量的名称与当前类中的某一个成员变量的名称相同
            ，此时这个局部变量就将成员变量的数据值隐藏。
         */
        System.out.println("testname--"+testname); //Z
        //如果需要强制得到被隐藏的成员变量值？
        //this.成员变量名称
        System.out.println("this.testname--"+this.testname); //zhangsan
    }
}
测试类
public static void main(String[] args) {
    //创建MyClass类的对象
    MyClass  mc=new MyClass();
    //调用测试方法
    mc.testMethod();
}
2.静态成员变量与实例变量的区别？ 
类中的成员变量可以根据是否使用static关键字，划分成2种：
1.静态成员变量【类变量】--- 使用static关键字修饰的成员变量
2.实例变量--普通的成员变量--没有使用static关键字修饰的成员变量
区别：
        1.静态成员变量和实例变量都是成员变量，都符合成员变量的基本特征。
        2.静态成员变量使用了static关键字修饰，实例变量没有使用static关键字修饰。
        3.静态成员变量可以在同一个类的多个对象之间共享数据，实例变量则不能共享数据。
        4.静态成员变量可以在静态方法中使用，实例变量则不能在静态方法中使用
        5.静态成员变量既可以用对象调用也可以用类名调用，实例变量只能对象调用
        原因是static关键字修饰的元素【变量和方法】，会在程序运行前分配好存储空间，没有使用static关键字修饰的元素【变量和方法】是在程序运行时候才分配存储空间。

package com.wangxing.test;
 
public class TestClass {
    //定义一个成员变量
    //testname这个成员变量使用了static修饰--静态成员变量[类变量]
    public static String  testname="zhangsan";
    //testaddress这个成员变量没有static修饰--普通的成员变量--实例变量
    public String  testaddress="西安";
}
 
package com.wangxing.test;
public class TestMain {
    public static void main(String[] args) {
        //创建TestClass类的第一个对象
        TestClass  tc1=new TestClass();
        //创建TestClass类的第二个对象
        TestClass  tc2=new TestClass();
        /*
        //静态成员变量可以在同一个类的多个对象之间共享数据
        System.out.println("对象1的--testname="+tc1.testname);//zhangsan
        System.out.println("对象2的--testname="+tc2.testname);//zhangsan
        System.out.println("-------------------------------");
        //修改第一个对象的testname为lisi
        tc1.testname="lisi";
        System.out.println("对象1的--testname="+tc1.testname);//lisi
        System.out.println("对象2的--testname="+tc2.testname); //lisi
        */
        
        /*
        //实例变量则不能共享数据。
        System.out.println("对象1的--testaddress="+tc1.testaddress);//西安
        System.out.println("对象2的--testaddress="+tc2.testaddress);//西安
        System.out.println("-------------------------------");
        //修改第一个对象的testaddress为北京
        tc1.testaddress="北京";
        System.out.println("对象1的--testaddress="+tc1.testaddress);//北京
        System.out.println("对象2的--testaddress="+tc2.testaddress); //西安
        */
        
        //静态成员变量既可以用对象调用也可以用类名调用
        /*
        TestClass  tc=new TestClass();
        System.out.println("对象调用静态成员变量--testname="+tc.testname);
        System.out.println("类名调用静态成员变量--testname="+TestClass.testname);
        */
        
        //实例变量只能对象调用
        TestClass  tc=new TestClass();
        System.out.println("对象调用实例变量--testaddress="+tc.testaddress);
        //System.out.println("类名调用实例变量--testaddress="+TestClass.testaddress);
        
    }
}
 

 

 3.Java类中方法的表现形式及其基本特征？
 Java类可以出现两个元素
        1.描述事物基本属性--变量
        2.描述事物基本功能--方法
    实例方法【普通方法】的基本格式:
    访问限制修饰  方法的返回值类型  方法的名称(参数列表){方法体}
    1.访问限制修饰---public/缺省的，决定了方法可以被谁使用，在那里调用
    2.方法的返回值类型---方法运行结果的数据类型
                方法执行以后没有结果，使用void代替方法的返回值类型
                方法的返回值类型如果不是void,方法体中的最后一句话需要
                return 结果;
                return的这个结果一定要与方法的返回值类型匹配。
    3.方法的名称---合法的标识符【首字母小写，从第二个单词开始首字母大写】
    4.(参数列表)---可以有多个参数中间用“，”分割【（int num,String name,char sex）】
               也可以一个参数都没有【()】
               参数就是用来接收方法之外的数据值，进入本方法，参与运算【找帮手】
               参数格式: 数据类型  变量名称
    5.{方法体}----编写实现具体功能的代码的地方

package com.wangxing.test1;
public class MyClass {
    //实例方法【普通方法】的基本格式:
    //访问限制修饰  方法的返回值类型  方法的名称(参数列表){方法体}
    public  void  testShiLiMethod1(){
        System.out.println("没有返回值,没有参数的实例方法");
    }
    //方法的返回值类型如果不是void,方法体中的最后一句话需要return 结果;
    //return的这个结果一定要与方法的返回值类型匹配。
    public  int  testShiLiMethod2(){
        System.out.println("有返回值,没有参数的实例方法");
        return 123;
    }
    
    String testShiLiMethod3(int number){
        System.out.println("缺省修饰的,有返回值,有1个参数的实例方法");
        return "hello";
    }
    
    double testShiLiMethod4(double arg1,int arg2){
        System.out.println("缺省修饰的,有返回值,有多个参数的实例方法");
        double res=arg1+12.5;
        return res;
    }
}
静态方法【类方法】的基本格式:
访问限制修饰 static 方法的返回值类型  方法的名称(参数列表){方法体}

package com.wangxing.test1;
 
public class TestClass {
    //静态方法【类方法】的基本格式:
    //访问限制修饰 static 方法的返回值类型  方法的名称(参数列表){方法体}
    public static void  testStaticMethod1(){
        System.out.println("没有返回值,没有参数的静态方法");
    }
    //方法的返回值类型如果不是void,方法体中的最后一句话需要return 结果;
    //return的这个结果一定要与方法的返回值类型匹配。
    public static int  testStaticMethod2(){
        System.out.println("有返回值,没有参数的静态方法");
        return 123;
    }
    
    static String testStaticMethod3(int number){
        System.out.println("缺省修饰的,有返回值,有1个参数的静态例方法");
        return "hello";
    }
    
    static double testStaticMethod4(double arg1,int arg2){
        System.out.println("缺省修饰的,有返回值,有多个参数的静态方法");
        double res=arg1+12.5;
        return res;
    }
}
构造方法的基本格式:
访问限制修饰  类名(参数列表){方法体}
    1.构造方法没有方法返回值类型这个部分
    2.方法的名称就是类名
    构造方法的作用:创建java类对象用的    
    注意：1.每一个定义好的类中，默认就有一个无参数的构造方法存在，只是没有显现出来
               2.当类中出现有参数的构造方法时，有参数的构造方法会覆盖没有显现出来的默认的无参数的构造方法。所以我们就需要将默认的无参数的构造方法手动显示出来。 

package com.wangxing.test1;
 
public class DoxClass {
    //构造方法的基本格式:
    //访问限制修饰  类名(参数列表){方法体}
    //1.构造方法没有方法返回值类型这个部分
    //2.方法的名称就是类名
    //构造方法的作用:创建java类对象用的    
    //注意：1.每一个定义好的类中，默认就有一个无参数的构造方法存在，只是没有显现出来
    //2.当类中出现有参数的构造方法时，有参数的构造方法会覆盖没有显现出来的默认的无
    //参数的构造方法。所以我们就需要将默认的无参数的构造方法手动显示出来。
    public  DoxClass(){
        System.out.println("无参数的构造方法");
    }
    public  DoxClass(String name){
        System.out.println("有1个参数的构造方法");
    }
    public  DoxClass(String name,int age){
        System.out.println("有多个参数的构造方法");
    }
}
4.什么是方法重载？ 
在同一个类中方法的名称相同，参数不同，这种现象就是方法重载
      注意:1.同一个类中
               2.参数不同[类型或者个数]
               3.方法的重载与方法的返回值类型没有关系

package com.wangxing.test1;
 
public class TestClass {
    //在同一个类中方法的名称相同，参数不同，这种现象就是方法重载
    //注意:1.同一个类中
    //2.参数不同[类型或者个数]
    //3.方法的重载与方法的返回值类型没有关系
    //构造方法重载
    public  TestClass(){}
    public  TestClass(int number){}
    public  TestClass(String name){}
    //实例方法重载
    public  void shiLi(){}
    public  void shiLi(int age){}
    /*
    //方法的重载与方法的返回值类型没有关系
    public  int shiLi(int age){
        return 123;
    }
    */
    public  int shiLi(double age){
        return 123;
    }
    //静态方法重载
    public static  void jingTai(){}
    public static void jingTai(int age){}
    /*
    //方法的重载与方法的返回值类型没有关系
    public static int shiLi(int age){
        return 123;
    }
    */
    public static int jingTai(double age){
        return 123;
    }
    public static double jingTai(double arg1,double arg2){
        return 123;
    }
}
总结：方法重载只看名称和参数