Java的哲学就是一切都一样，所有的代码都是用类写的。Java是一种纯面向对象的编程语言，类是它的基石。 　　

　　

　　Java类有五种成员类型： 　　

　　

　　类Person{ //属性，或者成员变量字符串名称；布尔运算出错；//构造函数public person(){ } public person(string n，boolean im){//构造函数重载name=n；isMarried=im}//方法，或者函数public void walk(){ system . out . println(' People walk？);} public String display(){ return '名称为：' name '，Married: ' isMarried}//代码块{name='韩梅梅'；isMarried=true}//内部类class pet { String name浮动重量；}} Class

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

　　

　　

　　封装数据和对这些数据进行操作的函数(方法，通常是对封装数据的操作)。 　　

　　

　　1.1数据根据存储类型可分为： 　　

　　

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

　　

　　参考数据类型。 　　

　　

　　1.2数据可分为： 　　

　　

　　1.2.1在方法之外，类中声明的变量称为成员变量(属性)。 　　

　　

　　1.2.1.1变量(不被静态修改，与具体对象相关且有区别)； 　　

　　

　　1.2.1.2变量(用static修饰并与该类的所有对象相关)； 　　

　　

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

　　

　　1.2.2.1参数(由方法和构造函数定义的变量)； 　　

　　

　　方法局部变量(在方法中定义)； 　　

　　

　　1.2.2.3代码块局部变量(在代码块中定义)； 　　

　　

　　

2 类的成员之方法

　　

　　

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

　　

　　将函数封装到方法中的目的是简化代码重用。Java中的方法不能独立存在，所以必须在类中定义。 　　

　　

　　传递Java方法的参数只有一种方式：值传递。也就是说，实际参数值的副本被传递到方法中，但参数本身不受影响。 　　

　　

　　所有参数都使用传值方式传递给方法。对于基元类型的参数，传递实际值；对于引用类型的参数，传递对象的引用。 　　

　　

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

　　

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

　　

　　方法不能修改的参数 　　

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 修饰属性 、方法 、代码块 、内部类。

－End－