【Java】类和对象知识

目录

类和对象的基础知识

命名规则

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

this引用

1. 为什么要有this引用

2. 什么是this引用

3. this引用的特性

对象的构造及初始化

1. 如何初始化对象

2. 构造方法

3. 默认初始化

4. 就地初始化

static成员

static修饰成员变量

static修饰成员方法

static成员变量初始化

代码块

1. 代码块概念以及分类

2. 普通代码块

3. 构造代码块

4. 静态代码块

内部类

1. 内部类的分类

2. 实例内部类

3. 静态内部类

4. 局部内部类

对象的打印

类和对象的三大特性

封装

作用

访问限定符

封装扩展之包

包的概念

导入包中的类

自定义包

常见的包

继承

1. 为什么需要继承？

2. 继承概念

3. 父类成员访问

super关键字

4. 子类构造方法

5. 再谈初始化

6. protected 关键字

7. 继承方式

8. final 关键字

多态

1. 多态概念

2. 实现多态的条件

3. 重写

---

类和对象的基础知识

命名规则

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

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

• 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 方法, 就会编译报错, 提示无法构成重写.