类的成员可以包括什么？

首先：创建类以及实例化对象的基本语法如下：

// 创建类
class <class_name>{ 
  field;//也叫字段/属性/成员变量(field)
  method;//成员方法
}
// 实例化对象
<class_name> <对象名> = new <class_name>();

Q：类的成员可以包括什么？
A：类的成员可以包含：字段、方法、代码块、内部类和接口等。

"示例:"
public class Person {
  //1--字段、属性，成员变量"
  public String name;  
  public int age;
  public static String STATIC_FIELD = "静态属性";
  
  //2--代码块分为普通代码块 静态代码块 构造代码块" 
  //"2.1构造代码块"
  {
        System.out.println("第一构造块");
  }
 // "构造方法"
  public Person (int i) {
        System.out.println("第" + i + "次调用" + "构造方法");
    }
    
  //"2.2静态代码块"
    static {
        System.out.println(STATIC_FIELD);
        System.out.println("静态代码块1");
    }
    
  //"3--方法"
  public void show() {
  	//"2.3普通代码块"
 	System.out.println("我叫" + name + ", 今年" + age + "岁");
  }
  
  //4--内部类
  class Draw {     
        public void drawShape() {
            System.out.println("draw");
        }
    }
   //5--接口
   public interface Eat {
        public String info();
    }
  
  //main()方法
 public static void main(String[] args) {
    Person person = new Person();//创建对象
    //使用new 关键字用于创建一个对象的实例；
    //使用 . 来访问对象中的属性和方法.；同一个类可以创建多个实例。
    System.out.println(person.name);
    person.show();//调用方法
}

• 类Draw是类Person的一个成员，Person称为外部类。成员内部类Draw可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）
• 需要注意，内部接口不管有没有声明static,都是静态的。这不同于成员内部类，成员内部类需要依赖其所在类实现的对象

——————————————————————————————————

字段(field)

• 初始化的三种方式：
  ①就地初始化,public String name = "张三";
  ②默认初始化public String name; 默认值为null；
  ③类外初始化。类外初始化在项目工程中使用频繁。
  对于一个对象的字段如果没有显式设置初始值, 那么会被设置一个默认的初值；

默认值规则
1、对于各种数字类型, 默认值为 0.
2、对于 boolean 类型, 默认值为 false.
3、对于引用类型(String, Array, 以及自定制类), 默认值为 null

方法 (method)

• 语法规则
  1.方法名称必须与类名称相同
  2.构造方法没有返回值类型声明
  3.每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造）

• 方法中还有一种特殊的方法称为 构造方法 (construction method)
  在使用关键字new实例化对象的时候会被自动调用到的方法, 方法名字和类名相同, 用于完成对象的初始化操作.

  这里就不得不提到new 执行过程，总共分为2步：
  1、为对象分配内存空间
  2、调用对象的构造方法

• 注意事项
  1、如果类中没有提供任何的构造函数，那么编译器会默认生成一个不带有参数的构造函数
  2、若类中定义了构造方法，则默认的无参构造将不再生成.
  3、构造方法支持重载. 规则和普通方法的重载一致

关键字static
       关于static修饰的属性和方法都使用类名.方法/属性来调用；因为静态的方法和属性就已经不依赖于对象了。同一个类的不同实例共用同一个静态属性.例如如下代码：

class TestDemo{
  public int a;
  public static int count;  //静态成员变量
}
public class Main{
 
public static void main(String[] args) {
    TestDemo t1 = new TestDemo();
    t1.a++;
    TestDemo.count++;
    System.out.println(t1.a);//1
    System.out.println(TestDemo.count);//1
    //实例化多个对象
    TestDemo t2 = new TestDemo();
    t2.a++;
    TestDemo.count++;//使用类名.属性来调用
    //无需创建实例对象 就可以调用
    System.out.println(t2.a);//1
    System.out.println(TestDemo.count);//2 
    //因为是共用的所以count从1变到2
 }
}

注：static可以修饰属性、修饰方法、代码块、修饰类

修饰限定符 private/ public 这两个关键字表示 “访问权限控制”
被 public 修饰的成员变量或者成员方法,可以直接被类的调用者使用.
被 private 修饰的成员变量或者成员方法, 不能被类的调用者使用

类和对象

       类和对象可以说是一个抽象与具体的例子，将一个具有共同属性的集合高度概括为一个抽象的“类（Class）”，在创建一个Class后可以将它实例化为许多具体的“对象”。我们借用类和对象来实现我们所需要的功能。

class Person {
  public int age;//实例变量  
  public String name;//实例变量
  public String sex;//实例变量均存放在对象内
  public static int count;//类变量也叫静态变量，编译时已经产生，属于类本身，且只有一份。存放在方法区
  public final int SIZE = 10;//被final修饰的叫常量，也属于对象。 被final修饰，后续不可更改，存放在对象内
  public static final int  COUNT = 99;//静态的常量，属于类本身，只有一份 被final修饰，后续不可更，存放在方法区
改
  //实例成员函数
  public void eat() {
   int a = 10;//局部变量
   System.out.println("eat()!"); 
 }
 
  //实例成员函数
  public void sleep() {
   System.out.println("sleep()!"); 
 }
 
  //静态成员函数
  public static void staticTest(){
    //不能访问非静态成员
    //sex = "man"; error
    System.out.println("StaticTest()");
  }
}

public class Main{
public static void main(String[] args) {
    //产生对象 实例化对象
    Person person = new Person();//person为对象的引用
    System.out.println(person.age);//默认值为0
    System.out.println(person.name);//默认值为null
    //System.out.println(person.count);//会有警告!
    //正确访问方式：
    System.out.println(Person.count);
    System.out.println(Person.COUNT);
    Person.staticTest();
    //总结：所有被static所修饰的方法或者属性，全部不依赖于对象。
    person.eat();
    person.sleep();
}
}

下图为数据属性的内存布局：