精华内容
下载资源
问答
  • java中,成员变量分为两种:实例成员变量和静态成员变量。 1.1.1实例成员变量 实例成员变量:是定义在方法外部类内部的且不被static所修饰的变量.用于描述一个类中包含哪些数据 代码示例: class Person ...

    类的成员

    类的成员可以包含以下:字段、方法、代码块、内部类和接口等。此处我们重点介绍字段.

    1.1字段/属性/成员变量

    在类中, 但是方法外部定义的变量. 这样的变量我们称为 "字段" 或 "属性" 或 "成员变量"(三种称呼都可以, 一般不会严格区分).

    在java中,成员变量分为两种:实例成员变量和静态成员变量。

    1.1.1实例成员变量

    实例成员变量:是定义在方法外部和类内部的且不被static所修饰的变量.用于描述一个类中包含哪些数据

    代码示例:

    class Person {
        public String name;//其别名有三种:属性/实例成员变量/字段
        public int age;
        public boolean flg;
        public char ch;
    }
    
    public class LeiHeDuiXiang {
        public static void main(String[] args) {
            Person person = new Person();
            //默认值为0
            System.out.println(person.age);
            //默认值为null
            System.out.println(person.name);
            //默认值为'\u0000',输出时不显示任何东西
            System.out.println(person.ch);
            //默认值为false
            System.out.println(person.flg);
        }

    注意事项:

    1:通过对象的引用来访问实例成员变量

    2:"访问" 既包含读, 也包含写.

    3:对于一个成员变量如果没有显式设置初始值, 那么会被设置一个默认的初值.

    下面来介绍下成员变量(不管是静态成员变量还是实例成员变量)在不赋值情况下的默认取值吧:

     byte short int long默认取值为 0

     float 默认取值为0.0f;  

    double 默认取值为0.0

     boolean  默认取值为false

     char 默认取值为'\u0000'(最终输出时为空)

    1.1.2静态成员变量

     static关键字修饰成员变量,简称静态成员变量,又称类变量
     1.访问方式:通过类名.静态成员变量名进行访问
     2.内存的存储方式:方法区
     3.特点:静态的只有一份且不依赖对象

    代码示例: 

    class Man {
     public static int count;
    }
    public class LeiHeDuiXiang {
    
        public static void main(String[] args) {
            Man.count++;
            System.out.println(Man.count);
            Man.count++;
            System.out.println(Man.count);
            Man.count++;
            System.out.println(Man.count);
    
        }
    }
    
    //输出结果为:
    1
    2
    3

    因为count为静态成员变量,其存储在方法区中且只有一个,是共享的,所以每次当访问它时,都会影响它的值

    1.2认识null

    null 在 Java 中为 "空引用", 表示不引用任何对象. 类似于 C 语言中的空指针. 如果对 null 进行 . 操作就会引发异常.

    代码示例:

    class Person {
        public String name; public int age;
    }
    class Test {
        public static void main(String[] args) { Person person = new Person();
            System.out.println(person.name.length()); // 获取字符串长度
        }
    }
    // 执行结果
    
        Exception in thread "main" java.lang.NullPointerException at Test.main(Test.java:9)

    同时假如我们给一个对象的引用赋值为null时,当输出这个引用此时还是为null,而假如此时不为空的话,输出值又会为多少呢?

    Person person1 = new Person();
    
    System.out.println(person1);

    上述代码最终的输出结果为如下:

    Person为类,@为分隔符,4554617c为对象地址的哈希值,那么为什么最终的输出结果为这个呢?我们来看下源码便一清二楚了

    1首先来看println处的源码:

    Object类为所有类的父类,valeOf方法是将引用x转化为字符串,那么是如何转化的呢?我们接着看valeOf的源码:

    此处判断这个引用是否为空,若为空,则返回null,若不为空,则返回这个引用所调用的toString方法的返回值,那么我们再来看toString方法的源码吧:

    我们可以看到,toString方法返回的是类的名字加上一个分隔符号@再加上一个把哈希值变成十六进制的数字

    总结:1.当我们输出对象的引用时,此时我们会在底层调用Object类的toString方法,返回一个对象地址的十六进制哈希值

              2.toString 方法会在 println 的时候被自动调用. 将对象转成字符串这样的操作我们称为 序列化.

              3. toString 是 Object 类提供的方法, 我们自己创建的 Person 类默认继承自 Object 类, 可以重写 toString 方法实现我们自己版本的转换字符串方法. (关于继承和重写这样的概念, 我们后面会重点介绍).

              4.IDEA快速生成Object的toString方法快捷键:alt+f12(insert),此处我们没有重写这个默认的toString方法,并无大碍,后面会详细介绍。

    1.3成员变量初始化

    很多时候我们不希望成员变量使用默认值, 而是需要我们显式设定初值. 那么此时有五种方法供我们成员变量初始化:

    1:默认初始化,即程序所赋予的默认值,上面已经讲过,此处不再过多陈述。

    2:就地初始化:即在定义成员变量时便进行初始化,如下所示:

    public String name = "张三";
    
    public int age = 18;

    3:类外初始化,即通过对象的引用进行初始化,这种方法一般用的最多,下面来看下实现过程:(注意私有的可通过setXX和getXX方法实现)

    public static void main(String[] args) {
            Person person = new Person();
            person.name = "张三";
            person.age = 14;
            }

    4:通过实例代码块和静态代码块进行初始化:这个在后面我们会专门讲到,在这里只需要知道这两个代码块的作用一般是提前初始化一些数据.

    5.通过构造方法进行初始化。

    展开全文
  • 小编典典Java的基本范例是编写类,并实例化这些类。实例化的对象(类的实例)具有与它们相关联的属性(成员变量),这些属性会影响它们的行为;当实例执行其方法时,它将引用这些变量。但是,所有特定类型的对象可能都...

    小编典典

    Java的基本范例是编写类,并实例化这些类。实例化的对象(类的实例)具有与它们相关联的属性(成员变量),这些属性会影响它们的行为;当实例执行其方法时,它将引用这些变量。

    但是,所有特定类型的对象可能都具有完全不依赖于成员变量的行为。这些方法最好设为静态。由于是静态的,因此不需要类的实例即可运行该方法。

    你可以执行以下操作来执行静态方法:

    MyClass.staticMethod();//Simply refers to the class's static code

    但是要执行非静态方法,你必须执行以下操作:

    MyClass obj = new MyClass();//Create an instance

    obj.nonstaticMethod();//Refer to the instance's class's code

    在更深层次上,当编译器将一个类放在一起时,它包含一些指向方法的指针。当执行这些方法时,它将跟随指针并在远端执行代码。如果实例化了一个类,则创建的对象将包含一个指向“虚拟方法表”的指针,该指针指向继承层次结构中该特定类要调用的方法。但是,如果该方法是静态的,则不需要“虚拟方法表”:对该方法的所有调用都将进入内存中的确切位置,以执行完全相同的代码。因此,在高性能系统中,如果你不依赖实例变量,则最好使用静态方法。

    2020-02-29

    展开全文
  • 一:基本介绍java中的静态成员包括静态方法和静态成员变量,静态成员都是由static修饰的;java中的实例成员包括实例方法和实例成员变量,实例成员都没有被static修饰;二:使用语法关于使用静态成员和实例成员的具体语法...

    一:基本介绍

    java中的静态成员包括静态方法和静态成员变量,静态成员都是由static修饰的;

    java中的实例成员包括实例方法和实例成员变量,实例成员都没有被static修饰;

    二:使用语法

    关于使用静态成员和实例成员的具体语法规则如下:

    public class Player {

    public String palyerName = “wade”;

    public static final int playerNumber = 3;

    public static void play(){}

    public void score(){}

    }

    public class MemberAccess {

    private String team = “heat”;

    private static String city = “Miami”;

    //静态方法

    public static void testStatic(){

    //System.out.println(“team = “+ team);在静态方法中直接使用实例成员变量,语法出错,编译不能通过

    System.out.println(new MemberAccess().team);//可以通过创建实例对象使用本类中的实例成员变量

    new MemberAccess().testInstance();//可以通过创建实例对象使用本类中的实例方法

    System.out.println(“city = ” + city);//使用本类中的静态成员变量,一般使用MemberAccess.city方式

    //对于其他类的静态成员和实例成员,可以通过类名或对象的方式使用

    System.out.println(“palyerNumber:” + Player.playerNumber);

    System.out.println(“playerName:” + new Player().palyerName);

    Player.play();

    new Player().score();

    //注意,在静态方法中不能出现this关键字

    }

    //实例方法

    public void testInstance(){

    System.out.println(“team = “+ team);//使用本类中的实例成员变量,一般使用this.team的方式

    System.out.println(“city = ” + city);//使用本类中的静态成员变量,一般使用MemberAccess.city方式

    //对于其他类的静态成员和实例成员,可以通过类名或对象的方式使用

    System.out.println(“palyercity:” + Player.playerNumber);

    System.out.println(“playerteam:” + new Player().palyerName);

    Player.play();

    new Player().score();

    }

    三:总结思考

    1:为什么在静态方法中不能直接使用实例成员变量,要创建实例对象之后才能使用

    2:为什么在实例方法中可以直接使用静态成员

    展开全文
  • java中的成员分为:静态成员 : 静态成员变量,静态代码块,静态成员方法实例成员实例成员变量,实例代码块,实例成员方法构造方法析构方法下面做的实验,主要是验证 当new 一个子类时,子类它的父类中 静态成员...

    java中的成员分为:

    静态成员 : 静态成员变量,静态代码块,静态成员方法

    实例成员:实例成员变量,实例代码块,实例成员方法

    构造方法

    析构方法

    下面做的实验,主要是验证 当new 一个子类时,子类和它的父类中  静态成员变量,静态代码块,实例成员变量,实例代码块,构造方法 这5部分的执行顺序

    父类代码:

    package _test;

    public abstract class AbstractClass {

    private static N n = new N(); //静态成员变量

    static{ //静态代码块

    System.out.println(2);

    }

    private M m = new M(); //实例成员变量

    { //实例代码块

    System.out.println(6);

    }

    public AbstractClass(){ //无参数的构造函数

    System.out.println(7);

    }

    public AbstractClass(int i){ //有参数的构造函数

    System.out.println(i);

    }

    }

    class M{

    public M(){

    System.out.println(5);

    }

    }

    class N{

    public N(){

    System.out.println(1);

    }

    }

    子类代码:

    package _test;

    public class SubClass extends AbstractClass {

    static{ //静态代码块

    System.out.println(3);

    }

    private static U u = new U(); //静态成员变量

    { //实例代码块

    System.out.println(8);

    }

    private I i = new I(); //实例成员变量

    public SubClass(){

    super(); //显式调用父类的构造函数;如果不写,也会隐式调用

    System.out.println(10);

    }

    }

    class I{

    public I(){

    System.out.println(9);

    }

    }

    class U{

    public U(){

    System.out.println(4);

    }

    }

    在main中 执行语句  SubClass sc = new SubClass();

    执行结果是: 1 2 3 4 5 6 7 8 9 10

    执行过程分析:

    当new 子类时,

    首先由JVM找出相关的父类,先加载父类再加载子类;  【对应结果中的 1 2 3 4】

    然后,进入子类的构造方法内部,先隐式地调用super()(也可显示调用无参数的或有参数的)来构造父类;【对应结果中的 5 6 7】

    然后,初始化子类中的实例成员,(这一步在构造方法内部并没有显式的代码) ;【对应结果中的8 9】

    最后,执行super()后面的其它语句。  【对应结果中的10】

    由上面执行过程可知:

    在构造方法里,执行语句super()和它后面的语句之间存在一个“过程”,在这个“过程"中执行的操作:初始化实例成员变量和执行实例代码块。

    (这个过程应该也是由JVM默认执行的。)

    展开全文
  • 静态成员:又称实例成员,未使用static修饰符的方法变量。结论注:jdk1.8测试源码public class Main {private int x = 34; // 非静态变量private static int a = 1; // 静态变量private static ...
  • 静态方法在访问本类的成员时,只允许访问静态成员(即静态成员变量静态方法),而不允许访问实例成员变量实例方法;实例方法则无此限制。下面几个例子展示了这一区别。1、调用静态方法示例。//------...
  • 静态成员1.静态域当创建一个类的许多对象时,每个对象都有属于自己的非静态域,这些变量存储在不同的内存位置。有时,我们希望某个域被所有对象共享,或者说这个域属于整个类而不是每个对象。使用static修饰符的域被...
  • 懒得自己再敲一遍了:——————————————————————————————————————————————————————————————————————————静态方法和实例方法的区别主要体现...
  • java程序里,所有东西都是对象,而对象的抽象就是类,对于一个类而言,如果要使用他的成员(成员指类中的函数、变量)普通情况:必须先实例化对象后才能通过对象的引用才能访问这些成员例外:该成员是用Static...
  • Java类中的成员(属性方法)可以分成两种,分别是实例成员和类成员。一、什么是实例成员和类成员?实例成员中是属于对象的,即属于对象级别的,它包括实例成员属性(也称为实例成员变量)和实例成员方法,只有创建了...
  • 这些静态成员不需要实例化即可直接引用。静态方法:不需要实例化,可直接引用。静态变量:不需要实例化,可直接引用。静态代码块:在系统初始化时时使用静态内部类:不能操作访问外部数据。静态的类在运行时加载到...
  • java变量分为实例变量和静态变量方法分为实例方法和静态方法如class Example{int data;//定义实例变量,也叫成员变量public void method(){ //实例方法,也叫成员方法.....}public static int count = 0;//定义静...
  • java静态方法和成员

    2021-03-23 17:45:23
    1. 静态方法:成员变量分为实例变量和静态变量。其中实例变量属于某一个具体的实例,必须在类实例化后才真正存在,不同的对象拥有不同的实例变量。而静态变量被该类所有的对象公有(相当于全局变量),不需要实例化就...
  • (注:静态变量修改为静态成员变量,静态方法改为静态成员方法)静态成员变量又称类变量,静态成员方法又称类方法,它们统称为静态成员或类成员。静态成员由static修饰,是属于整个类的,所有的对象共享这些静态成员。...
  • 首先弄明白:静态变量属于类的级别,而实例变量...主要区别有两点:1,存放位置不同类变量随着类的加载存在于方法区中,方法区即静态区(方法区包含整个程序中唯一存在的元素)实例变量随着对象的对象的建立存在于堆...
  • 面试题16 关于实例成员和成员区别考题题干下面关于实例成员的说法,哪些是正确的?A.实例成员也被称为实例变量B.实例成员属于类成员C.实例成员隶属于实例,但不隶属于整个类D.实例成员包括实例变量实例方法E...
  • 周末补了一下java对象实例化的顺序,用几个测试案例记录下:测试代码:HelloAHelloB运行结果子类继承父类,运行顺序:父静态——>子静态——>父代码块——>父构造方法——>子代码块——>子构造方法若...
  • java中的静态变量和实例变量有什么区别发布时间:2020-06-26 15:46:16来源:亿速云阅读:89作者:Leah今天就跟大家聊聊有关java中的静态变量和实例变量的区别,可能很多人都不太了解,为了让大家更加了解,小编给...
  • 三:静态变量与实例变量的区别 存储区域不同:静态变量存储在静态存储区域,实例变量存储在堆中,会被释放。 静态变量与类相关,实例变量与对象相关。 生命周期不同,静态变量在类启动时就分配指定内存;实例变量在...
  • 静态方法和实例方法的区别主要体现在两个方面: 在外部调用静态方法的时候,可以用类名.方法名进行调用,不必新创建一个对象。当然也可以创建一个对象,通过对象名.方法名进行调用,不过这种方法并不推荐。而实例...
  • java静态变量和成员变量的区别 1、静态变量。 由static修饰的变量称为静态变量,其实质上就是一个全局变量。如果某个内容是被所有对象所共享,那么该内容就应该用静态修饰;没有被静态修饰的内容,其实是属于对象...
  • 【资料来源】方法是我们每天都在写得,很多程序员大多都使用实例化方法,而很少使用静态方法,问原因也说不出来所以然,或者简单的回答两者定义的区别静态方法不需要new就可以使用 实例化方法需要new了以后才可以...
  • Java中的静态成员

    2021-03-17 17:37:59
    静态成员static修饰符可以修饰成员变量、成员方法代码块。1、用static修饰的成员变量叫静态变量。2、用static修饰的成员方法叫静态方法。3、用static修饰的代码块表示静态代码块,当Java虚拟机加载类时,就会执行...
  • } } 输出为 第一个实例对象调用变量i的结果:47 调用call()方法 0 1 2 第二个实例对象调用变量i的结果:60 调用call()方法 0 1 2 2、使用static 第一个实例对象调用变量i的结果:60 调用call()方法 0 1 2 第二个...
  • 静态成员静态成员类都可以访问外围类的所有成员,包括那些声明为private的成员。 两者非常相似,主要静态成员类多累static修饰词。 正因此,非静态成员类的每个实例都隐含着与外部类的一个实例所相关联。在非...
  • 这篇文章主要介绍了Java静态静态成员变量初始化过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下Java中非静态成员变量、静态成员变量的初始化时机。...
  • ●静态方法在访问本类的成员时,只允许访问静态成员(即静态成员变量静态方法),而不允许访问实例成员变量实例方法;实例方法则无此限制。下面几个例子展示了这一区别。//-----------hasS...
  • 成员变量 也叫全局变量,能够描述一个类的属性,与局部变量对立。 成员变量在类中,类方法外 局部变量一般在方法中,循环体中等 静态变量 用 static 修饰的的变量是静态变量,静态变量的内容可以被所有对象共享,...
  • “常规”内部类具有指向外部类实例的隐藏(隐式)指针。 这允许编译器生成代码以便为您追逐指针而无需键入它。 例如,如果外部类中有变量“a”,那么内部类中的代码只能执行“a = 0”,但编译器将生成“outerPointer.a...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 232,921
精华内容 93,168
关键字:

java实例成员和静态成员的主要区别

java 订阅