精华内容
下载资源
问答
  • 编程语言的三大发展阶段:面向机器语言、面向过程语言...1、类是Java程序的基本要素,一个Java应用程序就是由若干个类所构成; 2、类声明的变量称为对象变量,也简称 对象 ; 3、class 关键字是用来定义类 ; 4、...

    编程语言的三大发展阶段:面向机器语言、面向过程语言、面向对象语言 ;

    其中面向对象语言主要体现三个特征:封装性、继承、动态 ;

    类的定义:类声明和类体。基本格式如下:

    class 类名{

       类体

    }

    特点:

    1、类是Java程序的基本要素,一个Java应用程序就是由若干个类所构成;

    2、类声明的变量称为对象变量,也简称 对象 ;

    3、class 关键字是用来定义类 ;

    4、类的目的是抽象出一类事物共有的属性和行为,并用一定的语法格式来描述所抽象出的属性和行为;

    4、类名必须是合法的Java标识符;

    Java标识符详细说明:(以及中文标识符的说明)

    https://blog.csdn.net/LagerSwan/article/details/104081548


    类的声明:

    如下所示:

    class Number {

    .....

    }

    class 数字 {

    .....

    }

    其中 class Number 与 class 数字 称为类的声明,而 Number 和 数字 则为类名 ;


    类体,即 { } 中的内容:

    类体的内容由如下两部分构成:

    • 变量的声明:用来存储属性的值 ;(体现了对象的属性)
    • 方法的定义:方法可以对类中声明的变量进行操作;(体现了对象的行为)

    如下代码演示:

    public class Class_Test {
    	int number = 10;
    	double numberd = 11.111;
    	double TestDouble() {
    		double numbers = 100 ;
    		numbers += numberd;
    		return numbers;
    	}
    	public static void main(String[] args) {
    		Class_Test test = new Class_Test();
    		System.out.println(test.TestDouble());
    	}
    }

    在以上代码中,声明了一个类 Class_Test ,两个变量 number 与 numberd ,一个方法 TestDouble() ,一个主方法 main () ;


    成员变量的定义:

    一、成员变量的类型:

    成员变量的类型可以是Java中的任何一种数据类型,包括了基本数据类型:整形、浮点型、逻辑类型、字符类型 ;引用类型中的:数组、对象和接口;  

    如下代码演示:

    public class Class_Test {
    
    	public static void main(String[] args) {
    		
    		//成员变量的说明
    		//基本数据类型的成员变量
    		int testt = 11 ;
    		float testf = 11.111f ;
    		double testd = 11.11111 ;
    		//引用类型的变量
    		int a [] ;
    		Class_Test test ;
    		
    	}
    }

    在以上代码中,成员变量:testt,testf,testd 是基本数据类型的变量;a [ ] ,test是引用类型的变量,a [ ] 为数组的变量,test 为类声明的变量,即类对象;

    二、成员变量的有效范围:

    成员变量在整个类内都是有效的,其有效性与它在类体中声明的先后位置是不关的;

    如下代码演示:   最终输出: 110

    public class Class_Test {
    	
    	//成员变量的有效范围:
    	int number = 11 ;
    	int Int_Test(){
    		int int1 = number * digit ;
    		return int1;
    	}
    	int digit = 10 ;
    
    	public static void main(String[] args) {
    		//类体的说明
    		Class_Test test = new Class_Test();
    		System.out.println(test.Int_Test());	
    	}
    }
    

    不建议大家这样编写程序,当代码量多时,对代码的可读性有一定的影响,建议先声明成员变量,再定义方法;

    三、成员变量的编写风格:

    建议大家在声明成员变量时,变量的名字使用驼峰规则,即变量名由多个单词组成时,从第二个单词开始的其他单词的首字母大学;如:computerArea 、ClassExceptionShow 


    方法的使用:

    在类体中,方法的定义包括两部分:方法头、方法体 ;  一般格式如下:

    方法头 {

       方法体

    }

    一、方法头说明

    方法头由方法的类型、名称、名称后面的 () 以及 ()里面的参数列表所构成;

    如下代码演示:

    //无参数的方法头
    double testd (){
        return 11.111;
    }
    
    //有参数的方法头, x 和 y 即为参数
    double testd (double x,double y){
        return x+y;
    }

    二、方法体说明:

    方法体即 方法()后面的 { } 以及 { } 里面的内容;

    在方法体中声明的变量为局部变量,而不是成员变量,局部变量只在方法体内有效,而且与声明时的前后位置有关;

    如下代码演示:

    double testd = 10 ;
    double testd (double x,double y){      //参数 x,y是局部变量
       double sum;                         //参数 sum 是局部变量
       sum = x + y ;
    
       if(sum>x){
           sum += testd ;         //参数 testd 是成员变量(全局变量)
    }
    
        return sum;        //return 语句,返回 sum 的值
    }

    局部变量的介绍:

    1、局部变量不同与成员变量,局部变量只在方法中有效,而且与其声明的位置顺序有关;

    2、若局部变量声明在一个复合语句中,那么该局部变量的有效范围只在复合语句中有效;

    double testd (double x,double y){      //参数 x,y是局部变量
    	   double sum;                         //参数 sum 是局部变量
    	   sum = x + y ;
    	   if(sum != 0){
    	       int ints = 1;        // ints 为复合语句中的局部变量
    	       sum += ints ;
    	}
            double bottom = 1.1;
            bottom += ints ;         //程序报错:ints cannot be resolved to a variable
    	    return sum;
    	}

    3、若局部变量声明在一个循环语句中,那么该局部变量的有效范围只在循环语句中有效;和以上复合语句是一样的;


    总结:成员变量与局部变量的区别

    1、局部变量不同与成员变量,局部变量只在方法中有效,而成员变量在整个类中都有效;

    2、局部变量与其声明的位置顺序有关,而成员变量与其声明的位置顺序无关;

    3、若局部变量的名字和成员变量的名字相同,那么成员变量会被隐藏,即在方法体中成员变量暂时是无效的,如下代码演示:

    class Test_Variable {
        int x = 10 , y ;
       void tests () {
          int x = 5 ;
          y = x + 10 ; //y的值为 15 ,而不是20,此时成员变量 x = 10 在该方法体中,暂时失效;
       }
    
    }

    4、当想使用方法中被隐藏的成员变量,可以使用关键字 this 进行调用,如下代码演示:

    class Test_Variable {
        int x = 10 , y ;
       void tests () {
          int x = 5 ;
          y = this.x + 10 ; //此时 y 的值为 20 ,而不是15,this.x调用的为成员变量 x = 10 ;
       }
    
    }

    5、成员变量有默认值,而局部变量没有默认值,因此在使用局部变量时,要确保该局部变量是有初始值的,否则程序报错;

    class Test_Variable {
    
               int  y ;
    	   void tests () {
    	      int x;       //报错:The local variable x may not have been initialized
    	      y = x + 10 ; 
    	   }
    
    }

     

     

     

    展开全文
  • 新手小白学 JAVA 方法 局部变量 成员变量

    万次阅读 多人点赞 2021-04-01 23:59:30
    1 变量 1.1 概念 可以改变的数,称为变量。在Java语言中,所有的变量在使用前必须声明。 一般通过“变量类型 变量名 = 变量值 ;”这三部分来描述一个变量。...2.3 成员变量 位置:定义在类里方法外 注意:不用

    1 变量

    1.1 概念

    可以改变的数,称为变量。在Java语言中,所有的变量在使用前必须声明。
    一般通过“变量类型 变量名 = 变量值 ;”这三部分来描述一个变量。如:int a = 3 ;
    变量的使用原则:就近原则,即尽量控制变量的使用范围到最小

    1.2 局部变量

    位置:定义在方法里或者局部代码块中
    注意:必须手动初始化来分配内存.如:int i = 5;或者int i; i = 5;
    作用域:也就是方法里或者局部代码块中,方法运行完内存就释放了

    1.3 成员变量

    位置:定义在类里方法外
    注意:不用初始化,也会自动被初始化成默认值
    作用域:整个类中,类消失了,变量才会释放
    8大类型速查表(含默认值)

    1.4 练习:变量的默认值测试

    创建包: cn.tedu.basic
    创建类: TestVariable1.java

    package cn.tedu.design;
    /*本类用于测试各种类型变量的默认值*/
    public class TestVariable1 {
            static String name;
            static byte b;//整数类型默认值都是0
            static short c;
            static int d;
            static long e;
            static float f;//小数类型的默认值是0.0
            static double g;
            static char j;//char类型的默认值是\u0000
            static boolean h;//boolean类型的默认值是false
    
            public static void main(String[] args) {
                System.out.println(name);//null,引用类型的默认值
                System.out.println(b);
                System.out.println(c);
                System.out.println(d);
                System.out.println(e);
                System.out.println(f);
                System.out.println(g);
                System.out.println(h);
                System.out.println(j);
                System.out.println(h);
            }
        }
    

    1.5 练习:局部变量与成员变量测试

    创建包: cn.tedu.basic
    创建类: TestVariable2.java

    package cn.tedu.oop;
    /**本类用于测试变量的使用*/
    public class TestVariable2 {
        //2.定义成员变量:
        //1)位置:类里方法外
        //2)无需手动初始化,会自动赋予对应类型的默认值
        //3)作用域:在整个类中生效,类消失,变量才会消失
        static int count;
       
        //3.变量有一个使用的原则:就近原则
        static int sum = 200;
        public static void main(String[] args) {
            //1.定义局部变量:
            //1)位置:在方法里/局部代码块里
            //2)必须手动初始化
            //3)作用域:在方法/局部代码块中,对应的代码执行完局部变量就被释放
            int sum = 100;//定义在方法中的局部变量sum
            System.out.println(sum);//变量的就近原则:使用的都是自己附近的变量,100
            System.out.println(count);
           
            for (int i = 0; i < 10; i++) {//局部变量i只能在循环中使用
                System.out.println(i);
            }
            //System.out.println(i);//报错:无法引用变量i:i cannot be resolved to a variable
        }
    }
    

    2 方法

    2.1 概述

    被命名的代码块,方法可以含参数可以不含参数,可以提高代码的复用性。

    2.2 方法定义的格式

    方法的格式

    2.3 方法调用顺序图

    顺序执行代码,调用指定方法,执行完毕,返回调用位置
    方法的调用顺序

    2.4 练习:测试方法的调用顺序/参数/返回值

    创建包:cn.tedu.method
    创建类:TestMethod .java

    package cn.tedu.method;
    /**本类用于测试方法*/
    public class TestMethod {
    	//1.创建程序的入口函数main()
    	public static void main(String[] args) {
    		System.out.println(1);
    		/**2.我们通过方法名+参数列表的方式来调用方法的功能*/
    		method1();//调用method1()
    		System.out.println(2);
    		method2(3);//调用method2()
    		int result = method3(1,2);//调用method3()
    		System.out.println(result);
    	}
    
    	/**3.如果方法想要返回值,必须修改返回值类型
    	 * 并且return对应类型的结果
    	 * 如果方法的返回值类型是void,不允许有返回值
    	 * */
    	/*本方法用来测试方法的返回值类型*/
    	public static int method3(int i, int j) {
    		/**4.通过return关键字将方法结果返回到调用位置*/
    		return i+j;
    	}
    
    	/**1.方法的修饰符 方法的返回值类型 方法名(方法参数){方法体}*/
    	/*method1()想测试方法的调用顺序*/
    	public static void method1() {
    		System.out.println(5);
    		System.out.println(6);
    		System.out.println(7);
    	}
    	
    	/*本方法用来测试方法的参数,参数的位置在小括号里*/
    	public static void method2(int a) {
    		System.out.println("海绵宝宝今年:"+ a +"岁啦~");
    	}	
    }
    

    2.5 方法的重载

    方法的重载是指在一个类中定义多个同名的方法,但是每个方法的参数列表不同(也就是指参数的个数和类型不同),程序在调用方法时,可以通过传递给他们的不同个数和类型的参数来决定具体调用哪个方法.

    2.6 练习:测试方法的重载

    创建包: cn.tedu.method
    创建类: TestMethodOverload.java

    package cn.tedu.method;
    /**本类用于测试方法的重载*/
    public class TestMethodOverload {
    	public static void main(String[] args) {
    		/**1.我们根据方法名+参数列表确定具体调用哪个方法*/
    		/**2.方法的重载:
    		 * 在同一个类中,存在方法名相同,但参数列表不同的方法
    		 * 如果在同类中,同名方法的参数个数不同,一定构成重载
    		 * 如果在同类中,同名方法的参数个数相同,
    		 * 需要查看对应位置上参数的类型,而不是参数名,与参数名无关
    		 * (int a,String b)与(int b,String a)--不构成重载
    		 * (int a,String b)与(String a,int b)--构成重载
    		 * */
    		//2.调用method()
    		method();
    		//4.调用method(int)
    		method(666);
    		//6.调用method(int,String)
    		method(888,"泡泡");
    	}
    
    	//1.创建一个无参的method()
    	public static void method() {
    		System.out.println("哈哈哈哈我没参数");
    	}
    	//3.创建一个method(int n)
    	public static void method(int n) {
    		System.out.println("哈哈哈哈我的参数是:"+n);
    	}
    	//5.创建一个method(int n,String s)
    	public static void method(int a,String b) {
    		System.out.println(b+"今晚要干他"+a+"碗大米饭");
    	}
    	public static void method(String a,int b) {
    		System.out.println(b+"今晚要干他"+a+"碗大米饭");
    	}
    }
    
    展开全文
  • Java成员变量的隐藏

    千次阅读 2019-05-31 16:21:47
    Java成员变量的隐藏 前几天看一篇文章,里面提到了成员变量的"重写"问题,刚看到的时候我非常疑惑,难道成员变量不是和方法一样的重写机制吗?结果当然是啪啪打脸。这个知识点确实是我的知识误区,因为我记得当初...

    Java中成员变量的隐藏

    前几天看一篇文章,里面提到了成员变量的"重写"问题,刚看到的时候我非常疑惑,难道成员变量不是和方法一样的重写机制吗?结果当然是啪啪打脸。这个知识点确实是我的知识误区,因为我记得当初学Java的时候讲多态,主要提到了方法的重写体现了Java的多态性,没有提到过成员变量在继承中是如何变化的。(也许任老师讲过,我忘了。。)。平时开发时,在子类声明同名的成员变量,看到的效果是会覆盖掉父类的变量,下意识地就会认为成员变量和方法是一样的,会覆盖父类的成员变量。但其实不是这样的,我们看一个栗子。(PS:如果知道这个知识点就不需要看了)

    public class Test {
    
        public static void main(String[] args) {
            Child c1 = new Child();
            System.out.println((c1).s);
            System.out.println((c1).fuc());
    
            Parent c2 = new Child();
            System.out.println(c2.s);
            System.out.println(c2.fuc());
        }
    
    }
    
    class Parent{
        String s = "Parent";
    
        String fuc() {
           return "this is parent";
        }
    }
    
    class Child extends Parent {
        String s = "Child";
    
        @Override
        String fuc() {
            return "this is child";
        }
    }
    

    看这段代码的输出结果是什么?

    Child

    this is child
    Child
    this is child

    我的第一反应是上面这个,似乎没有毛病,但其实正确答案是酱紫

    Child

    this is child
    Parent
    this is child

    很难受,只是使用了父类的引用,为毛被覆盖的成员变量又冒出来了?

    因为这货根本不是被"重写"或是"覆盖"了,而是被"隐藏"了起来。

    这也是Java面向对象的一个概念,叫做Field Hiding。其实在重写的定义中只提到了方法,并没有提到成员变量

    在Java的子类与父类中有两个名称、参数列表都相同的方法的情况。由于他们具有相同的方法签名,所以子类中的新方法将覆盖父类中原有的方法。

    在子类中声明了和父类同名的成员变量,那么不管类型如何,父类中的成员变量会被隐藏。那么要想使用父类中的成员变量应该怎么做呢?只能使用父类的引用来获取父类的成员变量。这和方法的重写是有区别的,比如上面的使用父类引用的输出:

    Parent

    this is child

    显然,输出的是父类的成员变量和子类的方法,那么为什么会这样呢?在这里要理解多态的概念,子类重写了父类的方法,发生了多态,但成员变量只是隐藏,并没有重写。所以父类的引用调用方法时,通过多态找到了子类的实现,但打印成员变量并没有。

    成员变量和方法有一些区别,网上的大佬做了总结:

    成员变量:当子父类有同名成员变量时,多态调用时,只看调用该成员变量的引用所属于的类中的成员变量。简单说:无论编译或运行,都看等号的左边就行了。

    成员函数:当子父类有同名成员函数时,多态调用时,编译时看的是引用变量所属的类中的方法;运行时,看的是对象所属的类中的方法。简单说:编译看左边,运行看右边。

    看到这,就会发现隐藏成员变量并不是一个知识点,从多态出发就会发现这是一个必然的事情,我还是学艺未精。。继续努力。。

    展开全文
  • 关于java成员变量和局部变量

    万次阅读 多人点赞 2018-09-14 10:46:45
    Java语言里,根据定义变量位置的不同,可以将变量分成两大类:成员变量(存在于堆内存中,和类一起创建)和局部变量(存在于栈内存中,当方法执行完成,让出内存,让其他方法来使用内存)。二者的运行机制存在较大差异...

    1、成员变量和局部变量简述

    在Java语言里,根据定义变量位置的不同,可以将变量分成两大类:成员变量(存在于堆内存中,和类一起创建)和局部变量(存在于栈内存中,当方法执行完成,让出内存,让其他方法来使用内存)。二者的运行机制存在较大差异。

    1.1成员变量

    类变量从该类的准备阶段起开始存在,直到系统完全销毁这个类,类变量的作用域与这个类的生存范围相同;

    而实例变量则从该类的实例被创建起开始存在,直到系统完全销毁这个实例,实例变量的作用域与对应实例的生存范围相同。

    正是基于这个原因,可以把类变量和实例变量统称为成员变量。其中类变量可以理解为类成员变量,它作为类本身的一个成员,与类本身共存亡;实例变量则可以理解为实例成员变量,它作为实例的一个成员与实例共存亡。

    只要类存在,类就可以访问类变量         类.类变量

    只要实例存在,实例就可以访问实例变量        实例.实例变量

    当然实例也可以访问类变量。但是需要注意的是因为实例不拥有类变量,所以通过实例来访问类变量进行操作,实际上是对类变量进行操作 ,当有其他实例来访问类变量时,访问的类变量是被对象访问操作过的类变量。

    成员变量无需显示初始化,只要为一个类定义了类变量或实例变量,系统就会在这个类的准备阶段或创建该类的实例时进行默认初始化。

    1.2局部变量

    局部变量根据定义形式的不同,又可以分为如下三种:

    形参:在定义方法签名时定义的变量,形参的作用域在整个方法中都有效

    方法局部变量:在方法体内定义的局部变量,它的作用域是从定义该变量的地方生效,到该方法结束时失效

    代码块局部变量:这个局部变量的作用域从定义该变量的地方生效,到该代码结束时失效。

    一个变量只在一对{}中起作用。。

    java允许局部变量和成员变量同名,如果方法中局部变量和成员变量同名,局部变量就会覆盖成员变量,如果需要在这个方法中引用被覆盖成员变量,则可使用this(对于实例变量)或类名(对于类变量)作为调用者来限定访问成员变量。

    2、成员变量的初始化和内存中的运行机制

    接下来以下面代码来举例说明成员变量的初始化和内存中的运行机制

     

    复制代码

     1 public class Person {
     2     public int num;
     3     public String name;
     4     
     5     public static void main(String[] args) {
     6         Person p1 = new Person();
     7         Person p2 = new Person();
     8         p1.num = 2;
     9         p2.num = 3;
    10         p1.name = "张三";
    11         p2.name = "李四";
    12     }
    13     
    14 
    15 }

    复制代码

     

    当程序执行Person p1 = new Person();时,如果这行代码是第一次使用Person类,则系统通常会在第一次使用Person类时加载这个类,并初始化这个类,在类的准备 阶段,系统将会为该类的类变量分配内存空间,并指定默认初始值。当person类初始化完成后,系统内存中的存储示意图如下图所示。

     可以看出,当person类初始化完成后,系统将在堆内存中为Person分配一块内存空间,实际上是创建了一个类对象,在这块内存区里包含了保存num类变量的内存,并设置num的默认初始值为0。

    系统接着创建了一个Person对象,并把这个Person对象赋给p1变量,Person对象包含了名为name的实例变量,实例变量是在创建实例时分配内存空间并指定初始值的。当创建了第一个person对象后,系统内存中的存储示意图如下图所示。

    从上图可以看出num不属于对象,它属于类,所以创建第一个对象时并不需要为num分配内存空间,系统只是为name分配了内存空间,并指定初始值为null。

    创建第二个对象p2时,由于在创建第一个对象时已经对类进行了初始化,所以在创建p2时对类进行初始化,对象的创建过程与第一个对象的创建过程没有什么区别。

    第二个对象创建完成后,成员变量如上图所示在内存中存储。

    **当程序需要访问类变量时,尽量使用类来作为主调,不要使用对象作为主调,这个可以避免产生歧义。

    3、局部变量的初始化和内存中的运行机制

    *局部变量必须经过显示初始化之后才能使用,系统不会为局部变量执行初始化。定义了局部变量以后,系统并没有给局部变量进行初始化,直到程序给这个局部变量赋给初值时,系统才会为这个局部变量分配内存空间,并将初始值保存到这块内存中。

    *局部变量不属于任何类或者实例,因此它总是保存在方法的栈内存中。如果局部变量是基本数据类型,则该变量直接存储在方法的栈内存中,如果是引用变量则将引用的地址存储在方法的栈内存中。

    *栈内存中的变量无需系统垃圾回收,随着方法或者代码块的运行结束而结束。局部变量通常只保存了具体的值或者引用地址,所以所占的内存比较小。

    4、变量的使用规则

    能不使用成员变量就别使用成员变量

    能不使用方法局部变量就别使用方法局部变量

    使用代码块局部变量性能最好。

     

     

     

    展开全文
  • Java成员变量和局部变量区别

    千次阅读 2021-03-19 10:18:38
    掌握Java成员变量和局部变量 学习内容: 1、变量分类 变量的定义语法 数据类型 变量名 = 初始值; 根据变量定义位置的不同,分成两大类 成员变量: 直接定义在类中,方法外面。又称之为字段(Field),不要称...
  • java成员变量和局部变量

    千次阅读 2016-02-09 17:00:59
    java成员变量和局部变量 成员变量是指在类中定义的变量 局部变量是指在方法中定义的变量 成员变量成员变量分为类属性和实例属性两种,定义一个属性时不使用static修饰就是实例属性,使用static修饰就是类属性。类...
  • java中的变量(成员变量、本地变量、类变量)

    万次阅读 多人点赞 2015-12-05 22:08:29
    Java中的变量: ...1.1-成员变量:(在类中定义,访问修饰符修饰符typename=value) 1.2-什么是成员变量成员变量就是类中的属性。当new对象的时候,每个对象都有一份属性。一个对象中的属性就是成员变量
  • Java成员变量与成员方法

    千次阅读 2019-05-27 10:28:49
    (成员变量定义在类中,方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。) 成员方法: 在Java中使用成员方法来对应与类对象的行为,在类中,除了变量外...
  • 成员变量和成员方法是范围最大定义,简单而论成员变量包括实例变量和类变量,成员方法包括实例方法和类方法。 实例变量 实例变量定义在类中,但是在方法之外,前面没有static修饰,它在一个对象创建时创建,摧毁时...
  • java方法 成员变量 局部变量概述

    千次阅读 2017-12-23 20:37:58
    如果需要定义一个方法,则只能在类里面定义,不能不能独立定义一个方法。一旦将一个方法定义在某个类的类体内,如果这个方法使用了static修饰,则这个方法属于这个类,否则这个方法属于这个类的实例。 1.2 方法的...
  • 如果java成员变量和局部变量重名 JAVA会用局部变量覆盖掉成员 只看楼主 收藏 回复 iehshx 淼沝 5 怎么样才能让两个变量都输出呢...
  • java成员变量是什么

    千次阅读 2019-07-02 07:58:28
    java中 变量分成员变量 和局部变量 成员变量是指这个类的变量,局部变量是类中方法体内定义的变量。
  • Java成员变量、局部变量和静态变量的区别

    千次阅读 多人点赞 2017-12-04 11:30:24
    之前在刚开始学习Java的时候,就谈了谈Java基础中的变量(见 http://www.linuxidc.com/Linux/2015-02/113862.htm),虽然知道这货以后会经常用到,但没想到了基本语法这里,竟然有冒出来了成员变量、局部变量和静态...
  • 成员变量成员变量又叫实例变量,它是类的实例,所作用于所在的整个类。 局部变量:只在某个范围有效(例如方法中)。 类变量:有效性主要和变量前的修饰符有关,例如private修饰就只对此类有效,public对所有包都...
  • java成员变量、类变量、局部变量

    千次阅读 2018-02-25 20:03:12
    成员变量定义在类中,方法体之外。变量在创建对象时实例化。成员变量可被类中的方法、构造方法以及特定类的语句块访问。public class ClassName{ int a; public void printNumber(){ // 其他代码 } }类变量...
  • java成员变量和局部变量的初始化

    千次阅读 多人点赞 2016-07-02 09:40:18
    java成员变量和局部变量的初始化 成员变量的初始化 在java中,成员变量存在于类之内,方法和代码块之外。 class A{ 修饰符 数据类型 成员变量名; 方法(){} }这类变量在创建时如果不给初始化值,创建之后java...
  • 根据定义变量位置的不同,可以将变量分为成员变量和局部变量。 成员变量定义在一个类的变量:类中方法外 局部变量是定义在一个方法内的变量:方法中 成员变量分为: 静态属性:随类的存在而存在,是在类加载的...
  • java成员变量、局部变量、全局变量的区别 原创 2015年03月09日 10:43:27 3057 局部变量在方法内部声明,并且只能在方法内部使用,在外层的方法被调用时被分配内存,请求在方法执行完毕后...
  • 从默认修饰符 “public static final” 中可以看出,在接口内定义成员变量时,成员变量为最终静态变量,不能被实例化为对象【没有对象】,并且必须赋值,在外面访问该成员变量时无法修改该成员变量的值。 例如: 1.
  • 静态成员变量不用new对象,在类加载的过程中就已经初始化存放在数据区域,静态成员变量是类和所有对象共有的, 类和对象都可以改变它的值,每一次改变值之后,静态成员变量的值在所有对象里面都将改变。   ...
  • 成员变量:访问权限修饰符 修饰符 类型 属性名; 局部变量:修饰符类型 属性名; 局部变量没有访问权修修饰符(public private...),但有修饰符static (静态)final(常量)transient (该属性不能被序列化)volatile ...
  • 对于成员变量和局部变量:成员变量就是方法外部,类的内部定义的变量;局部变量就是方法或语句块内部定义的变量。局部变量必须初始化。 形式参数是局部变量,局部变量的数据存在于栈内存中。栈内存中的局部变量随着...
  • JAVA 面向对象 成员变量和局部变量

    万次阅读 多人点赞 2016-07-20 18:08:42
    Java语言中, 根据定义变量位置的不同,可以将变量分成两大类:成员变量 局部变量 成员变量和局部变量的运行机制存在很大差异,下面我们看看差异在哪. 成员变量 成员变量指的是在类里定义的变量. 局部变量指的是...
  • Java接口成员变量和方法默认修饰符

    千次阅读 2017-09-30 22:46:03
    Java接口成员变量和方法默认...所以我们在interface中定义成员变量的时候,可以 1:public static final String name = "张三"; 2:String name = "张三"; 以上两种都可以,老司机一般都是第二种。
  • Java重载成员变量

    千次阅读 2017-02-19 16:29:31
    如果子类中变量的名字和父类的变量的名字一样,不管他们的类型是否一致,那么在子类中,父类的同名变量无法直接通过变量名访问。 (个人认为这是一个很差的设计,对于代码的可读性可维护性非常不友好,编译器应该...
  • 变量按作用范围划分分为全局变量(成员变量)和局部变量 成员变量按调用方式划分分为实例属性与类属性  (有关实例属性与类属性的介绍见另一博文https://blog.csdn.net/DragonGirI/article/details/81948332) ...
  • Java 成员变量与局部变量名重复

    千次阅读 2015-08-17 09:45:27
    Java成员变量和局部变量可以重复定义
  • Java成员变量和成员方法的使用

    千次阅读 2016-10-16 21:56:56
    package g.practise_myself;... 功能:成员变量和成员方法的使用  */ import java.io.*; public class Object  { public static void main(String[] args) { //创建一个人的对象 Person p1=new
  • Java 成员变量和成员方法

    万次阅读 多人点赞 2018-12-07 10:25:44
    Java 语言中对象的属性以成员变量的形式存在,对象的方法以成员方法的形式存在。 成员变量Java 中对象的属性也称为成员变量。为了了解成员变量,首先定义一个图书类,成员变量对应于类对象的属性,在 Book 类...
  • java中interface定义成员变量和方法

    万次阅读 2018-04-16 14:35:46
    在interface里面的成员变量都是public static final 的。所有你可以这样写: public static final int i=10;也可以这样写 int i =10(省略了public static final) 我们都知道Java不支持多继承,但是可以支持多实现...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 369,974
精华内容 147,989
关键字:

java定义成员变量

java 订阅