类的成员
 
类的成员可以包含以下：字段、方法、代码块、内部类和接口等。此处我们重点介绍字段.
 
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的基本范例是编写类，并实例化这些类。实例化的对象(类的实例)具有与它们相关联的属性(成员变量)，这些属性会影响它们的行为；当实例执行其方法时，它将引用这些变量。
 
但是，所有特定类型的对象可能都具有完全不依赖于成员变量的行为。这些方法最好设为静态。由于是静态的，因此不需要类的实例即可运行该方法。
 
你可以执行以下操作来执行静态方法：
 
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修饰;
 
二:使用语法
 
关于使用静态成员和实例成员的具体语法规则如下:
 
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 一个子类时，子类和它的父类中  静态成员变量，静态代码块，实例成员变量，实例代码块，构造方法 这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默认执行的。)