JAVA的哲学是一切皆类，全部代码都写在类内。Java是纯面向对象的编程语言，类是其基石。

Java类有五类成员：

class Person{
    // ① 属性，或成员变量
    String name;
    boolean isMarried;
    // ③ 构造器
    public Person(){}
    public Person(String n, boolean im){// 构造器重载
        name = n;
        isMarried = im;
    }
    // ② 方法，或函数
    public void walk(){
        System.out .println("人走路?");
    }
    public String display(){
        return "名字是："+name+",Married: "+isMarried ;
    }
    // ④ 代码块
    {
        name = "HanMeiMei";
        isMarried = true;
    }
    // ⑤ 内部类
    class pet{
        String name;
        float weight;
    }
}

1 类的成员之属性（数据）

类封装数据和操作这些数据的函数（方法，通常是操作封装的数据）。

1.1 数据按存储类型可以分为：

1.1.1 基本数据类型 (如int 、Boolean；

1.1.2 引用数据类型。

1.2 数据按作用域可以分为：

1.2.1 在方法体外，类内声明的变量称为成员变量（属性）。

1.2.1.1 实例变量（不以static修饰，与具体对象相关，有差异化）；

1.2.1.2 类变量（以static修饰，与类全部对象相关）；

1.2.2 在方法体内部声明的变量称为局部变量。

1.2.2.1 形参（方法、构造器定义的变量）；

1.2.2.2 方法局部变量（在方法内定义）；

1.2.2.3 代码块局部变量（在代码块定义）；

2 类的成员之方法

方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中也称为函数或过程。

将功能封装为方法的目是，可以实现代码重用简化，Java 里的方法不能独立存在，所有必须定义类里。

Java里方法的参数传递方式只有一种：值传递。即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。

All parameters are passed to methods using pass-by-value. For a parameter of a primitive type, the actual value is passed; for a parameter of a reference type, the reference for the object is passed.

形参是基本数据类型时，将实参基本数据类型变量的“数据值”传递给形参；

形参是引用数据类型时，将实参引用数据类型变量的“地址值”传递给形参；

A method cannot modify a parameter of a primitive type (that is, numbers or boolean values).

A method can change the state of an object parameter.

A method cannot make an object parameter refer to a new object.

类属性作为该类各个对象之间共享的变量。在设计类时，分析哪些属性不因对象的不同而改变，将这些属性设置为类属性。相应的方法设置为类方法。

如果方法与调用者无关，则这样的方法通常被声明为类方法，由于不需要创建对象就可以调用类方法，从而简化了方法的调用。

在同一个类中，允许存在一个以上的同名方法，只要它们参数个数或参数类型不同（与返回值类型无关）。

方法也可以递归调用（一个方法体内调用它自己）。

3 类的成员之构造器

数据的初始化很重要，成员变量同样如此。面向对象的语法机制能够确定对象创建即初始化创建时自动调用一个初始化成员变量的方法，这个方法称为构造器，为确定不同的初始化方法来构建不同的对象，构造器也可以重载。

构造器的特征：

① 名称与类名相同；

② 不声明返回值类型，不能有return 语句；

③ 不能被 static 、final、synchronized、abstract 、native修饰。

根据参数不同，构造器可以分为如下两类：

隐式无参构造器（系统默认提供）；

显式定义一个或多个构造器（无参、有参）。

Java语言中，每个类都至少有一个构造器，也可以重载多个，默认构造器的修饰符与所属类的修饰符一致。

一旦显式定义了构造器，则系统不再提供默认构造器。

类方法都隐式包含一个表示其对象的关键字this，this可以调用本类的其它方法、构造器和引用数据成员。

在继承体系中，子类可以使用关键字super调用父类的构造函数。

4 类的成员之代码块

对类内数据成员的初始化，除了使用构造器，还可以使用代码块。

（有点类似于C++的初始化列表，先于构造函数执行。）

类的static数据成员的初始化使用静态代码块（用static修饰），由此，代码块分为两类：

4.1 静态代码块：用static 修饰的代码块。

static代码块通常用于初始化static的属性

class Person {
    public static int total;
    static {
        total = 100;//为total赋初值
    }
    …… //其它属性或方法声明
}

4.1.1 可以有输出语句。

4.1.2 可以对类的属性、类的声明进行初始化操作。

4.1.3 不可以对非静态的属性初始化。即不可以调用非静态的属性和方法。

4.1.4 若有多个静态的代码块，那么按照从上到下的顺序依次执行。

4.1.5 静态代码块的执行要先于非静态代码块。

4.1.6 静态代码块随着类的加载而加载，且只执行一次。

4.2 非静态代码块：没有static修饰的代码块。

1 可以有输出语句。

2 可以对类的属性、类的声明进行初始化操作。

3 除了调用非静态的结构外，还可以调用静态的变量或方法。

4 若有多个非静态的代码块，那么按照从上到下的顺序依次执行。

5 每次创建对象的时候，都会执行一次。且先于构造器执行。

程序中成员变量赋值的执行顺序：

① 声明成员变量的默认初始化；

② 显式初始化、多个初始化块依次被执行（同级别下按先后顺序执行）；

③ 构造器再对成员进行初始化操作；

④ 通过”对象.属性”或”对象.方法”的方式。

5 类的成员之内部类

当一个事物的内部，还有一部分需要完整结构进行描述，而这部分的完整结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类 。

An inner class is a class that is defined inside another class. Why would you want to do that? There are three reasons:

① Inner class methods can access the data from the scope in which they are defined—including the data that would otherwise be private.

② Inner classes can be hidden from other classes in the same package.

③ Anonymous inner classes are handy when you want to define callbacks without writing a lot of code.

在Java 中，允许一个类的定义位于另一个类的内部。前者称为内部类（Inner class） ，后者称为外部类（out class）。

Inner class 一般用在定义它的类或语句块之内，外部引用它时必须给出完整的名称。

Inner class的名字不能与包含它的外部类类名相同。

内部类可以区分为：

① 成员内部类（static成员内部类和非static成员内部类）；

② 局部内部类（不用修饰符）；

③ 匿名内部类。

成员内部类作为类的成员的角色：

和外部类不同 ，Inner class还可以声明为private 或protected；

可以调用外部类的结构；

Inner class可以声明为 static 的，但此时就不能再使用外层类的非 static的成员变量。

成员内部类作为类的角色：

可以在内部定义属性 、方法 、构造器等结构；

可以声明为abstract类 ，因此可以被其它的内部类继承；

可以声明为 final；

编译以后生成 OuterClass$InnerClass.class字节码文件 （也适用于局部内类）。

public class MAIn {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.test();
    }
}
// Demonstrate an inner class.
class Outer {
    int outer_x = 100;
    void test() {
        Inner inner = new Inner();
        inner.display();
    }
    // this is an inner class
    class Inner {
        void display() {
            System.out.println("display: outer_x = " + outer_x);
        }
    }
}

The nesting is a relationship between classes, not objects. A LinkedList object does not have subobjects of type Iterator or Link.

There are two benefits about inner class: name control and access control.

However, the Java inner classes have an additional feature that makes them richer and more useful than nested classes in C++. An object that comes from an inner class has an implicit reference to the outer class object that instantiated it. Through this pointer, it gains access to the total state of the outer object.

匿名内部类不能定义任何静态成员、方法和类，只能创建匿名内部类的一个实例。一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。

在Java 类中 ，可用 static 修饰属性 、方法 、代码块 、内部类。