【Java】类和对象知识

类和对象的基础知识

命名规则

• 类名统一使用大驼峰
• 方法和成员变量统一使用小驼峰

定义一个类的时候注意的事项

• 1. 一般一个文件当中只定义一个类
• 2. main方法所在的类一般要使用public修饰(注意：Eclipse默认会在public修饰的类中找main方法)
• 3. public修饰的类必须要和文件名相同
• 4. 不要轻易去修改public修饰的类的名称

this引用

1. 为什么要有this引用

• 防止形参和成员变量名字相同
• 绑定多调用的具体对象

2. 什么是this引用

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

注意：this引用的是调用成员方法的对象

3. this引用的特性

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

对象的构造及初始化

1. 如何初始化对象

• 在Java方法内部定义一个局部变量时，必须要初始化，否则会编译失败。

  public static void main(String[] args) {
    int a;
    System.out.println(a);
  }
  // Error:(26, 28) java: 可能尚未初始化变量a

• 成员不需要初始化也可以编译通过，这是因为类在创建一个对象的时候，会给成员变量给一个特定的值

2. 构造方法

构造方法(也称为构造器)是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次。

特性

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

3. 默认初始化

问题：为什么局部变量在使用时必须要初始化，而成员变量可以不用呢？

要搞清楚这个过程，就需要知道 new 关键字背后所发生的一些事情：

在程序层面只是简单的一条语句，在JVM层面需要做好多事情，下面简单介绍下：

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

4. 就地初始化

注意：代码编译完成后，编译器会将所有给成员初始化的这些语句添加到各个构造函数中

static成员

static修饰成员变量

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

【静态成员变量特性】

• 1. 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中
• 2. 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问
• 3. 类变量存储在方法区当中
• 4. 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)

static修饰成员方法

被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的

【静态方法特性】

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

static成员变量初始化

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

静态成员变量的初始化分为两种：就地初始化 和 静态代码块初始化。

• 1. 就地初始化        
  • 就地初始化指的是：在定义时直接给出初始值

代码块

1. 代码块概念以及分类

使用 {} 定义的一段代码称为代码块。根据代码块定义的位置以及关键字，又可分为以下四种：

• 普通代码块
• 构造块
• 静态块
• 同步代码块（后续讲解多线程部分再谈）

2. 普通代码块

普通代码块：定义在方法中的代码块。

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);
    }
}

这种用法较少见

3. 构造代码块

构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量。

class Student {
    //实例成员变量
    private String name;
    private String gender;
    private String sex;
    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

4. 静态代码块

使用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加载类时开辟空间并初始化的
• 如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)
• 实例代码块只有在创建对象时才会执行

内部类

内部类出现的意义

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

内部类的定义

在 Java 中，可以将一个类定义在另一个类或者一个方法的内部，前者称为内部类，后者称为外部类。内部类也是封装的一种体现。

【注意事项】

• 1. 定义在class 类名{}花括号外部的，即使是在一个文件里，都不能称为内部类
• 2. 内部类和外部类共用同一个java源文件，但是经过编译之后，内部类会形成单独的字节码文件

1. 内部类的分类

根据内部类定义的位置不同，一般可以分为以下几种形式：

• 1. 成员内部类
  • 普通内部类：未被static修饰的成员内部类
  • 静态内部类：被static修饰的成员内部类
• 2. 局部内部类(不谈修饰符)、匿名内部类

注意：内部类其实日常开发中使用并不是非常多，大家在看一些库中的代码时候可能会遇到的比较多，日常开始中使用最多的是匿名内部类。

2. 实例内部类

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

注意事项：

• 1. 外部类中的任何成员都可以在实例内部类方法中直接访问
• 2. 实例内部类所处的位置与外部类成员位置相同，因此也受public、private等访问限定符的约束
• 3. 在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名称.this.同名成员 来访问
• 4. 实例内部类对象必须在先有外部类对象前提下才能创建
• 5. 实例内部类的非静态方法中包含了一个指向外部类对象的引用
• 6. 外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象。

3. 静态内部类

被static修饰的内部成员类称为静态内部类。

【注意事项】

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

4. 局部内部类

【注意事项】

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

对象的打印

public class Person {
    String name;
    String gender;
    int age;

    public Person(String name, String gender, int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
    }

    public static void main(String[] args) {
        Person person = new Person("Jim", "男", 18);
        System.out.println(person);
    }
}
// 打印结果：day20210829.Person@1b6d3586

如果想要默认打印对象中的属性该如何处理呢？答案：重写toString方法即可。

public class Person {
  String name;
  String gender;
  int age;
  public Person(String name, String gender, int age) {
    this.name = name;
    this.gender = gender;
    this.age = age;
 }
  @Override
  public String toString() {
    return "[" + name + "," + gender + "," + age + "]";
 }
  public static void main(String[] args) {
    Person person = new Person("Jim","男", 18);
    System.out.println(person);
 }
}
// 输出结果：[Jim,男,18]

类和对象的三大特性

封装

作用

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

访问限定符

作用：访问权限用来控制方法或者字段能否直接在类外使用

【Java提供的四个访问限定符号如下】

【说明】

• protected主要是用在继承中
• default权限指：什么都不写时的默认权限
• 访问权限除了可以限定类中成员的可见性，也可以控制类的可见性

封装扩展之包

包的概念

为了更好的管理类，把多个类收集在一起成为一组，称为软件包。

比如：为了更好的管理电脑中的歌曲，一种好的方式就是将相同属性的歌曲放在相同文件下，也可以对某个文件夹下的音乐进行更详细的分类。

导入包中的类

• 使用 import语句导入包.
• 可以使用import static导入包中静态的方法和字段
• 注意事项:  import 和 C++ 的  #include 差别很大. C++ 必须  #include 来引入其他文件内容, 但是 Java 不需要.import 只是为了写代码的时候更方便.  import 更类似于 C++ 的  namespace 和  using

自定义包

基本规则

• 在文件的最上方加上一个 package 语句指定该代码在哪个包中.
• 包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如  com.zxj.demo1 ).
• 包名要和代码路径相匹配. 例如创建  com.zxj.demo1 的包, 那么会存在一个对应的路径  com/zxj/demo1 来存储代码
• 如果一个类没有 package 语句, 则该类被放到一个默认包中.

常见的包

• 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编程开发包。

继承

1. 为什么需要继承？

面向对象思想中提出了继承的概念，专门用来进行共性抽取，实现代码复用。

2. 继承概念

继承(inheritance)机制：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特 性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用。

Java继承语法

在Java中如果要表示类之间的继承关系，需要借助extends关键字，具体如下：

修饰符 class 子类 extends 父类 {
 // ... 
}

3. 父类成员访问

子类中访问父类的成员变量

• 1. 子类和父类不存在同名成员变量 -- 可以直接访问
• 2. 子类和父类成员变量同名 -- 访问顺序如下
  • 如果访问的成员变量子类中有，优先访问自己的成员变量。
  • 如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。
  • 如果访问的成员变量与父类中成员变量同名，则优先访问自己的。
  • 成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。
• 3. 子类中访问父类的成员方法
  • 注意：通过派生类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用方法适传递的参数选择合适的方法访问，如果没有则报错；

super关键字

• 问题：由于设计不好，或者因场景需要，子类和父类中可能会存在相同名称的成员，如果要在子类方法中访问父类同名成员时，该如何操作？
• 解决方法：直接访问是无法做到的，Java提供了super关键字，该关键字主要作用：在子类方法中访问父类的成员。

【注意】

• 只能在非静态方法中使用
•  在子类方法中，访问父类的成员变量和方法

4. 子类构造方法

父子父子，先有父再有子，即：子类对象构造时，需要先调用基类构造方法，然后执行子类的构造方法。

• 1. 若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用基类构造方法
• 2. 如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。
• 3. 在子类构造方法中，super(...)调用父类构造时，必须是子类构造函数中第一条语句。
• 4. super(...)只能在子类构造方法中出现一次，并且不能和this同时出现

super和this

【相同点】

• 1. 都是Java中的关键字
• 2. 只能在类的非静态方法中使用，用来访问非静态成员方法和字段
• 3. 在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在

【不同点】

• 1. this是当前对象的引用，当前对象即调用实例方法的对象，super相当于是子类对象中从父类继承下来部分成员的引用
• 2. 在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性
• 3. 在构造方法中：this(...)用于调用本类构造方法，super(...)用于调用父类构造方法，两种调用不能同时在构造方法中出现
• 4. 构造方法中一定会存在super(...)的调用，用户没有写编译器也会增加，但是this(...)用户不写则没有

5. 再谈初始化

• 1、父类静态代码块优先于子类静态代码块执行，且是最早执行
• 2、父类实例代码块和父类构造方法紧接着执行
• 3、子类的实例代码块和子类构造方法紧接着再执行
• 4、第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行

6. protected 关键字

不同包的子类访问protected成员

7. 继承方式

一般我们不希望出现超过三层的继承关系

8. final 关键字

final关键可以用来修饰变量、成员方法以及类。

修饰变量或字段，表示常量(即不能修改) -- 和C++中的const关键字类似

• 关键：final修饰的变量只能初始化一次

修饰类：表示此类不能被继承

修饰方法：表示该方法不能被重写

多态

1. 多态概念

具体点就是去完成某个行为，当不同的对象去完成时会产生出不同 的状态。

2. 实现多态的条件

1. 必须在继承体系下
2. 子类必须要对父类中方法进行重写
3. 通过父类的引用调用重写的方法

3. 重写

【不能重写的场景】

• 父类静态成员
• private修饰
• final修饰
• 构造方法

【方法重写规则】

• 子类在重写父类的方法时，一般必须与父类方法原型一致： 返回值类型 方法名 (参数列表) 要完全一致
• 被重写的方法返回值类型可以不同，但是必须是具有父子关系的 -- 协变
• 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类方法被public修饰，则子类中重写该方法就不能声明为 protected
• 父类被static、private修饰的方法、构造方法都不能被重写。
• 重写的方法, 可以使用  @Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验. 例如不小心将方法名字拼写错了 (比如写成 aet), 那么此时编译器就会发现父类中没有 aet 方法, 就会编译报错, 提示无法构成重写.