java总复习2

最新推荐文章于 2024-07-09 16:46:46 发布

rena11

最新推荐文章于 2024-07-09 16:46:46 发布

阅读量55

点赞数

分类专栏： java 文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/qq_51758329/article/details/127832865

版权

java 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

一、自带包装类

1. Number 类

在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情形。为了解决这个问题，Java 语言为每一个内置数据类型提供了对应的包装类。

所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类。
在这里插入图片描述

2. Math类

Java 的 Math 包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数。

Math 的方法都被定义为 static 形式，通过 Math 类可以在主函数中直接调用。

3.Character类

Character 类用于对单个字符进行操作。

Character 类在对象中包装一个基本类型 char 的值

4.String类

① 初始化:

String s1 = "Runoob";              // String 直接创建
String s3 = s1;                    // 相同引用
String s4 = new String("Runoob");   // String 对象创建

char[] helloArray = { 'r', 'u', 'n', 'o', 'o', 'b'};
String s5 = new String(helloArray);   // 字符数组初始化

②.常用方法:

length() : 它返回字符串对象包含的字符数。
string1.concat(string2);: 连接两个字符串
更常用的是直接用 ‘+’ 来连接字符串。

③. 格式化字符串:
String 类使用静态方法 format() 返回一个String 对象而不是 PrintStream 对象,能用来创建可复用的格式化字符串，而不仅仅是用于一次打印输出。

String fs;
fs = String.format("浮点型变量的值为 " +
                   "%f, 整型变量的值为 " +
                   " %d, 字符串变量的值为 " +
                   " %s", floatVar, intVar, stringVar);

5. StringBuffer& StringBuilder类

① 和String的区别:
当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。

和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

在使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，所以如果需要对字符串进行修改推荐使用 StringBuffer。
②.StringBuffer和StringBuilder的区别
StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。

由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。

二、数组

1.创建数组

实际上是被拆成两步，先声明后创建.
声明:

dataType[] arrayRefVar;   // 首选的方法
 或
dataType arrayRefVar[];  // 效果相同，但不是首选方法

创建

arrayRefVar = new dataType[arraySize];

这里实际也分了两个步骤:
一、使用 dataType[arraySize] 创建了一个数组。
二、把新创建的数组的引用赋值给变量 arrayRefVar。

结合起来，数组的声明和创建：

dataType[] arrayRefVar = new dataType[arraySize];
// 或者，直接赋值
dataType[] arrayRefVar = {value0, value1, ..., valuek};

2.遍历数组

for循环遍历

 double[] myList = {1.9, 2.9, 3.4, 3.5};
 
      // 打印所有数组元素
      for (int i = 0; i < myList.length; i++) {
         System.out.println(myList[i] + " ");
      }

for-each 循环 / 加强型循环

for(type element: array)
{
System.out.println(element);

      double[] myList = {1.9, 2.9, 3.4, 3.5};
 
      // 打印所有数组元素
      for (double element: myList) {
         System.out.println(element);
      }

数组可以作为函数的参数，返回值.

3.多维数组

①. 直接为每一维分配空间,如下:

type[][] typeName = new type[typeLength1][typeLength2];

②.从最高维开始，分别为每一维分配空间

String[][] s = new String[2][];
s[0] = new String[2];
s[1] = new String[3];

4. Arrays类

java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。

具有以下功能：

给数组赋值：public static void fill(int[] a, int val)；
将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。
对数组排序：通过 sort 方法,按升序。
比较数组：通过 equals 方法比较数组中元素值是否相等。
查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。

练习题1 :

以下程序输出的结果:

class TestIt
{
    public static void main ( String[] args )
    {
        int[] myArray = {1, 2, 3, 4, 5};
        ChangeIt.doIt( myArray );
        for(int j=0; j<myArray.length; j++)
            System.out.print( myArray[j] + " " );
    }
}
class ChangeIt
{
    static void doIt( int[] z ) 
    {
    	if(z.length>0)z[0]=8;
        z = null ;
    }
}

输出 8 2 3 4 5.
解释：对象或数组作为参数传递时，传递的是一个引用，将z[0]赋值为8直接将z指向的数组{1, 2, 3, 4, 5}第一个元素改为8，但是将z指向null只是将z这个引用指向空，并不会改变原来的数组。

三、方法

1.概念

方法是解决一类问题的步骤的有序组合
方法包含于类或对象中
方法在程序中被创建，在其他地方被引用

2.定义

修饰符返回值类型方法名(参数类型参数名){
…
方法体
…
return 返回值;
}

3.参数

函数参数是值传递的过程。
内置数据类型传递的是参数的值；引用数据类型传递的是一个引用。
调用时必须按照参数列表指定的顺序提供参数。

4.方法的重载

一个类的两个方法拥有相同的名字，但是有不同的参数列表。不能依据修饰符或者返回类型的不同来重载方法。

重载的方法必须拥有不同的参数列表: 参数的个数不同，对应位置的参数类型不同，都算是不同的参数列表。

方法重载可以让程序更清晰易读。执行密切相关任务的方法应该使用相同的名字。

5.构造方法

①作用:
当一个对象被创建时候，构造方法用来初始化该对象。通常会使用构造方法给一个类的实例变量赋初值，或者执行其它必要的步骤来创建一个完整的对象。
②要求:
构造方法和它所在类的名字相同，但构造方法没有返回值。
③规则:
不管你是否自定义构造方法，所有的类都有构造方法，因为 Java 自动提供了一个默认构造方法，默认构造方法的访问修饰符和类的访问修饰符相同(类为 public，构造函数也为 public；类改为 protected，构造函数也改为 protected)。
一旦你定义了自己的构造方法，默认构造方法就会失效。

6.可变参数

typeName… parameterName

在方法声明中，在指定参数类型后加一个省略号(…) 。

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

7.finalize()方法

Java 允许定义这样的方法，它在对象被垃圾收集器析构(回收)之前调用，这个方法叫做 finalize( )，它用来清除回收对象。
在 finalize() 方法里，你必须指定在对象销毁时候要执行的操作。

和c++中析构函数的比较:

在C++中，对象是可以在栈上分配的，也可以在堆上分配。在栈上分配的对象，也就是函数的局部变量，当超出块的"}"时，生命期便结束了。在堆上分配的对象，使用delete的时候，对象的生命期也就结束了。因此在C++中，对象的内存在哪个时刻被回收，是可以确定的（假设程序没有缺陷）。一旦C++的对象要被回收了，在回收该对象之前对象的析构函数将被调用，然后释放对象占用的内存
java秉承一切皆为对象的思想，对象仅能通过new来创建，因此java的对象是在堆上分配的内存。这些堆上的对象，如果没有作用了（无引用指向它），将等待垃圾回收器来回收其占用的内存。而垃圾回收期何时运行，无法提前预知，甚至有的时候直到程序退出都没有进行垃圾回收，程序所占内存直接由操作系统来回收。所以在java中，对象的内存在哪个时刻回收，取决于垃圾回收器何时运行。finalize()方法的一个作用是用来回收“本地方法”中的本地对象。较少使用。

四、Scanner

可以通过 Scanner 类来获取用户的输入。

1. 语法

Scanner s = new Scanner(System.in);

2.使用

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

nextLine()：
1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
2、可以获得空白。

②.输入的同时检查类型:
如果要输入 int 或 float 类型的数据，在 Scanner 类中也有支持，但是在输入之前最好先使用 hasNextXxx() 方法进行验证，再使用 nextXxx() 来读取.

import java.util.Scanner;
 
public class ScannerDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        // 从键盘接收数据
        int i = 0;
        float f = 0.0f;
        System.out.print("输入整数：");
        if (scan.hasNextInt()) {
            // 判断输入的是否是整数
            i = scan.nextInt();
            // 接收整数
            System.out.println("整数数据：" + i);
        } else {
            // 输入错误的信息
            System.out.println("输入的不是整数！");
        }
        System.out.print("输入小数：");
        if (scan.hasNextFloat()) {
            // 判断输入的是否是小数
            f = scan.nextFloat();
            // 接收小数
            System.out.println("小数数据：" + f);
        } else {
            // 输入错误的信息
            System.out.println("输入的不是小数！");
        }
        scan.close();
    }
}

五、异常处理

1.分类：

检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
运行时异常：运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
错误：错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。

2. Exception类

所有的异常类是从 java.lang.Exception 类继承的子类。

Exception 类是 Throwable 类的子类。除了Exception类外，Throwable还有一个子类Error 。

Java 程序通常不捕获错误。错误一般发生在严重故障时，它们在Java程序处理的范畴之外。

Error 用来指示运行时环境发生的错误。

例如，JVM 内存溢出。一般地，程序不会从错误中恢复。

异常类有两个主要的子类：IOException 类和 RuntimeException 类。

3.捕获异常

try{
  // 程序代码
}catch(异常类型1 异常的变量名1){
  // 程序代码
}catch(异常类型2 异常的变量名2){
  // 程序代码
}finally{
  // 程序代码
}

finally 关键字用来创建在 try 代码块后面执行的代码块。

无论是否发生异常，finally 代码块中的代码总会被执行。

在 finally 代码块中，可以运行清理类型等收尾善后性质的语句。

4.throws/throw关键字

如果一个方法没有捕获到一个检查性异常，那么该方法必须使用 throws 关键字来声明。throws 关键字放在方法签名的尾部。也可以使用 throw 关键字抛出一个异常，无论它是新实例化的还是刚捕获到的。都只是捕获抛出异常并不处理。

区别：
（1）throws用于方法头，表示的只是异常的声明，而throw用于方法内部，抛出的是异常对象。
（2）throws可以一次性抛出多个异常，而throw只能一个
（3）throws抛出异常时，它的上级（调用者）也要申明抛出异常或者捕获，不然编译报错。而throw的话，可以不申明或不捕获（这是非常不负责任的方式）但编译器不会报错。