KuangStudy 狂神说 JavaSE 学习笔记

于 2022-11-04 13:15:30 发布
阅读量422 收藏 1
点赞数
CC 4.0 BY-SA版权
文章标签： 学习 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/firemarks/article/details/127686889
这篇博客详细介绍了JavaSE的基础知识，包括注释、标识符和关键字、数据类型、运算符、流程控制、方法、数组、面向对象的概念和特性。内容涵盖变量、常量、类型转换、包机制、异常处理等方面，深入浅出地讲解了Java编程的核心概念。此外，还探讨了方法的定义、调用、重载以及类和对象的关系，强调了封装、继承和多态的重要性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

JavaSE

基础

基础 01 注释

  1. 单行注释

    • // 单行注释

  2. 多行注释

    • /*
	多行注释
*/

  3. 文档注释

    • /**
*@Description Hello World
*@Author 
*/

基础 02 标识符、关键字

  1. 关键字

    • abstract; boolean; break; byte; case; catch; char; class; continue; default; do; double; else; extends; false; final; finally; float; for; if; implements; import; instanceof; int; interface; long; native; new; null; package; private; protected; public; return; short; static; super; switch; synchronized; this; throw; throws; transient; true; try; void; volatile; while

    • 在这里插入图片描述

  2. 标识符

    • 规则见[Java开发手册（黄山版）.pdf]

基础 03 数据类型

  1. 基本数据类型

    • 数值类型

      • 整数类型

        • byte占 1 个字节，min：-128（-27）max：127（27-1）
        • short占 2 个字节，min：-32768（-215）max：32767（215-1）
        • int占 4 个字节，默认值 0，min：-2,147,483,648（-231）max：2,147,483,647（231-1）
        • long占 8 个字节，min：-9,233,372,036,854,775,808（-263）max：9,223,372,036,854,775,807（263-1）

      • 浮点类型

        • float占 4 个字节
        • double占 8 个字节

      • 字符类型

        • char占 2 个字节，默认值null

    • boollean类型：占 1 位，其值只有true和false两个，默认值false

  2. 引用数据类型

    • 类
    • 接口
    • 数组

基础 04 数据类型拓展

  1. 整数

    • 二进制 0b
    • 十进制
    • 八进制 0
    • 十六进制 0x

  2. 浮点数

    • 最好完全避免使用浮点数进行比较
    • 银行业务怎么表示？ ==> BigDecimal 数学工具类

  3. 字符

    • 所有字符的本质还是数字
    • 编码 Unicode 表：（97 = a 65 = A）
    • 2 字节 65536
    • U0000 UFFFF

  4. 转义字符

    • \t 制表符
    • \n 换行符
    • \a 响铃
    • \b 退格
    • \f 换页
    • \r 回车
    • \v 垂直制表
    • \\ 反斜线字符
    • \’ 单引号(撇号)字符
    • \" 双引号字符
    • \0 空字符

基础 05 类型转换

低 -----------------------------------------------------------------------> 高
byte -> short, char -> int -> long -> float -> double

  1. 强制类型转换

    • （类型）变量名 高 --> 低

  2. 自动类型转换

    • 低 --> 高

  3. 注意点

    • 不能对布尔值进行转换

    • 不能把对象类型转换为不相干的类型

    • 在把高容量转换到低容量的时候，强制转换

    • 转换的时候可能存在内存溢出，或者精度问题

    • //JDK7新特性，数字之间可以用下划线分割
int money = 10_0000_0000;
int years = 20;
int total = money*years; // -1474836480，计算的时候溢出了
long total2 = money*years; // 还是-1474836480，因为右边还是int类型，转换之前已经存在问题了
long total3 = money*((long)years); // 2000000000，先把一个数转换为long，则全部转换为long

基础 06 变量、常量、作用域

  1. 变量

    • 类变量

    • 实例变量（从属于对象）

    • 局部变量（从属于方法，必须声明和初始化值）

    • public class Variable {
    static int allClick = 0;	//类变量
    String str = "Hello world";	//实例变量
    public void method() {
        int i = 0;	//局部变量
    }
}

  2. 常量（Constant）

    • 初始化（initialize）后不能再改变值

    • 常量名一般使用大写字符

    • final double PI = 3.14;

  3. 命名规范

    • 所有变量、方法、类名：见名知意
    • **类成员变量：**首字母小写和驼峰原则：monthSalary
    • **局部变量：**首字母小写和驼峰原则
    • **常量：**大写字母和下划线：MAX_VALUE
    • **类名：**首字母大写和驼峰原则：Man，GoodMan
    • **方法名：**首字母小写和驼峰原则：run()，runRun()

基础 07 运算符

  1. 算术运算符 +, -, *, /, %, ++, –

    • int以下精度运算（short，byte），结果自动转化为int

    • 幂运算 2^3

    • double pow = Math.pow(2,3);

  2. 赋值运算符 =

  3. 关系运算符 >, <, >=, <=, ==, !=, instanceof

  4. 逻辑运算符 &&, ||, !

    • 注意短路运算

    • boollean a = true;
boollean b = false;
System.out.println(a && b);	//false，先执行判断a，后执行判断b
System.out.println(b && a);	//false，先执行判断b，直接短路，不执行判断a

  5. 位运算符 &, |, ^, ~, >>, <<, >>>

    • &, |, ~, ^：位运算的与，或，非，异或

    • A = 0011 1100
B = 0000 1101
A & B	//与，0000 1100
A | B	//或，0011 1101
A ^ B	//异或，0011 0001
~ B    //非，1111 0010

    • 2 × 8 最快运算方法？

      • <<左移，相当于 × 2

      • >>右移，相当于 ÷ 2

      • System.out.println(2 << 3);

  6. 条件运算符 ? :

  7. 扩展赋值运算符 +=, -=, *=, /=

基础 08 包机制

  • 为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。

  • 包语句的语法格式为：

    • package pkg1[. pkg2[. pkg3...]];

  • 一般利用公司域名倒置作为包名；

  • 为了能够使用某一个包的成员，需要在Java程序中明确导入该包，使用import语句可完成此功能：

    • import package1[. package2...].(classname|*);

基础 09 javadoc生成文档

  • javadoc命令是用来生成自己 API 文档的
  • 参数信息
    • @author作者名
    • @version版本号
    • @since指明需要最早使用的jdk版本
    • @param参数名
    • @return返回值情况
    • @throws异常抛出情况

流程控制

流程控制 01 用户交互Scanner

  • 基本语法

    • Scanner scanner = new Scanner(System.in);

  • 通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。

    • import java.util.Scanner;
public class Hello {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用next方式接收：");
        if(scanner.hasNext()){
            String str = scanner.next();
            System.out.println("输入的内容为："+str);
        }
        // 凡是属于IO流的类如果不关闭会一直占用资源，应该使用完就关掉。
        scanner.close();
    }
}

  • next()：

    • 一定要读取到有效字符后才可以结束输入
    • 对输入有效字符之前遇到的空白，next()方法会自动将其去掉
    • 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符
    • next()不能得到带有空格的字符串

  • nextLine()：

    • 以 Enter 为结束符，也就是说nextLine()方法返回的是输入回车之前的所有字符
    • 可以获得空格

流程控制 02 Scanner进阶使用

  1. 输入整数

    • import java.util.Scanner;
public class Hello {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int i;
        if (scanner.hasNextInt()) {
            i = scanner.nextInt();
            System.out.println(i);
        } else {
            System.out.println("输入的不是整数。");
        }
        scanner.close();
    }
}

  2. 输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果

    • import java.util.Scanner;
public class Hello {
    public static void main(String[] args) {
        double sum = 0.0D;
        int m = 0;
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextDouble()) {
            sum += scanner.nextDouble();
            m++;
        }
        System.out.println("总和为：" + sum + "\n平均数为：" + sum / m);
        scanner.close();
    }
}

流程控制 03 顺序结构

  • Java 的基本结构就是顺序结构，除非特别指明，否则就按顺序逐句执行

流程控制 04 if选择结构

  1. if单选择结构

    • if (布尔表达式) {
    // 如果布尔表达式的值为 true 执行代码
}

  2. if双选择结构

    • if (布尔表达式) {
    // 如果布尔表达式的值为 true 执行代码
} esle {
    // 如果布尔表达式的值为 false 执行代码
}

  3. if多选择结构

    • // 一旦其中一个 else if 语句检测为 true，其他的 else if 以及 else 语句都将跳过执行
if (布尔表达式 1) {
    // 如果布尔表达式 1 的值为 true 执行代码
} esle if (布尔表达式 2) {
    // 如果布尔表达式 2 的值为 true 执行代码
} esle if (布尔表达式 3) {
    // 如果布尔表达式 3 的值为 true 执行代码
} esle {
    // 如果以上布尔表达式的值均为 false 执行代码
}

  4. 嵌套的if结构

    • if (布尔表达式 1) {
    // 如果布尔表达式 1 的值为 true 执行代码
    if(布尔表达式 2) {
        // 如果布尔表达式 2 的值为 true 执行代码
    }
}

流程控制 05 switch多选择结构

  • switch语句中的变量类型可以是byte、short、int或者char

  • 从 Java SE 7 开始，switch支持字符串String类型了，同时case标签必须为字符串常量或字面量

    • switch (expression) {
	case value:
	// 语句
	break; // 可选
	case value:
	// 语句
	break; // 可选
	default: // 可选
	// 语句
}

  • case穿透现象：从满足条件的case value开始，执行后面所有的case，直到遇到 break停止

流程控制 06 while循环

  • while是最基本的循环，其结构为：

    • while (布尔表达式) {
	// 循环内容
}

  • 只要布尔表达式为true循环就会一直执行下去

  • 大多数情况会让循环停止下来，需要一个让表达式失效的方式来结束循环

  • 少部分情况需要循环一直执行，比如服务器的请求响应监听等

流程控制 07 do…while 循环

  • 对于while语句而言，如果不满足条件，则不能进入循环

  • do…while循环和while循环相似，不同的是，do…while循环至少会执行一次

    • do {
	// 代码语句
} while (布尔表达式);

流程控制 08 for循环

  • for循环执行的次数在执行前就确定，语法格式如下：

    • for (初始化;布尔表达式;更新) {
    // 代码语句
}

  • IDEA 快捷键：100.for后回车，自动生成：

    • for (int i = 0; i < 100; i++) {

}

  • 练习1：计算0到100之间的奇数和偶数的和

    • public static void main(String[] args) {
    int oddsum = 0;
    int evensum = 0;
    for (int i = 0; i < 100; i++) {
        if (i % 2 != 0) {
            oddsum += i;
        } else {
            evensum += i;
        }
    }
    System.out.println("奇数的和：" + oddsum);
    System.out.println("偶数的和：" + evensum);
}

  • 练习2：用while或for循环输出 1-1000 之间能被 5 整除的数，每行输出 3 个

    • public static void main(String[] args) {
    for (int i = 1; i < 1000; i++) {
        if (i % 5 == 0) {
            System.out.print(i + "\t");
        }
        if (i % 15 == 0) {
            System.out.println();
        }
    }
}

  • 练习3：打印九九乘法表

    • public static void main(String[] args) {
    for (int i = 1; i <= 9; i++) {
        for (int j = 1; j <= i; j++) {
            System.out.print(j+"×"+i+"="+j*i+"\t");
        }
        System.out.println();
    }
}

流程控制 09 增强for循环

  • Java 5 引入了一种主要用于数组或集合的增强型for循环

  • Java 增强for循环语法格式如下：

    • for (声明语句 : 表达式)
{
    // 代码句子
}

  • 声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

  • 表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

    • public static void main(String[] args) {
    int[] numbers = {10, 20, 30, 40, 50};
    for (int x : numbers) {
        System.out.println(x);
    }
}

流程控制 10break、continue、goto

  • 在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。

    • public static void main(String[] args) {
    int i = 0;
    while (i < 100) {
        i++;
        System.out.println(i);
        if (i == 30) {
            break; // 打破 while 循环，至此只输出到 30
        }
    }
    System.out.println("123"); // 证明只是打破 while 循环，函数仍在执行。
}

  • continue用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

    • public static void main(String[] args) {
    int i = 0;
    while (i < 100) {
        i++;
        if (i % 10 == 0) {
            System.out.println();
            continue; // 后面输出 i 不执行，直接进入下一次 while 循环
        }
        System.out.print(i);
    }
}

  • 关于goto关键字

    • goto关键字很早就在程序设计语言中出现。尽管goto仍是 Java 的一个保留字，但并未在语言中得到正式使用 —— Java 没有goto。然而，在break和continue这两个关键字的身上，我们仍能看出一些goto的影子 —— 带标签的break和continue。例如label:

    • // 输出 101 到 150 之间的质数
public static void main(String[] args) {
    outer: for (int i = 101; i < 150; i++) {
        for (int j = 2; j < i/2; j++) {
            if (i % j == 0) {
                continue outer; // 直接跳转到 outer:
            }
        }
        System.out.print(i + " ");
    }
}

  • 对 Java 来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一个循环，由于break和continue关键字通常只中断当前循环，但若随同标签使用，它们就会终端到存在标签的地方。

流程控制 12 打印三角形及菱形

  • 打印三角形

    • import java.util.Scanner;
public class Hello {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n-i-1; j++) {
                System.out.print(" ");
            }
            for (int j = 0; j < 2*i+1; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

  • 打印菱形

    • import java.util.Scanner;
public class Hello {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        for (int i = 0; i < 2*n-1; i++) {
            if (i < n) {
                for (int j = 0; j < n-i-1; j++) {
                    System.out.print(" ");
                }
                for (int j = 0; j < 2*i+1; j++) {
                    System.out.print("*");
                }
            } else {
                for (int j = 0; j < i-n+1; j++) {
                    System.out.print(" ");
                }
                for (int j = 0; j < 4*n-2*i-3; j++) {
                    System.out.print("*");
                }
            }
            System.out.println();
        }
    }
}

方法

方法 01 什么是方法

  1. Java 方法是语句的集合，它们在一起执行一个功能
    • 方法是解决一类问题的步骤的有序组合
    • 方法包含于类或对象中
    • 方法在程序中被创建，在其他地方被引用
  2. 设计方法的原则：
    • 方法的本意是功能块，即实现某个功能的语句块的集合
    • 最好保持方法的原子性， 即一个方法只完成一个功能，以利于后期扩展
  3. 方法的命名规则：
    • 首字母小写驼峰原则

方法 02 方法的定义及调用

  1. 方法的定义

    • 修饰符：可选，告诉编译器如何调用该方法。定义了该方法的访问类型。

    • 返回值类型：returnValueType是方法返回值的数据类型。有些方法没有返回值，在此情况下，returnValueType是关键字void。

    • 方法名：方法的实际名称。方法名和参数表共同构成方法签名。

    • 参数类型：当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。

      • 形式参数

      • 实参

    • 方法体：包含具体的语句，定义该方法的功能。

    • 修饰符 返回值类型 方法名（参数类型 参数名） {
	……
	方法体
	……
	return 返回值;
}

  2. 方法调用

    • 调用方法：对象名.方法名（实参列表）

    • Java 支持两种调用方法的方式，根据方法是否返回值来选择

    • 当方法返回一个值的时候，方法调用通常被当作一个值

      • int larger = max(30, 40);

    • 如果方法返回值是void，方法调用一定是一条语句

      • System.out.println("Hello, world!");

    • 值传递（Java） 和 引用传递

方法 03 方法的重载

  • 重载就是在一个类中，有相同的函数名称，但形参不同的函数
  • 方法的重载规则：
    • 方法名称必须相同
    • 参数列表必须不同（个数不同、类型不同、参数排列顺序（需要形参类型不同为前提）不同等）
    • 方法的返回类型可以相同也可以不同
    • 仅仅返回类型不同不足以成为方法的重载
  • 实现理论
    • 方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。

方法 04 命令行传递参数

  • 运行一个程序时候再传递给它消息，需要靠传递命令行参数给main()方法实现

    • package method;
public class Demo03 {
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println("args[" + i + "]: " + args[i]);
        }
    }
}

    • D:\Coding\Java\Learning>javac Demo03
错误: 仅当显式请求注释处理时才接受类名称 'Demo03'
1 个错误

D:\Coding\Java\Learning>cd D:\Coding\Java\Learning\src\method

D:\Coding\Java\Learning\src\method>javac Demo03.java

D:\Coding\Java\Learning\src\method>java Demo03
错误: 找不到或无法加载主类 Demo03

D:\Coding\Java\Learning\src\method>cd..\

D:\Coding\Java\Learning\src>java method.Demo03

D:\Coding\Java\Learning\src>java method.Demo03 this is Enchant_sword
args[0]: this
args[1]: is
args[2]: Enchant_sword

D:\Coding\Java\Learning\src>

方法 05 可变参数（不定项参数）

  • JDK 1.5 开始，Java 支持传递同类型的可变参数给一个方法

  • 在方法声明中，在指定参数类型后加一个省略号（…）

  • 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

    • package method;
public class Demo04 {
    public static void main(String[] args) {
        // 调用可变参数的方法
        printMax(34,3,3,2,56.5);
        printMax(new double[] {1,2,3});
    }
    public static void printMax(double... numbers) {
        if (numbers.length == 0) {
            System.out.println("No argument passed");
            return;
        }
        double result = numbers[0];
        // 排序
        for (int i = 1; i < numbers.length; i++) {
            if (numbers[i] > result) {
                result = numbers[i];
            }
        }
        System.out.println("The max value is " + result);
    }
}

方法 06 递归

  • 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。

  • 递归体：什么时候需要调用自身方法。

    • package method;
public class Demo06 {
    public static void main(String[] args) {
        System.out.println(f(5));
    }
    public static int f(int n) {
        if (n == 1) { //递归头
            return 1;
        } else { //递归体，阶乘
            return n * f(n-1);
        }
    }
}

数组

数组 01 数组声明创建

  • 声明数组变量

    • dataTypep[] arrayRefVar; // 首选方法
或
dataTypep arrayRefVar[]; // 效果相同，但非首选方法

  • Java 使用new操作符来创建数组

    • dataTypep[] arrayRefVar = new dataType[arraySize];

  • 数组通过索引访问，数组索引从 0 开始

  • 获取数组长度：

    • arrays.length

    • package array;
public class Demo01 {
    public static void main(String[] args) {
        int[] nums; // 1.声明1个数组
        nums = new int[10]; // 2.创建1个数组
        nums[0] = 1; // 3.给数组中元素赋值
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;
        nums[5] = 6;
        nums[6] = 7;
        nums[7] = 8;
        nums[8] = 9;
        nums[9] = 10;
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            // 增强型 for 循环: for (int num : nums)
            sum += nums[i];
        }
        System.out.println("总和为：" + sum);
    }
}

数组 02 内存分析 及 三种初始化

  1. Java 内存分析：

    • 堆

      • 存放new的对象和数组
      • 可以被所有的线程共享，不会存放别的对象引用

    • 栈

      • 存放基本变量类型（会包含这个基本类型的具体数值）
      • 引用对象的变量（会存放这个引用在堆里面的具体地址）

    • 方法区

      • 可以被所有的线程共享
      • 包含了所有的class和static变量

  2. 三种初始化

    • 静态初始化

      • int[] a = {1,2,3,4,5,6,7,8};
Man[] men = {new Man(1,1), new Man(2,2)};

      • 动态初始化

        • int[] a = new int[2];
a[0] = 1;
a[1] = 2;

      • 数组的默认初始化

        • 数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

数组 03 下标越界 及 小结

  • 数组的四个基本特点

    1. 长度确定。数组一旦被创建，其长度不可改变。
    2. 数组元素必须是相同类型，不允许出现混合类型。
    3. 数组元素可以是任何数据类型，包括基本类型和引用类型。
    4. 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java 中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

  • 数组边界

    • 下标的合法区间：[0, length-1]，如果越界就会报错
    • ArrayIndexOutOfBoundsException：数组下标越界异常！

数组 04 数组的使用

  • 普通的for循环

  • for - each循环 （增强型for循环）

  • 数组作方法入参

  • 数组作返回值

    • package array;
public class Demo03 {
	public static void main(String[] args) {
		int[] arrays = {1,2,3,4,5};
		printArray(arrays);
		printArray(reverseArray(arrays));
	}
	// 打印数组元素（数组作方法入参）
	public static void printArray(int[] arrays) {
		// 普通的 for 循环
		for (int i = 0; i < arrays.length; i++) {
			// 增强的 for 循环：
			for (int i : arrays) {
				System.out.print(arrays[i] + " ");
			}
		}
	}
	// 反转数组（数组作返回值）
	public static int[] reverseArray(int[] arrays) {
		int[] result = new int[arrays.length];
		for (int i = 0; i < arrays.length; i++) {
			result[arrays.length - i - 1] = arrays[i];
		}
		return result;
	}
}

数组 05 多维数组

  • 多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组

  • 二维数组

    • // 可视作两行五列的数组
int a[][] = new int[2][5]

    • package array;
public class Demo04 {
    public static void main(String[] args) {
        // [4][2]
        int[][] array = {{1,2},{2,3},{3,4},{4,5}};
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

数组 06 Arrays类

  • Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而不用使用对象来调用（注意：是“不用”而非“不能”）

  • 具有以下常用功能：

    • 给数组赋值：通过fill方法

    • 对数组排序：通过sort方法，按升序

    • 比较数组：通过equals方法比较数组中元素值是否相等

    • 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作

    • package array;
import java.util.Arrays;
public class Demo05 {
    public static void main(String[] args) {
        int[] a = {4,7,23,534,76,334,2,56,67,33,45};
        // 数组升序排序
        Arrays.sort(a);
        // 转成字符串输出
        System.out.println(Arrays.toString(a));
        // 将数组下标[2]到下标[8-1]的元素用 0 填充
        Arrays.fill(a,2,8,0);
        // 转成字符串输出
        System.out.println(Arrays.toString(a));
    }
}

数组 07 冒泡排序

  • 嵌套循环，时间复杂度为 O(n^2)

    • package array;
import java.util.Arrays;
public class Demo06 {
	public static void main(String[] args) {
        int[] array = {3,5,756,23,5,4334,65,445,6,4,3,56};
        int[] sort = sort(array);
        System.out.println(Arrays.toString(sort));
    }
    public static int[] sort(int[] a) {
        // 临时变量
        int temp;
        // 外层循环，判断循环执行次数
        for (int i = 0; i < a.length - 1; i++) {
            // 内层循环，比较两个数大小，并互换位置
            for (int j = 0; j < a.length - 1 - i ; j++) {
                // 改为 < 则降序排序
                if (a[j] > a[j+1]) {
                    /*
                          核心代码，若不引入临时变量 temp，也可简化为
                          a[j] += a[j+1];
                          a[j+1] = a[j] - a[j+1];
                          a[j] -= a[j+1];
                       */
                    temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }
        return a;
    }
}

  • 优化算法

    • for (int i = 0; i < a.length - 1; i++) {
    // 放置标识位，减少无意义的比较
    boollean flag = false;
    for (int j = 0; j < a.length - 1 - i ; j++) {
        if (a[j] > a[j+1]) {
            temp = a[j];
            a[j] = a[j+1];
            a[j+1] = temp;
            // 只要发生过 1 次 if 交换，则 flag 赋值 true，后面继续比较
            flag = true;
        }
    }
    if (!flag) {
        break;
    }
}

数组 08 稀疏数组

  • 当一个数组中大部分元素为 0，或者为同一值时，可以使用稀疏数组来保存

  • 稀疏数组的处理方式是：

    • 记录数组一共有几行几列，有多少个不同值

    • 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

    • 原始数组：
      [000220015011000170000−6000000003909100000000280000] \left [ \begin{array}{c} 0 & 0 & 0 & 22 & 0 & 0 & 15 \\ 0 & 11 & 0 & 0 & 0 & 17 & 0 \\ 0 & 0 & 0 & -6 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 39 & 0 \\ 91 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 28 & 0 & 0 & 0 & 0 \\ \end{array} \right ] ⎣⎡​0000910​0110000​0000028​220−6000​000000​01703900​1500000​⎦⎤​

    • 稀疏数组：
      [行列值(row)(col)(value)[0]678[1]0322[2]0615[3]1111[4]1517[5]23−6[6]3539[7]4091[8]5228] \left [ \begin{array}{c|cc} & 行 & 列 & 值 \\ & (row) & (col) & (value) \\ \hline [0] & 6 & 7 & 8 \\ [1] & 0 & 3 & 22 \\ [2] & 0 & 6 & 15 \\ [3] & 1 & 1 & 11 \\ [4] & 1 & 5 & 17 \\ [5] & 2 & 3 & -6 \\ [6] & 3 & 5 & 39 \\ [7] & 4 & 0 & 91 \\ [8] & 5 & 2 & 28 \\ \end{array} \right ] ⎣⎡​[0][1][2][3][4][5][6][7][8]​行(row)600112345​列(col)736153502​值(value)822151117−6399128​​⎦⎤​

    • 原始数组和稀疏数组互相转换

      • package array;
public class Demo07 {
    public static void main(String[] args) {
        // 创建一个 11 * 11 的二维数组
        // 0：没有棋子  1：黑棋  2：白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        // 输出原始的数组（①使用 2 层增强型 for 循环）
        System.out.println("输出原始的数组");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }

        // 转换为稀疏数组保存
        // 1.获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array1[i][j] != 0) {
                    sum ++;
                }
            }
        }
        System.out.println("有效值的个数为：" + sum);
        // 2.创建一个稀疏数组的数组
        // 因第 0 行存放数组信息，稀疏数组行数为 sum + 1
        int[][] array2 = new int[sum + 1][3];
        // 列数固定为 3，分别为行坐标、列坐标、值
        array2[0][0] = array1.length;
        array2[0][1] = array1.length;
        array2[0][2] = sum;
        // 3.遍历二维数组，将非零的值存放于稀疏数组中
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j] != 0) {
                    count ++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }
        // 4.输出转换后的稀疏数组（②使用 1 层常规 for 循环）
        System.out.println("输出转换后的稀疏数组");
        for (int[] item : array2) {
            System.out.println(item[0] + "\t"
                               + item[1] + "\t"
                               + item[2] + "\t");
        }

        // 还原为原始数组
        System.out.println("还原为原始数组");
        int rowArray3 = array2[0][0];
        int colArray3 = array2[0][1];
        int countArray3 = array2[0][2];
        int[][] array3 = new int[rowArray3][colArray3];
        for (int i = 0; i < countArray3; i++) {
            int row = array2[i + 1][0];
            int col = array2[i + 1][1];
            int value = array2[i + 1][2];
            array3[row][col] = value;
        }
        // 输出还原后的原始数组（③使用 2 层常规 for 循环）
        for (int i = 0; i < array3.length; i++) {
            for (int j = 0; j < array3[i].length; j++) {
                System.out.print(array3[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

面向对象

面向对象 01 何为面向对象

  1. 面向过程 & 面向对象

    • 面向过程思想

      • 步骤清晰简单，第一步、第二步……

      • 适合处理较为简单的问题

      • 面向对象思想

        • 分类的思维模式，先思考解决问题需要哪些分类，然后对这些分类进行单独思考，最后才对某个分类的细节进行面向过程的思索。
        • 面向对象适合处理复杂的问题、需要多人协作的问题。

    • 描述复杂的事物，为从宏观上把握、从整体上分析，需要使用面向对象的思路。但具体到微观操作，仍需要面向过程的思路去处理。

  2. 何为面向对象

    • 面向对象编程（Object - Oriented Programming, OOP）

    • 面向对象编程的本质是：以类的方式组织代码，以对象的方式组织（封装）数据。

    • 抽象

      • 三大特性
        • 封装
        • 继承
        • 多态

    • 从认识论角度考虑，是先有对象后有类。对象是具体的事物；类是对对象的抽象。

    • 从代码运行角度考虑，是先有类后有对象。类是对象的模板。

面向对象 02 方法的定义

  • 修饰符
  • 返回类型
  • break和return的区别：break结束循环；return结束方法。
  • 方法名：驼峰原则、见名知意
  • 参数列表：（参数类型，参数名）…（可变参数）
  • 异常抛出

面向对象 03 方法的调用

  • 静态方法

    • package oop;
public class Demo02 {
    public static void main(String[] args) {
        // 调用静态方法
        // 类名.方法名
        Student.say1();
    }
}

  • 非静态方法

    • package oop;
public class Demo02 {
    public static void main(String[] args) {
        // 调用非静态方法
        // 对象类型 对象名 = new 对象值
        Student student = new Student();
        student.say2();
    }
}

  • 形参和实参

  • 值传递和引用传递

    • package oop;
// 值传递
public class Demo04 {
    public static void main(String[] args) {
        int a = 1;
        new Demo04().change(a);
        System.out.println(a); // 输出 a = 1，而非 a = 10
    }
    public void change(int a) {
        a = 10;
    }
}

    • package oop;
// 引用传递
public class Demo05 {
    public static void main(String[] args) {
        Person aaa = new Person();
        System.out.println(aaa.name);// 输出 null
        Demo05.change(aaa);
        System.out.println(aaa.name);// 输出 狗蛋
    }
    public static void change(Person bbb) {
        bbb.name = "狗蛋";
    }
}
// 定义了一个 Person 类，有一个属性：name
class Person {
    String name; // 默认初始值 null
}

    • 值传递

    • 引用传递

  • this关键字

    • this 关键字

    • this 内存原理

面向对象 04 类 与 对象

  1. 类与对象的关系

    • 类是一种抽象的数据类型，它是对某一类事物的整体描述 / 定义，但是并不能代表某一个具体的事物。

      • 动物、植物、手机、电脑……
      • Person 类、Pet 类、Car 类等，这些类都是用来描述 / 定义某一类具体的事物应该具备的特征

    • 对象是抽象概念的具体实例

      • “张三”是“人”的具体实例
        • 能体现出特点、展现出功能，而非抽象概念

  2. 创建与初始化对象

    • 使用new关键字创建对象

    • 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认初始化，以及调用类中构造器。

    • 类中构造器也称为构造方法，是创建对象时必须要调用的。构造器有以下特点：

      1. 必须和类的名字相同
      2. 必须没有返回类型，也不能写void
    • package oop.demo;
// 一个项目应该只存在一个 main 方法
public class Application {
    public static void main(String[] args) {
        // 类：抽象的，实例化
        // 类实例化后会返回一个自己的对象
        // goudan 对象就是一个 Student 类的具体实例
        Student goudan = new Student();
        goudan.name = "狗蛋";
        goudan.age = 3;
        System.out.println(goudan.name);
        System.out.println(goudan.age);
        new Student().study();
    }
}

    • package oop.demo;
// 学生类
public class Student {
    // 属性：字段
    String name;
    int age;
    // 方法
    public void study() {
        System.out.println(this.name + "在学习");
    }
}

面向对象 05 构造器详解

  • 构造器：

    1. 和类名相同
    2. 没有返回值

  • 作用：

    1. new（本质在调用构造方法）
    2. 初始化对象的值

  • 注意点：

    • 定义有参构造后，若想使用无参构造，需显式地定义一个无参构造

    • 构造快捷键 alt + ins

    • this. = （this 代表本方法）

    • package oop.demo;
// 一个项目应该只存在一个 main 方法
public class Application {
    public static void main(String[] args) {
        // new 实例化了一个对象
        // 1.使用 new 关键字，本质是在调用构造器
        // 2.用来初始化值
        Person person = new Person("狗蛋");
        System.out.println(person.name);
    }
}

    • package oop.demo;
public class Person {
    // 一个类即使什么都不写，它也会存在一个方法
    String name;
    // 显式地定义无参构造器则如下
    public Person() {

    }
    // 有参构造：一旦定义了有参构造，无参就必须显式定义
    // 本质是 Person 方法的重载
    public Person(String name) {
        this.name = name;
    }
    // 快捷键 alt + insert 自动生成构造器
}

面向对象 06 创建对象内存分析

  • 创建对象内存分析

面向对象 07 类与对象小结

  1. 类与对象
    • 类是一个抽象的模板；对象是一个具体的实例。
  2. 方法
    • 定义
    • 调用
  3. 对象的引用
    • 引用类型：8 大基本类型之外基本都是引用类型
    • 对象是通过引用来操作的：栈 —> 堆（地址）
  4. 属性：字段（Field）成员变量
    • 默认初始化
      • 数字：0 0.0
      • char：u0000
      • boolean：false
      • 引用：null
    • 修饰符 属性类型 属性名 = 属性值
  5. 对象的创建和使用
    • 必须使用new关键字创造对象（Person goudan = new Person();）
    • 对象的属性goudan.name
    • 对象的方法goudan.sleep()
  6. 类：
    • 静态的属性 属性
    • 动态的行为 方法

面向对象 08 封装

  • 该露的露，该藏的藏

    • 程序设计追求**“高内聚，低耦合”**。高内聚：类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。

  • 封装（数据的隐藏）

    • 通常，应禁止直接访问一个对象中数据的实际表示，应通过操作接口来访问。

  • 属性私有，get / set

    • package oop.demo;
// 一个项目应该只存在一个 main 方法
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("狗蛋");
        System.out.println(s1.getName());
        s1.setAge(18);
        System.out.println(s1.getAge());
    }
}

    • package oop.demo;
// 学生类
public class Student {
    private String name;
    private int age;
    // alt + insert 快捷键，设置 setter & getter
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

面向对象 09 继承

  • 继承的本质是对某一批类的抽象，从而实现更好地建模

  • extends（扩展），子类是父类的扩展

  • Java 中只有单继承，没有多继承

    • 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等

    • 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。

    • 子类和父类之间，从意义上讲应该具有 “is a” 的关系

    • package oop.demo;
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        //Student 类已继承 Person 类的全部方法
        s1.say();
    }
}

    • public class Person {
    // public
    // protected
    // default
    // private 
    private int money = 10_0000_0000;
    // Person 类的 say() 方法
    public void say() {
        System.out.println("说了一句话");
    }
    public void setMoney(int money) {
        this.money = money;
    }
    public int getMoney() {
        return money;
    }
}

    • // extends 关键字，继承 Person 类的 say() 方法
public class Student extends Person {
    
}

面向对象 10 super详解

  1. super调用父类的属性

    • package oop.demo;
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.test1("狗蛋"); // print "狗蛋" \n "学生" \n "人类"
    }
}

    • package oop.demo;
public class Person {
    protected String name = "人类";
}

    • package oop.demo;
// Student 类继承 Person 类
public class Student extends Person {
    private String name = "学生";
    public void test1(String name) {
        System.out.println(name); // 局部变量 形式参数name（"狗蛋"）
        System.out.println(this.name); // 实例变量 "学生"
        System.out.println(super.name); // 实例变量 "人类"
    }
}

  2. super调用父类的方法

    • package oop.demo;
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.test2(); // print "学生" \n "学生" \n "人类"
    }
}

    • package oop.demo;
public class Person {
    public void print() {
        System.out.println("人类");
    }
}

    • package oop.demo;
public class Student extends Person {
    public void print() {
        System.out.println("学生");
    }
    public void test2() {
        print(); // "学生"
        this.print(); // "学生"
        super.print(); // "人类"
    }
}

  3. super调用构造器（无参）

    • package oop.demo;
public class Application {
    public static void main(String[] args) {
        // 虽然只调用了 Student 类，但因为 Student 类 extends 了 Person 类，故会先生成父类 Person 的构造器，再生成子类 Student 的构造器
        Student s1 = new Student(); // print "人类 无参" \n "学生 无参"
    }
}

    • package oop.demo;
public class Person {
    // 显式无参构造
    public Person() {
        System.out.println("人类 无参");
    }
}

    • package oop.demo;
public class Student extends Person {
    // 显式无参构造
    public Student() {
        // 隐藏代码 super(); ，调用了父类 Person 的无参构造。调用父类的构造器，必须要在子类构造器的第一行
        System.out.println("学生 无参");
    }
}

  4. super调用构造器（有参）

    • package oop.demo;
public class Application {
    public static void main(String[] args) {
        // 调用子类 有参构造器
        Student s1 = new Student("狗蛋"); // print "人类" \n "狗蛋"
    }
}

    • package oop.demo;
public class Person {
    // 父类 有参构造器
    public Person(String name) {
        System.out.println(name);
    }
}

    • package oop.demo;
public class Student extends Person {
    // 子类 显式无参构造器
    public Student() {
        super("人类");
        System.out.println("学生 无参");
    }
    // 子类 有参构造器
    // 因父类构造器有参，必须用 super("String") 调用，否则报错
    public Student(String name) {
        super("人类");
        System.out.println(name);
    }
}

  5. 小结

    • super注意点：
      • super调用父类的构造方法，必须在构造方法的第一个
      • super只能出现在子类的方法或构造方法中
      • super和this不能同时调用构造方法
    • VSthis：
      • 代表的对象不同
        • this：本身调用者这个对象
        • super：代表父类对象的引用
      • 前提
        • this：没有继承也可以使用
        • super：只能在继承条件下使用
      • 构造方法
        • this()：本类的构造
        • super()：父类的构造

面向对象 11 方法重写

  1. 静态方法调用

    • package oop.demo;
public class Application {
    public static void main(String[] args) {
        // 静态方法的调用只和左边定义的数据类型（B）有关
        B b = new B();
        b.test(); // print "B --> test()"

        // 父类的引用指向了子类
        A a = new B();
        a.test(); // print "A --> test()"
    }
}

    • package oop.demo;
public class A {
    // static 静态方法
    public static void test() {
        System.out.println("A --> test()");
    }
}

    • package oop.demo;
public class B extends A {
    // static 静态方法
    public static void test() {
        System.out.println("B --> test()");
    }
}

  2. 非静态方法重写

    • package oop.demo;
public class Application {
    public static void main(String[] args) {
        B b = new B();
        b.test(); // print "B --> test()"

        // 父类的引用指向了子类
        A a = new B(); // 子类重写了父类的方法
        a.test(); // print "B --> test()"
    }
}

    • package oop.demo;
public class A {
    // 非静态方法
    public void test() {
        System.out.println("A --> test()");
    }
}

    • package oop.demo;
public class B extends A {
    @Override // 注解：有功能的注释
    // 非静态方法
    public void test() {
        System.out.println("B --> test()");
    }
}

  3. 小结

    • 重写：需要有继承关系，子类重写父类的方法
      • 方法名必须相同
      • 参数列表必须相同
      • 修饰符：范围可以扩大 private < default < protected < public
      • 抛出的异常：范围可以被缩小，但不能扩大
    • 为何需要重写：
      • 父类的功能，子类不一定需要，或者不一定满足
    • 快捷键 alt + insert：override

面向对象 12 多态

  • 即同一方法可以根据发送对象的不同而采用多种不同的行为方式

  • 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

  • 多态是方法的多态，属性没有多态性

  • instanceof类型转换（引用类型）

  • 重写前的多态

    • package oop.demo;
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        Person s2 = new Student();
        Object s3 = new Student();
        // 子类型 Student 的对象 s1 可以直接调用父类型 Person 的方法
        s1.run(); // print "人类 跑"
        s2.run(); // print "人类 跑"
    }
}

    • package oop.demo;
public class Person {
    public void run() {
        System.out.println("人类 跑");
    }
}

    • package oop.demo;
public class Student extends Person {

}

  • 重写后的多态，拓展

    • package oop.demo;
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        Person s2 = new Student(); // 父类的引用指向子类
        Object s3 = new Student();
        // run() 已被重写
        s2.run(); // print "重写为：飞"
        // s2.eat();报错：父类型 Person 的对象 s2 不能直接调用子类型 Student 的方法，需强制转换类型（Person 转 Student）
        ((Student) s2).eat(); // print "吃"
    }

    • package oop.demo;
public class Person {
    public void run() {
        System.out.println("跑");
    }
}

    • package oop.demo;
public class Student extends Person {
    // 重写 run()
    @Override
    public void run() {
        System.out.println("重写为：飞");
    }
    public void eat() {
        System.out.println("吃");
    }
}

面向对象 13 instanceof 和类型转换

  • instanceof是 Java 的保留关键字，其作用是：测试左边的对象是否是右边的类的实例，返回boolean的数据类型

    • 比如 Person X = new Student()，我们知道左边 Person 是引用类型，右边 Student 是实际类型

    • X instanceof Y，若 X 的引用类型（Person）和 Y 有没有继承关系，则编译报错

    • 若 X 的实际类型（Student）是 Y 本身，或 Y 的子类，则返回 true，否则返回 false

    • 若 X 的实际类型是 Y 的父类，也返回 false

    • package oop.demo;
public class Application {
    public static void main(String[] args) {
        // Object > String
        // Object > Person > Teacher
        // Object > Person > Student
        Object o = new Student();
        System.out.println(o instanceof Student); // true
        System.out.println(o instanceof Person); // true
        System.out.println(o instanceof Object); // true
        System.out.println(o instanceof Teacher); // false
        System.out.println(o instanceof String); // false

        Person p = new Student();
        System.out.println(p instanceof Student); // true
        System.out.println(p instanceof Person); // true
        System.out.println(p instanceof Object); // true
        System.out.println(p instanceof Teacher); // 引用类型 Person 和 Teacher 无继承关系，编译报错
        System.out.println(p instanceof String); // 引用类型 Person 和 String 无继承关系，编译报错

        Student s = new Student();
        System.out.println(s instanceof Student); // true
        System.out.println(s instanceof Person); // true
        System.out.println(s instanceof Object); // true
        System.out.println(s instanceof Teacher); // 引用类型 Student 和 Teacher 无继承关系，编译报错
        System.out.println(s instanceof String); // 引用类型 Student 和 String 无继承关系，编译报错
    }
}

    • package oop.demo;
public class Person {
}

    • package oop.demo;
public class Student extends Person {
}

    • package oop.demo;
public class Teacher {
}

  • 基本类型不能用instanceof判断

面向对象 14 static关键字详解

  • 静态属性

    • package oop.demo;
public class Student {
    private static int age; // 静态变量
    private double score; // 非静态变量
    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println(Student.age);
        System.out.println(Student.score); // 报错
        System.out.println(s1.age);
        System.out.println(s1.score);
    }
}

  • 静态方法

    • package oop.demo;
public class Student {
    // 静态方法
    public static void run() {
    } 
    // 非静态方法
    public void go() {
    } 
    public static void main(String[] args) {
        run();
        go(); // 报错
    }
}

  • 静态代码块

    • package oop.demo;
public class Student {
    // 执行顺序第 2 ，可用来赋初始值
    {
        System.out.println("匿名代码块"); // 代码块（匿名代码块）
    }
    // 执行顺序第 1 ，只执行 1 次
    static {
        System.out.println("静态代码块"); // 静态代码块
    }
    // 执行顺序第 3
    public Student() {
        System.out.println("构造方法"); // 构造器
    }

    public static void main(String[] args) {
        Student s1 = new Student(); // print "静态代码块" \n "匿名代码块" \n "构造方法" \n
        Student s2 = new Student(); // print "匿名代码块" \n "构造方法" \n
    }
}

  • 静态导入包

    • package oop.demo;
import static java.lang.Math.random; // 静态导入 Math.random() 方法
import static java.lang.Math.PI; // 静态导入 Math.PI 常量
public class Student {
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
    }
}

面向对象 15 抽象类

  • abstract修饰符可以用来修饰方法（抽象方法），也可以用来修饰类（抽象类）。

  • 抽象类中可以没有抽象方法，但有抽象方法的类一定要声明为抽象类。

  • 抽象类不能使用new关键字来创建对象，它是用来让子类继承的。

  • 抽象方法只有声明，没有实现，它是用来让子类实现的。

  • 子类继承抽象类，则必须要实现抽象类未实现的抽象方法，否则该子类也要声明为抽象类

    • package oop.demo;
public abstract class Person {
    public abstract void doSomething(); // 抽象方法只有声明，没有方法体
}

    • package oop.demo;
public abstract class Student extends Person {
    // 子类继承抽象类，重写实现抽象类未实现的抽象方法
    @Override
    public void doSomething() {
        System.out.println("抽象类");
    }
}

面向对象 16 接口

  • 普通类：只有具体实现

  • 抽象类：具体实现和规范（抽象方法）都有

  • 接口：只有规范

  • 接口的本质是契约

  • 声明类的关键字是class，声明接口的关键字是interface

    • package oop.demo;
public interface UserService {
    // 接口中所有定义的属性其实都是静态常量 public static final
    int AGE = 99;
    // 接口中所有定义的方法其实都是抽象的 public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

    • package oop.demo;
public interface TimeService {
    void timer();
}

    • package oop.demo;
public class UserServiceImpl implements UserService, TimeService {
    // 实现了接口的类，就需要重写接口中的方法
    @Override
    public void add(String name) {
    }
    @Override
    public void delete(String name) {
    }
    @Override
    public void update(String name) {
    }
    @Override
    public void query(String name) {
    }
    @Override
    public void timer() {
    }
}

  • 接口的作用：

    • 约束
    • 定义一些方法，让不同的人实现
    • 属性默认都是public static final常量
    • 方法默认都是public abstract抽象
    • 接口中没有构造方法，不能被实例化
    • implements可以实现多个接口
    • 必须要重写接口中的方法

面向对象 17 内部类

  • 内部类就是在一个类的内部再定义一个类。 A 类中定义一个 B 类，则 B 是 A 的内部类，A 是 B 的外部类。

  • 种类

    • 成员内部类

    • 创建成员内部类对象，必须先创建外部类对象，再通过外部类对象.new 构造内部类对象

    • 成员内部类中不能有静态成员

    • 成员内部类可以访问外部类的私有属性

      • package oop.demo;
public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.out(); // print "这是外部类的方法"
        // 语法 outer.new Inner();
        Outer.Inner inner = outer.new Inner();
        inner.in(); // print "这是内部类的方法"
        inner.getID(); // print 10
        inner.getOut(); // print "这是外部类的方法"
    }
}

      • package oop.demo;
// 外部类
public class Outer {
    private int id = 10;
    public void out() {
        System.out.println("这是外部类的方法");
    }
    // 内部类
    public class Inner {
        public void in() {
            System.out.println("这是内部类的方法");
        }
        // 可获得外部类的私有属性
        public void getID() {
            System.out.println(id); // print 10
        }
        // 可直接调用外部类的方法
        public void getOut() {
            out(); // print "这是外部类的方法"
        }
    }
}

    • 静态内部类

    • 静态内部类中只能访问外部类的静态成员

      • package oop.demo;
public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.out(); // print "这是外部类的方法"
        // 语法 new Outer.Inner();
        Outer.Inner inner = new Outer.Inner();
        inner.in(); // print "这是内部类的方法"
    }
}

      • package oop.demo
// 外部类
public class Outer {
    public void out() {
        System.out.println("这是外部类的方法");
    }
    // 静态内部类
    public static class Inner {
        public void in() {
            System.out.println("这是内部类的方法");
        }
    }
}

    • 局部内部类

    • 局部内部类创建对象时，只能在定义它的方法内部进行

    • 局部内部类可以去访问外部类的私有属性

    • 局部内部类也可以去访问它所在方法的局部变量，但是要求局部变量必须被final修饰

    • jdk 8.0开始，默认为局部变量添加final

      • package oop.demo;
public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.out(); // print "这是外部类的方法" \n "这是外部类的方法"
    }
}

      • package oop.demo;
public class Outer {
    public void out() {
        System.out.println("这是外部类的方法");
        class Inner {
            public void in() {
                System.out.println("这是内部类的方法");
            }
        }
        // 局部内部类创建对象，只能在 out() 方法内进行
        Inner inner = new Inner();
        inner.in();
    }
}

    • 匿名内部类

异常

异常 01 Error和Exception

  • Java 把异常当作对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类
  • 检查性异常：最具代表的是用户错误或问题引起的异常，这是程序员无法预见的。例如打开一个不存在的文件时，一个异常就发生了。
  • 运行时异常：是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
  • 在Java API 中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception
    • Throwable
      • Error
        • VirtualMachineError虚拟机运行错误
          • StacOverFlowError栈溢出错误
          • OutOfMemoryError内存不足错误
        • AWTError
      • Exception
        • IOExcption
          • EOFException
          • FileNotFoundException找不到文件异常
        • RuntimeException运行时异常
          • ArrithmeticException算术异常
          • MissingResourceException丢失资源
          • ClassNotFoundException找不到类
          • NullPointerException空指针异常
          • IllegalArgumentException不合法参数
          • ArrayIndexOutOfBoundsException数组下标越界
          • UnknownTypeException不明类型异常
  • 错误Error：错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，编译中也检查不到。
    • Error类对象由 Java 虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关
    • 当 JVM 不再有继续执行操作所需的内存资源时，将出现 Java 虚拟机运行错误VirtualMachineError
    • 发生在虚拟机试图执行应用时，如类定义错误NoClassDefFoundError，链接错误LinkageError，这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。
  • Error和Exception的区别：Error通常是灾难性的致命错误，是程序无法控制和处理的，当出现这些异常时，JVM 一般会选择终止线程。Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能地去处理这些异常。

异常 02 捕获和抛出异常

  • 快捷键 Ctrl + Alt + T

  • 抛出异常

  • 捕获异常

  • 异常处理 5 个关键字

    • try、catch、finally、throw、throws

    • package exception;
public class Demo01 {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;
        // 假设要捕获多个异常：按照范围从小到大的顺序
        try { // try 监控区域
            System.out.println(a / b);
        } catch (ArithmeticException e) { // catch 捕获异常
            System.out.println("运行异常！除数不能为0！");
            e.printStackTrace(); // 打印错误的栈信息
        } catch (Error e) {
            System.out.println("Error");
        } catch (Exception e) {
            System.out.println("Exception");
        } catch (Throwable e) {
            System.out.println("Throwable");
        } finally { // 处理善后工作
            System.out.println("finally");
        }
    }
}

    • package exception;
public class Demo02 {
    public static void main(String[] args) {
        Demo02 test = new Demo02();
        test.test(1,0);
    }
    // 假设该方法中处理不了这个异常
    // public void test(int a, int b) throws ArithmeticException() {
    public void test(int a, int b) {
        if (b == 0) {
            // 主动抛出异常，一般在方法中使用
            throw new ArithmeticException();
        }
    }
}

异常 03 自定义异常及经验小结

  • 使用 Java 内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需继承 Exception 类即可

    • 创建自定义异常类

    • 在方法中通过throw关键字抛出异常对象

    • 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理（程序继续正常运行）；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常（程序中断不继续运行）

    • 在出现异常方法的调用者中捕获并处理异常

    • package exception;
// 自定义的异常类
public class MyException extends Exception{
    // 传递数字 >10
    private int detail;

    public MyException(int a) {
        this.detail = a;
    }
    // toString：异常的打印信息
    @Override
    public String toString() {
        return "MyException{" + "detail=" + detail + '}';
    }
}

    • package exception;
public class Test {
    // 可能会存在异常的方法，`throws`关键字抛出
    static void test(int a) throws MyException {
        System.out.println("传递的参数为：" + a);
        if (a > 10) {
            throw new MyException(a);
        }
        System.out.println("OK");
    }
    public static void main(String[] args) {
        // `try`-`catch`关键字捕获
        try {
            test(11);
        } catch (MyException e) {
            System.out.println("自定义异常:" + e);
            // print 传递的参数为：11 \n 自定义异常:MyException{detail=11}
        }
    }
}

  • 实际应用中的经验总结

    • 处理运行时异常时，采用逻辑去合理规避，同时辅助try-catch处理
    • 在多重catch块后面，可以加一个尽可能大的catch (Exception e)来处理可能会被遗漏的异常
    • 对于不确定的代码，也可以加上try-catch，处理潜在的异常
    • 尽量去处理异常，切忌简单地调用printStackTrace()去打印输出
    • 具体如何处理异常，要根据不同地业务需求和异常类型去决定
    • 尽量添加finally语句块去释放占用的资源
firemarks
关注
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值