面向对象的三大特征：封装、继承、多态

封装

对象代表什么，就得封装对应的数据，并提供数据对应的行为。

private关键字

是一个权限修饰符，被修饰的成员变量只能在本类中才能访问

对于被private修饰的成员变量，如需被其他类使用，要提供相应的操作

1
2
public void setxxx(参数){}
public 数据类型 getxxx(){}
this关键字

用来区分成员变量和局部变量

本质：代表当前方法调用者的地址值
->成员变量与局部变量重名时，遵循就近原则

1
this.属性
构造方法（构造器、构造函数）

在创建对象时给成员变量进行初始化

如果没有定义构造方法，系统将给出一个默认的无参构造；反之则不提供。

一般手动两种都写

格式：

1
2
3
4
5
6
修饰符 类名(){
	方法体;
}
修饰符 类名(参数){
	方法体;
}

特点：

  1. 方法名与类名完全相同
  2. 没有返回值类型，连void也没有
  3. 没有具体的返回值（不能由return带回结果数据）

执行时机：

  1. 创建对象时由虚拟机调用，不能手动调用
  2. 每创建一次对象，就会调用一次构造方法

标准Javabean类

要求 and 步骤：

  1. 类名需要见名知意
  2. 成员变量用private修饰
  3. 提供至少两个构造方法
    · 无参构造方法
    · 带全部参数的构造方法
  4. 成员方法
    · 提供每一个成员变量对应的`setXxx()/getXxx()
    · 如果还有其他行为，也需要写上

快捷键：**==ALT + Insert==**

基本数据类型

变量中存储的是真实的数据值，数据值存储在自己的空间中

引用数据类型

变量存储的是地址值，使用其他空间的数据；赋值给其他变量，赋的是地址值。

static

  1. 被static修饰的成员变量，叫做静态变量

    核心：共享

    1. 特点：被该类所有对象共享；不属于对象，属于类；随着类的加载而加载，优先于对象存在
    2. 调用方式：类名调用（推荐）、对象名调用

  2. 被static修饰的成员方法，叫做静态方法

    1) 特点：多用在测试类和工具类中，Javabean类中很少会用
2) 调用方式：类名调用（推荐）、对象名调用
类 功能
JavaBean类 用来描述一类事物的类。比如Student，Teacher，Dog等
测试类 用来检查其他类是否书写正确，带有main方法的类，是程序的入口
工具类 不是用来描述一类事物，而是帮我们做一些事情的类
格式化代码：CTRL+ALT+L
工具类

私有化构造方法–不让创建对象
静态方法

static注意事项

总结：静态方法中，只能访问静态。 //静态方法不能调用非静态的成员变量–不在静态区
非静态方法可以访问所有。
静态方法中没有 this 关键字。 //共享，跟某一个对象没什么关系

静态区在堆中

继承
1
public class 子类 extends 父类{}

–>什么时候用？
当类与类之间，存在相同（共性）的内容，并满足子类是父类的一种

–>特点：Java只支持单继承，不支持多继承，但支持多层继承

单继承：一个子类只能继承一个父类
不支持多继承：子类不能同时继承多个父类
多层继承：子类A继承父类B，父类B可以继承父类C

每一个类都直接或间接继承于Object类。

画图：从下往上 —- 写代码：从上往下

子类能继承父类中的哪些内容？

内容 非私有 private
构造方法 不能 不能
成员变量 能 能(不能用)
成员方法 (虚方法表)能 (否则)不能
只有父类中的虚方法才能被子类继承（非private、非static、非final

继承中成员变量访问特点：==就近原则==
局部 -> 本类成员 -> 父类成员

出现重名的成员变量：

1
2
3
System.out.println(name); //从局部位置开始往上找
System.out.println(this.name); //从本类成员位置开始往上找
System.out.println(super.name); //从父类成员位置开始往上找

继承中成员方法访问特点：this就近原则，super直接找父类

方法的重写
在继承体系中，子类出现了和父类一模一样的方法声明，我们就称子类这个方法是重写的方法。
只有被添加到虚方法表中的方法才能被重写。
@Override重写注解
–放在重写后的方法上，校验子类重写时语法是否正确。
–加上注解后如果有红色波浪线，表示语法错误。
–建议重写方法都加@Override注解

继承中构造方法访问特点：
子类不能继承父类的构造方法，但可以通过super调用
子类构造方法的第一行，有一个默认的super();
子类中所有构造方法默认先访问父类中的无参构造，再执行自己
如果想要访问父类有参构造，必须手动书写

多态

同类型的对象，表现出不同的形态

表现形式：

1
2
父类类型 对象名称 = 子类对象;
Person p = new Student();

前提：
有继承关系、有父类引用指向子类对象、有方法重写

好处：
使用父类作为参数，可以接受所有子类对象

调用成员的特点：

  1. 调用成员变量：编译看左边，运行也看左边 （父类
  2. 调用成员方法：编译看左边，运行看右边

弊端：
不能调用子类的特有功能
解决方法：自动类型转换（大转小）、强制类型转换（小转大）
用 instanceof 关键字进行判断

包

文件夹，用来管理不同功能的Java类

final

修饰方法：表明该方法是最终方法，不能被重写
修饰类：表明该类是最终类，不能被继承
修饰变量：叫做常量，只能被赋值一次
>基本类型：数据值不能发生改变
>引用类型：地址值不能发生改变，内部的属性值可以修改

权限修饰符的分类
修饰符 同一个类中 同一个包中其他类 不同包下的子类 不同包下的无关类
private √
空着不写 √ √
protected √ √ √
public √ √ √ √
代码块

大括号

局部代码块：方法内

构造代码块：每创建一次对象就执行一次

静态代码块：
格式：static{}
特点：需要通过static关键字修饰，随着类的加载而加载，并且自动触发，只执行一次
使用场景：在类加载的时候，做一些数据初始化时使用

抽象类和抽象方法
接口

异常

在Java中，异常（Exception）分为两大类：受检查异常（Checked Exception）和未检查异常（Unchecked Exception）。这两种异常在处理方式和用法上有所不同。

受检查异常（Checked Exception）

受检查异常是指在编译时由编译器强制检查的异常。这类异常通常是由于外部原因引起的，如文件未找到、网络连接失败、数据库访问错误等。受检查异常需要显式地进行处理，即必须使用try-catch块捕获异常，或者在方法签名中使用throws关键字声明抛出该异常。

常见的受检查异常：

  • IOException
  • SQLException
  • ClassNotFoundException

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class CheckedExceptionExample {
    public static void main(String[] args) {
        try {
            File file = new File("somefile.txt");
            FileInputStream fis = new FileInputStream(file);
        } catch (FileNotFoundException e) {
            System.out.println("File not found: " + e.getMessage());
        } catch (IOException e) {
            System.out.println("IO error: " + e.getMessage());
        }
    }
}

在这个例子中，FileNotFoundException和IOException都是受检查异常，必须使用try-catch块来处理。

未检查异常（Unchecked Exception）

未检查异常包括运行时异常（RuntimeException）及其子类和错误（Error）及其子类。这类异常通常是由编程错误引起的，如数组越界、空指针引用、算术错误等。未检查异常不要求在编译时强制捕获或声明抛出，可以选择不处理它们。未检查异常在运行时可能会终止程序的正常执行。

常见的未检查异常：

  • NullPointerException
  • ArrayIndexOutOfBoundsException
  • ArithmeticException
  • IllegalArgumentException

示例代码：

1
2
3
4
5
6
7
public class UncheckedExceptionExample {
    public static void main(String[] args) {
        int[] array = {1, 2, 3};
        System.out.println(array[3]); // ArrayIndexOutOfBoundsException
    }
}

总结：

  • 受检查异常需要显式地捕获或声明处理。
  • 未检查异常不要求显式处理，但在运行时可能会导致程序终止。