Java码农人生使用手册——类和对象

一、类的定义和使用

        类是用来对一个实体（对象）来进行描述的。

注意：

• 类名采用大驼峰定义

二、类的实例化

        定义了一个类，就相当于在计算机中定义了一个新的类型，用类的类型创建对象的过程，称为类的实例化。

注意：

• new关键字用于创建一个对象的实例；
• 使用 . 来访问对象中的属性和方法；
• 同一个类可以创建多个实例。

说明： 

1. 类只是一个模型，用来描述一个实体，限定实体有哪些成员。
2. 类是一种自定义的类型，可以用来定义变量。
3. 一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量。
4. 类相当于设计图纸，只设计出需要什么东西；类的实例化就像使用这个图纸建造出来的房子，实际存储数据，占用物理空间。

三、this引用

        this引用指向当前对象（成员方法运行时调用该成员方法的对象），在成员方法中， 所有成员变量的操作都是通过该引用去访问的。

this引用的特性：

1. this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型。
2. this只能在成员方法中使用。
3. 在成员方法中，this只能引用当前对象，不能引用其他对象。
4. this是“成员方法”第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法对象的引用传递给该成员方法，this负责来接收。

四、对象的创造和初始化

1、构造函数

        名字必须与类名相同，在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次。

注意：

• 构造方法没有返回值类型，设置为void也不行；
• 一般情况下用public修饰；
•  构造方法的作用就是对对象的成员进行初始化，并不负责给对象开辟空间。

特性： 

1. 名字必须与类名相同。
2. 没有返回值类型，设置为void也不行。
3. 创建对象时由编译器自动调用，并且在整个对象的生命周期内只调用一次。（相当于人的一生只出生一次）
4. 构造方法可以重载。
5. 如果用户没有显式定义，编译器会生成一份默认的无参构造方法。一旦用户定义，编译器则不会生成。
6. 在构造方法中，可以使用this调用其他的构造方法来简化代码。
   1. this（……）必须是构造方法中的第一条语句。
   2. 不能形成闭环。
7. 大多数情况下使用public修饰，特殊场景下会被private修饰（单例模式时会遇到）。

2、默认初始化

new关键字的作用：

1. 检测对象对应的类是否加载了，如果没有加载则加载。
2. 为对象分配内存空间。
3. 处理并发安全问题。（比如多个线程同时申请对象，JVM要保证给对象分配的空间不冲突）
4. 初始化所分配的空间。即：对象空间被申请好之后，对象中包含的成员已经设置好了初始值（一.1）。
5. 设置对象头信息。（对象内存模型部分介绍）
6. 调用构造方法给对象各个成员赋值。

3、就地初始化

        在声明成员变量时，就直接给出初始值。（注意：代码编译完成后，编译器会将所有给成员初始化的这些语句添加到各个构造函数中。）

 五、封装

        面向对象三大特性（封装、继承、多态）之一。简单来说，封装就是套壳屏蔽细节。

1、概念

        将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。

2、访问限定符

        在Java中，主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，而访问权限用来控制方法或者字段能否直接在类外使用。

注意：

• protected主要用于继承；
• 什么都不写时默认的权限为default；
• 访问权限除了可以限定类中成员的可见性以外，还可以控制类的可见性；
• 一般情况下成员变量设置为private， 成员方法设置为public。 

3、包 

        为了更好的管理类，把多个类收集在一起成为一组，称为软件包。包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式。在同一个工程中允许存在相同名称的类，只要处在不同的包中即可。

3.1导入包中的类

        使用import 语句导入包。可以使用import static导入包中静态的方法和字段。

        注意：import 和 C++ 的 #include 差别很大。C++ 必须 #include 来引入其他文件内容, 但是 Java 不需要。import 只是为了写代码的时候更方便。import 更类似于 C++ 的 namespace 和 using。

3.2自定义包

基本规则：

• 在文件的最上方加上一个 package 语句指定该代码在哪个包中。
• 包名需要尽量指定成唯一的名字。
• 包名要和代码路径相匹配。例如创建 com.bit.demo1 的包，那么会存在一个对应的路径 com/bit/demo1 来存储代码。
• 如果一个类没有 package 语句，则该类被放到一个默认包中。

3.3常见的包

1. java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入
2. java.lang.reflect:java 反射编程包
3. java.net:进行网络编程开发包
4. java.sql:进行数据库开发的支持包
5. java.util:是java提供的工具程序包。(集合类等) 非常重要
6. java.io:I/O编程开发包

六、static成员

        在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对象，是所有对象所共享的。

1、static修饰成员变量（静态成员变量）

        static修饰的成员变量，称为静态成员变量，静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共享的。

特性：

1. 不属于某个具体的对象，是类的属性，所有对象共享的，不储存在某个对象的空间中。
2. 既可以通过对象访问，又可以通过类名访问，但一般推荐通过类名访问。
3. 类变量储存在方法区中。
4. 生命周期伴随类的一生。（随类的加载而创造，随类的卸载而销毁）

2、static修饰成员方法（静态成员方法）

        static修饰的成员方法，称为静态成员方法，是类的方法，不是某个对象特有的。静态成员一般通过静态方法访问。 

特征：

1. 不属于具体的对象，是类方法。
2. 可以通过对象调用，但更推荐通过类名调用。
3. 不能在静态方法中访问任何非静态成员变量。
4. 静态方法中不能调用任何非静态方法，因为非静态方法中有this参数，在静态方法中调用时候无法传递this引用。
5. 静态方法无法重写，不能实现多态。

3、static成员变量初始化

        注意：静态成员变量一般不会放在构造方法中初始化，构造方法中初始化的是与对象有关的实例属性。

3.1就地初始化

        在定义时直接给出初始值。

3.2静态代码块初始化

        什么是静态代码块？看后续……

七、代码块

        使用 {} 定义的一段代码称为代码块。

1、普通代码块

        定义在方法中的代码块。不常用。

public class Main{     public static void main(String[] args) {         { //直接使用{}定义，普通方法块             int x = 10 ;             System.out.println("x1 = " +x);         }         int x = 100 ;         System.out.println("x2 = " +x);         }     }  // 执行结果 x1 = 10 x2 = 100

 2、构造代码块

        定义在类中的代码块（不加修饰符），也叫 实例代码块。一般用于初始化实例成员变量。

public class Student{     //实例成员变量     private String name;     private String gender;     private int age;     private double score;     public Student() {         System.out.println("I am Student init()!");     }     //实例代码块     {         this.name = "bit";         this.age = 12;         this.sex = "man";         System.out.println("I am instance init()!");     }     public void show(){         System.out.println("name: "+name+" age: "+age+" sex: "+sex);     } }  public class Main {     public static void main(String[] args) {         Student stu = new Student();         stu.show();     } }  // 运行结果 I am instance init()! I am Student init()! name: bit age: 12 sex: man

注意：

• 构造代码块（实例代码块）只有在创建对象时才会执行。 

3、静态代码块

        使用static定义的代码块。一般用于初始化静态成员变量。

public class Student{     private String name;     private String gender;     private int age;     private double score;     private static String classRoom;     //实例代码块     {         this.name = "bit";         this.age = 12;         this.gender = "man";         System.out.println("I am instance init()!");     }      // 静态代码块     static {         classRoom = "bit306";         System.out.println("I am static init()!");     }      public Student(){     System.out.println("I am Student init()!");     }      public static void main(String[] args) {     Student s1 = new Student();     Student s2 = new Student();     } }

注意：

• 静态代码块不管生成多少个对象，其只会执行一次。
• 静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的。
• 如果一个类中有多个静态代码块，在编译代码时，编译器会按照定义的顺序依次执行（合并）。

八、内部类

1、成员内部类

         在外部类中，内部类定义位置与外部类成员所处位置相同，因此称为成员内部类。

1.1 实例内部类

        未被static修饰的成员内部类。

注意：

• 外部类中的任何成员都可以在实例内部类方法中直接访问；
• 实例内部类所处位置与与外部类成员位置相同，因此也受public、private等访问限定符的约束；
• 在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须用 外部类名称.this.同名成员 来访问；
• 实例内部类对象必须在先有外部类对象前提下才能创建；

  // 创建实例内部类对象 OutClass.InnerClass innerClass1 = new OutClass().new InnerClass();  // 上述语法比较怪异，也可以先将外部类对象先创建出来，然后再创建实例内部类对象 OutClass.InnerClass innerClass2 = outClass.new InnerClass();

• 实例内部类的非静态方法中包含了一个指向外部类对象的引用；
• 外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象。

1.2 静态内部类 

        被static修饰的内部成员类。

注意：

• 在静态内部类中只能访问外部类中的静态成员。
• 创建静态内部类对象时，不需要先创建外部类对象。

2、局部内部类

         定义在外部类的方法体或者 {} 中，该种内部类只能在其定义的位置使用，一般使用的非常少。

注意：

• 局部内部类只能在所定义的方法体内部使用；
• 不能被public、static等修饰符修饰；
• 编译器也有自己独立的字节码文件，命名格式：外部类名字$数字内部类名字.class。

3、匿名内部类