Java中类class说明（二）

93 阅读 0 评论 62 点赞

我是靠谱客的博主文艺白猫，最近开发中收集的这篇文章主要介绍Java中类class说明（二），觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

Java类由属性、方法、构造器、代码块、内部类五部分组成。

代码块：初始化块，属于类中的成员，类似与方法

将逻辑语句（任何逻辑语句都可）封装在方法体中，通过{}包围起来

和方法不同，其没有方法名，没有返回值，没有参数，仅仅只有{方法体}

语法：[修饰符] {代码块};

本质上：相当于另一种形式的构造器（对构造器的补充机制），可以做补充机制。当构造器中有许多重复语句，可以抽取到构造器中，提高代码的复用性。

分类：代码块通常被分为两类：被static修饰的静态代码块，不被static修饰的普通代码块

静态代码块作用：对类进行初始化，随着类的加载而执行。其中只能调用静态成员

普通代码块作用：可以调用任何成员

类加载的时间：1.创建对象实例的时候

2.创建子类对象：先加载父类，后加载子类

3.调用类中的静态成员

调用规则：

对于静态代码块：类在被加载时，执行。仅仅执行一次

对于普通代码块：每当new一个对象时，就会被调用一次

创建对象时，调用顺序：

调用代码块的顺序优于调用构造器的顺序。不管调用哪个构造器都会先调用代码块。

1.调用静态代码块、静态属性初始化（两者优先级相同，如果同时出现，则按照定义的顺序）--静态代码块即静态属性初始化在类加载的时候就完成了

2.调用普通代码块、普通属性初始化（两者优先级相同，如果同时出现，则按照定义的顺序）--在构造器的前面隐含了super()和调用普通代码块

3.调用构造器

创建子类对象时，调用顺序：

首先进行类的加载，先完成父类的记载后进行子类的加载。然后创建对象，调用子类构造器中的super(),进入父类的构造器，调用父类的普通代码块和普通属性初始化，后创建父类的对象；完成后，进入子类，子类的普通代码块和普通属性初始化，后创建子类对象。

1.调用父类的静态代码块和静态属性初始化

2.调用子类的静态代码块和静态属性初始化

3.父类的普通代码块和普通属性初始化

4.父类的构造器

5.子类的普通代码块和普通属性初始化

6.子类的构造器

内部类：一个类的内部完整的嵌套了另一个类的结构。被嵌套的类称为内部类；嵌套的类称为外部类。

特点：直接访问外部类的私有属性，并且体现类与类之间的包含关系

class Outer { // 外部类
class Inner { // 内部类
}
}
class Other { // 其他类
}

内部类的分类：根据定义的位置：

1.定义在外部类的局部位置上（方法内或代码块中）：局部内部类（有类名）；匿名内部类（没有类名）

2.定义在外部类的成员位置上：成员内部类（没有static修饰）；静态内部类（使用static修饰）

// 局部内部类
// 外部类
class Outer {
private int num;
private String name = "kxg";
public void f1() {
// 内部类
// 首先内部类定义在外部类的局部位置上（方法内或代码块中）
// 局部内部类Inner不能使用访问修饰符进行修饰，但是可以使用final
// 类Inner属于局部变量中的成员，所以不能使用访问修饰符
// 类Inner使用final修饰，表示该类不能再被继承
class Inner {
// 局部内部类中可以直接访问外部类中的私有属性
num = 1；
// 局部内部类与外部类有同名的属性,并进行访问
private String name = "jack";
public void f3() {
// 局部类与外部类有同名属性，访问是遵循就近原则，输出局部内部类中的变量值
System.out.println("局部内部类中的name = " + name); // jack
// 访问外部类中的name，使用Outer.this.name
System.out.println("外部类中的name = " + Outer.this.name);
// Outer.this本质上是一个外部类的对象，通过对象名.属性访问name
// 创建的外部类对象实例中，谁调用了Outer中的f2，Outer.this指向谁
}
}
}
public void f2() {
// 创建内部类的实例，调用内部类方法
Inner inner = new Inner();
inner.f3();
}
}

// 匿名内部类比较重要，在下篇blog中详细介绍

// 成员内部类
class Outer { // 外部类
privte int num;
private String name = "jack";
// 内部类
// 成员内部类，定义在类体中，没有static修饰
// 可以用访问修饰符进行修饰，本身也是一个局部变量
// 与其他类中成员一样，作用域是整个类体
class Inner {
private String name = "kxg";
// 可以访问类中的任意成员，包括私有属性
num = 1;
// 内部类与外部类的同名属性访问：
public void f1() {
// 直接通过属性名进行访问，遵循就近原则，得到内部类中的成员
System.out.println("局部类中的name =" + name); // kxg
// 访问外部类中的name，通过Outer.this.属性名
System.out.println("外部类中的name =" + name); // jack
}
}
// 外部类中方法使用内部类
public void f2() {
// 创建内部类对象
Inner inner = new Inner();
inner.f1();
}
// 返回内部类对象
public Inner getInner() {
return new Inner();
}
}
public class Test {
public static void main(String[] args) {
// 创建外部类
Outer outer = new Outer();
outer.f1();
// 在外部其他类main中访问成员内部类
// 1.通过外部类的对象创建内部类对象
Outer.Inner inner = Outer.new Inner(); // 相当于把new Inner当作外部类Outer中的成员
inner.f1();
// 2.在外部类中的写方法，返回内部类对象
Outer.Inner inner1 = outer.getInner();
}
}

// 静态内部类
class Outer {
private int num;
private static int count;
private static String name = "jack";
// 内部类
// 静态内部类：定义在外部类的类体中，使用static修饰
// 可以使用访问修饰符修饰，本身是一个类中的成员
// 作用范围与其他类成员一样，是整个类体
static class Inner {
// 可以直接访问类中的静态成员，不能访问非静态的
count = 1;
// num = 1;
// 外部类的静态属性与内部类属性重名
private String name = "mary";
public void f1() {
// 如果外部类的静态属性与内部类属性重名，则遵循就近原则
System.out.println("name= " + name); // mary
// 访问外部类中的count：外部类名.属性
System.out.println("name= " + Outer.name); // jack
}
}
// 外部类访问内部类
public void f2() {
// 创建内部类
Inner inner = new Inner();
inner.f1();
}
public Inner getInner() {
return new Inner();
}
public class test() {
public static void main(String[] args) {
// 外部其他类访问静态内部类：
// 1.直接new，因为静态内部类可以通过类名直接访问
Outer.Inner inner = new Outer.Inner();
inner.f1();
// 2.外部类提供方法，返回内部类对象
Outer outer = new Outer();
Outer.Inner inner1 = outer.getInner();
}
}