【无标题】

最新推荐文章于 2025-05-03 10:56:02 发布

zq211115

最新推荐文章于 2025-05-03 10:56:02 发布

阅读量967

点赞数 22

分类专栏：考试不挂科文章标签： java

本文链接：https://blog.youkuaiyun.com/zq211115/article/details/135564125

版权

考试不挂科专栏收录该内容

2 篇文章

订阅专栏

java考试前核心复习知识点：

涉及到自己不会的可以咨询智能助手，或查阅教材，问同学等。

其他基本知识点

构造函数特点

Java构造函数的特性主要包括以下几点：

名称与类名相同：构造函数与类名必须相同，这是Java语言的规定。
没有返回类型：构造函数没有返回类型，即使是void类型也没有。这与Java中的其他方法不同，其他方法必须声明返回类型。
不能被直接调用：构造函数不能像普通方法那样被直接调用。它们在创建对象时自动调用。
可以有多个：一个类可以有多个构造函数，这称为构造函数的重载。这是通过为构造函数提供不同的参数列表来实现的。
默认构造函数：如果一个类没有显式定义任何构造函数，Java编译器会为它提供一个默认构造函数。这个默认构造函数没有参数，并且不做任何事情。
构造函数的访问修饰符：构造函数的访问修饰符不能是private，因为构造函数用于创建对象，需要在类的外部进行访问。构造函数可以是public、protected或默认（没有指定任何修饰符）。
可以带有参数：构造函数可以带有参数，这使得可以在创建对象时提供初始值。
this()和super()的使用：构造函数中可以使用this()来引用同一类的另一个构造函数，或者使用super()来引用父类的构造函数。

以下是一个Java构造函数的示例：

public class Person {  
    private String name;  
    private int age;  
      
    // 默认构造函数  
    public Person() {  
        this("Unknown", 0); // 使用this()调用另一个构造函数  
    }  
      
    // 带有一个参数的构造函数  
    public Person(String name) {  
        this(name, 0); // 使用this()调用另一个构造函数  
    }  
      
    // 带有两个参数的构造函数  
    public Person(String name, int age) {  
        this.name = name;  
        this.age = age;  
    }  
}

抽象类特点

java抽象类是一种特殊的类，它不能被实例化。抽象类通常用于定义一组相关的行为，这些行为可以被其他类继承和实现。下面是Java抽象类的一些特点：

抽象方法：抽象类中可以包含抽象方法和具体方法。抽象方法是在声明时没有方法体的方法，只有方法签名。子类必须实现（override）所有继承自抽象类的抽象方法，除非该子类也是一个抽象类。
继承：抽象类可以被子类继承。子类继承抽象类后，必须实现（override）所有继承自抽象类的抽象方法。如果一个子类是一个抽象类，则它可以继续定义抽象方法。
包含具体方法：抽象类中可以包含具体方法，即已经在声明时提供了方法体的方法。子类可以选择是否重写这些具体方法。
不能被实例化：由于抽象类中可能包含没有实现的方法，因此不能直接实例化抽象类。必须先创建一个子类，然后使用子类的对象来创建对象。
接口：在Java中，接口也是一种定义行为的方式，与抽象类相似。接口中的所有方法都是抽象的，而抽象类中则可以包含具体方法和抽象方法。

以下是一个Java抽象类的示例：

abstract class Animal {  
    // 抽象方法  
    abstract void makeSound();  
      
    // 具体方法  
    void move() {  
        System.out.println("The animal moves.");  
    }  
}

在这个例子中，Animal是一个抽象类，它定义了一个抽象方法makeSound()和一个具体方法move()。任何继承自Animal的子类都必须实现makeSound()方法。

接口的特点

Java接口是一种定义方法签名的抽象类型，它是一种完全抽象的类，只包含抽象方法，不包含具体实现。以下是Java接口的主要特点：

抽象性：接口中的所有方法都是抽象的，没有具体实现。实现接口的类必须提供这些方法的具体实现。
方法公有：接口中的所有方法默认都是public的，不能有private或protected访问修饰符。
无构造方法：接口不能被实例化，因此接口中不能定义构造方法。
常量和默认方法：从Java 8开始，接口中可以定义常量，也可以定义默认方法。默认方法允许在接口中提供方法的默认实现。
继承：接口可以继承其他接口，实现多重继承。一个类可以实现多个接口。
实现类：实现接口的类必须实现接口中的所有方法。如果一个类没有实现接口中的所有方法，则该类必须被声明为抽象类。
接口的继承：一个接口可以继承另一个接口，继承时需要使用关键字extends。如果一个接口继承了另一个接口，则该接口会自动继承父接口的所有抽象方法。

以下是一个Java接口的示例：

interface Animal {  
    void makeSound(); // 抽象方法  
    void move(); // 默认方法  
      
    int getWeight(); // 常量  
}

在这个例子中，Animal是一个接口，它定义了一个抽象方法makeSound()、一个默认方法move()和一个常量getWeight()。实现Animal接口的类必须实现makeSound()方法和getWeight()常量，可以选择是否重写move()方法。

程序运行结果的基本知识点

1 知道字符串类型，以及8个基本类型的缺省值，就是没有赋值时，它应该是什么值

在Java中，当你声明一个变量但没有给其赋值时，该变量的值会根据其数据类型来决定。对于基本数据类型（如int、char、boolean等），它们会有一个默认的初始值。对于引用类型（如String），Java会将其初始化为null。

以下是Java中基本数据类型的默认初始值：

byte: 0
short: 0
int: 0
long: 0L
float: 0.0f
double: 0.0d
char: ‘\u0000’ (空字符)
boolean: false

对于引用类型，例如String，默认值为null，表示该变量不引用任何对象。

需要注意的是，这些默认值是对于局部变量而言的。对于类变量（static变量），它们的默认值会有所不同。对于非static的实例变量，它们的默认值与局部变量相同。但对于static变量，它们的默认值如下：

byte, short, int, long: 0
float, double: 0.0
char: ‘\u0000’ (空字符)
boolean: false
对于引用类型（如String）：null

2 知道System.out.println()和System.out.print()的区别

System.out.println() 和 System.out.print() 都是用于在控制台输出信息的Java方法，但它们之间有几个关键的区别：

换行符：System.out.println() 在输出信息后会自动添加一个换行符，而 System.out.print() 则不会。这意味着如果你连续使用 System.out.println()，每次输出后都会有一个新行，而使用 System.out.print() 则不会。
返回值：System.out.println() 返回一个 void，也就是说它没有返回值。而 System.out.print() 返回的是 PrintStream 对象，它有一个可以继续输出的方法。
用途：由于上述的特性，通常在需要格式化输出时，或者在需要连续输出而不换行时，使用 System.out.print()。而当需要输出信息并换行时，通常使用 System.out.println()。
缓冲：在某些情况下，你可能需要强制刷新输出流，这可以通过调用 System.out.flush() 来实现。这会影响到 System.out.print() 的行为，因为它是通过缓冲区来工作的。

总的来说，选择使用 System.out.println() 还是 System.out.print() 主要取决于你的具体需求，但通常情况下，对于大多数情况，使用 System.out.println() 是一个更合适的选择。

3 知道this(),this(x),super. ,this.的含义和不同

在Java编程语言中，this, this(x), super, 和 this. 都是特殊的关键词，具有特定的含义和用途。以下是它们各自的含义和不同之处：

this
- 含义：this 是一个引用变量，它引用了当前对象实例。它常用于区分局部变量和实例变量，或者在构造函数中引用当前实例。
- 用法：可以在类的方法或构造器中，以及静态方法中使用 this 关键字。
- 示例：当局部变量和实例变量同名时，可以使用 this 来区分它们。
this(x)
- 含义：this(x) 是在一个构造器内部，用来调用同一个类中的另一个构造器。这是构造器的特殊语法。
- 用法：只能在构造器内部使用，并且必须作为构造器的第一个语句出现。
- 示例：当一个类有多个构造器时，可以使用 this 来调用另一个构造器，从而避免重复的代码。
super
- 含义：super 是一个引用变量，它引用了当前对象的父类实例。它常用于访问父类的属性和方法。
- 用法：可以在子类的构造器和方法中使用 super 关键字。
- 示例：当子类需要访问父类的构造器或重写父类的方法时，可以使用 super。
this.
- 含义：this. 是用来区分当前对象的实例变量和局部变量（方法内的变量）的。如果一个变量名与实例变量同名，那么可以使用 this. 来引用实例变量。
- 用法：只能在类的方法内部使用。
- 示例：当局部变量和实例变量同名时，可以使用 this. 来区分它们。

不同之处：

this 和 super 都是引用变量，分别引用当前对象和父对象，而 this(x) 是构造器的特殊语法，用于调用其他构造器。
this. 是用来区分实例变量和局部变量的语法结构。
this, this(x), 和 this. 都可以在方法或构造器中使用，而 super 只能在构造器中使用。

4 知道在字符串比较中 == equals 它们之间的不同

在Java中，== 和 equals() 方法都可以用于比较字符串，但它们之间有几个重要的不同点。

比较类型：
- == 用于比较两个引用是否指向内存中的同一个对象。
- equals() 是String类中的一个方法，用于比较两个字符串的内容是否相同。
默认行为：
- == 默认比较的是引用。
- equals() 默认比较的是字符串的内容。
重写：
- == 不能被重写。
- equals() 可以被重写以实现特定的比较逻辑。例如，某些类可能会根据对象的某些属性来定义equals()方法，而不是直接比较对象的内容。
空值比较：
- 使用 == 比较空字符串 ("") 和 null 会返回 false，因为它们指向不同的对象。
- 使用 equals() 比较空字符串 ("") 和 null 会抛出 NullPointerException，因为 null 对象不能调用任何方法。
性能：
- 对于字符串内容比较，使用 equals() 方法通常比使用 == 更快，因为JVM可能会对字符串常量进行优化。
跨类比较：
- 如果比较的两个对象不属于 String 类或其子类，则使用 == 或 equals() 都可以比较它们的引用，但结果可能不同。
多线程环境：
- 在多线程环境中，使用 == 可能会产生竞态条件，因为它比较的是对象的引用而不是内容。在这种情况下，应该使用 equals() 来比较字符串的内容。
不一致性：
- 如果一个对象的 equals() 方法与 == 的行为不一致（例如，当一个对象的 equals() 方法是基于其内部地址而不是其内容时），这可能会导致不一致的程序行为。在设计和实现类时，应该特别注意这种可能的混淆。

5 知道static的静态属性和普通属性的不同知道静态代码初始化的特点

当然，让我们深入探讨一下Java中的静态属性和普通属性的不同，以及静态代码块的特点。

静态属性和普通属性的不同：

存储位置：静态属性存储在静态存储区，而普通属性存储在堆内存中。
生命周期：静态属性随着类的加载而创建，随着类的消失而销毁。普通属性随着对象的创建而创建，随着对象的销毁而销毁。
访问方式：静态属性可以通过类名直接访问，而无需创建对象。普通属性必须通过对象实例来访问。
初始化顺序：静态属性在类加载时初始化，只初始化一次。普通属性在对象创建时初始化，每次创建新对象时都会初始化。
多线程环境：在多线程环境中，静态属性是线程安全的，因为多个线程访问的是同一个静态属性。而普通属性可能不是线程安全的，因为它与每个对象实例关联。

静态代码块的特点：

静态代码块执行顺序：静态代码块在类加载时执行，且只执行一次。它在构造函数之前执行，并且优先于构造函数执行。
目的：静态代码块通常用于初始化静态变量或执行只需要在类加载时执行一次的代码。
线程安全：静态代码块是线程安全的，因为它们在类加载时只执行一次。
可以包含实例初始化器：虽然我们通常不这样做，但静态代码块可以包含实例初始化器（instance initializers）。这类似于非静态初始化块（non-static initialization block），但它是静态的。
不能直接访问实例变量或方法：由于静态代码块在类加载时执行，因此不能直接访问类的实例变量或方法，因为这些还没有被创建。

6 知道异常处理的处理语句和含义

try{

}

catch(){

}

finally{

}

执行过程和逻辑

要知道即使try{}中有return返回，finally{

}也必做。

异常处理结构是Java中常见的异常处理方式。这里，try、catch 和 finally 块用于处理可能发生的异常。

try 块：
这是异常处理的主要部分，其中包含可能引发异常的代码。如果在执行 try 块中的代码时发生异常，控制流将立即传递到相应的 catch 块。
catch 块：
catch 块用于捕获 try 块中抛出的特定类型的异常。可以有多个 catch 块来捕获不同类型的异常。一旦 try 块中的代码抛出异常，控制流将立即传递到相应的 catch 块。
finally 块：
无论是否发生异常，finally 块中的代码都将被执行。这可以确保某些操作总是被执行，例如关闭文件或释放资源。

执行过程和逻辑：

正常执行：如果 try 块中的代码没有抛出任何异常，那么 finally 块中的代码将被执行，然后程序将继续执行后续的代码。
异常发生：如果 try 块中的代码抛出一个异常，那么将寻找匹配该异常的 catch 块。一旦找到匹配的 catch 块，该块中的代码将被执行，然后执行 finally 块中的代码。如果没有找到匹配的 catch 块，那么异常将被抛出到更高级别的代码（例如调用方法或主程序）。
return 和 finally：即使在 try 块中有 return 语句，finally 块中的代码仍然会被执行。这是因为 return 只影响方法或构造函数的返回，而不影响异常的处理流程。

示例：

public int divide(int a, int b) {  
    try {  
        if (b == 0) {  
            throw new ArithmeticException("Division by zero");  
        }  
        return a / b;  
    } catch (ArithmeticException e) {  
        System.out.println("Exception caught: " + e.getMessage());  
    } finally {  
        System.out.println("Finally block executed.");  
    }  
    return -1; // This line is executed only if no exception is thrown in the try block.  
}

在这个示例中，如果 b == 0，会抛出一个 ArithmeticException。这个异常会被捕获并处理，然后控制流将传递到 finally 块。无论是否发生异常，finally 块中的代码都将被执行。

程序设计编程题必须掌握的知识点

1 会写一个基本业务类

就是会写一个基本业务类：属性，方法，构造方法等，最基本的东西要会。

比如一个例子，定义一个基本的业务类，名为Employee，包含了一些基本的属性： name; age; salary;和几个基本方法，还有构造函数；构造方法有无参的、1个参数的、2个参数的、3个参数的等。如何写出这个类。

以下是一个基本的Employee业务类的定义，包括属性、方法和构造方法：

public class Employee {  
    // 属性  
    private String name;  
    private int age;  
    private double salary;  
  
    // 无参构造函数  
    public Employee() {  
    }  
  
    // 1个参数的构造函数  
    public Employee(String name) {  
        this.name = name;  
    }  
  
    // 2个参数的构造函数  
    public Employee(String name, int age) {  
        this.name = name;  
        this.age = age;  
    }  
  
    // 3个参数的构造函数  
    public Employee(String name, int age, double salary) {  
        this.name = name;  
        this.age = age;  
        this.salary = salary;  
    }  
  
    // Getter和Setter方法  
    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;  
    }  
  
    public double getSalary() {  
        return salary;  
    }  
  
    public void setSalary(double salary) {  
        this.salary = salary;  
    }  
}

这个Employee类包含了三个私有属性：name、age和salary，以及对应的无参、1个参数、2个参数和3个参数的构造方法。还包含了用于获取和设置这些属性的getter和setter方法。

2 要求练习学会的技术

1）使用Scanner类，从键盘上输入整数

import java.util.Scanner;  
  
public class Main {  
    public static void main(String[] args) {  
        Scanner scanner = new Scanner(System.in);  
        System.out.println("请输入一个整数：");  
  
        // 使用 nextInt() 方法获取用户输入的整数  
        int number = scanner.nextInt();  
  
        System.out.println("您输入的整数是：" + number);  
    }  
}

2）学会定义数组和创建数组

int[] arrayName;
arrayName = new int[5];
arrayName = new int[]{1, 2, 3, 4, 5};

3）学会把键盘输入的整数（比如输入5个整数）放到数组中去

import java.util.Scanner;  
  
public class Main {  
    public static void main(String[] args) {  
        Scanner scanner = new Scanner(System.in);  
        int[] array = new int[5];  
        int i = 0;  
  
        while (i < array.length) {  
            System.out.print("请输入一个整数（输入0结束）：");  
            int number = scanner.nextInt();  
            if (number != 0) {  
                array[i] = number;  
                i++;  
            }  
        }  
  
        scanner.close();  
    }  
}

4）给数组a排序方法：最简单的是Array.sort(a)

import java.util.Arrays;  
  
public class Main {  
    public static void main(String[] args) {  
        int[] array = {5, 2, 8, 9, 1};  
        Arrays.sort(array);  
        System.out.println(Arrays.toString(array)); // 输出：[1, 2, 5, 8, 9]  
    }  
}

5）把数组输出

import java.util.Arrays;  
  
public class Main {  
    public static void main(String[] args) {  
        int[] array = {5, 2, 8, 9, 1};  
        Arrays.sort(array);  
        System.out.println(Arrays.toString(array)); // 输出：[1, 2, 5, 8, 9]  
    }  
}

3 要求练习学会的技术

会写一个接口

以下是一个简单的Java接口示例：

public interface MyInterface {  
    // 定义一个方法  
    void myMethod();  
}

这个接口名为MyInterface，它定义了一个没有实现的方法myMethod()。任何实现这个接口的类都必须提供myMethod()方法的实现。

要实现这个接口，可以创建一个类并实现其中的方法，如下所示：

public class MyClass implements MyInterface {  
    // 实现接口中的方法  
    @Override  
    public void myMethod() {  
        System.out.println("实现MyInterface接口的myMethod方法");  
    }  
}

在这个示例中，MyClass类实现了MyInterface接口，并提供了myMethod()方法的实现。通过使用implements关键字，我们告诉编译器这个类实现了指定的接口。

现在，你可以创建MyClass类的实例，并调用myMethod()方法：

public class Main {  
    public static void main(String[] args) {  
        MyClass myClass = new MyClass();  
        myClass.myMethod(); // 输出 "实现MyInterface接口的myMethod方法"  
    }  
}

这只是一个简单的接口示例，你可以根据自己的需求定义更复杂的方法和属性。

会写一个实现该接口的类

会写一个主类和主方法

以下是一个简单的Java主类和主方法的示例：

public class Main {  
    public static void main(String[] args) {  
        // 主方法  
        System.out.println("Hello, World!");  
    }  
}

在这个示例中，Main 类包含一个 main 方法。这是Java程序的入口点，当你运行程序时，JVM会调用这个方法。在 main 方法中，我们只是简单地打印了一条 “Hello, World!” 的消息。

在主方法中用类创建对象，对象调用方法，输出结果

以下是一个在主方法中创建对象、调用方法并输出结果的示例：

public class Main {  
    public static void main(String[] args) {  
        // 创建对象  
        MyClass myObject = new MyClass();  
          
        // 调用方法并输出结果  
        myObject.myMethod();  
    }  
}  
  
class MyClass implements MyInterface {  
    @Override  
    public void myMethod() {  
        System.out.println("实现MyInterface接口的myMethod方法");  
    }  
}

在这个示例中，我们首先在主类 Main 的 main 方法中创建了一个 MyClass 类的实例，并将其赋值给变量 myObject。然后，我们通过 myObject 对象调用了 myMethod() 方法，并输出了结果。MyClass 类实现了 MyInterface 接口，并提供了 myMethod() 方法的实现。因此，当我们调用 myObject.myMethod() 时，它会输出 “实现MyInterface接口的myMethod方法”。

4 要求练习学会的技术

与第2题类同

会把一个整数转成字符串

Integer.toString()方法将整数转换为字符串。以下是一个示例：

int number = 123;  
String str = Integer.toString(number);  
System.out.println(str); // 输出 "123"

在这个示例中，我们首先定义了一个整数变量 number，并将其初始化为123。然后，我们使用Integer.toString()方法将整数转换为字符串，并将结果存储在变量 str 中。最后，我们使用System.out.println()方法将字符串输出到控制台。

注意，Integer.toString()方法只能用于将基本数据类型整数转换为字符串。如果要转换其他数据类型，可以使用相应的转换方法，例如Double.toString()、Float.toString()等。

会获取字符串的第i个字符

使用字符串的charAt()方法来获取字符串的第i个字符。以下是一个示例：

String str = "Hello, World!";  
int index = 7; // 要获取的字符的索引位置  
char character = str.charAt(index);  
System.out.println(character); // 输出 "W"

在这个示例中，我们首先定义了一个字符串变量 str，并将其初始化为 “Hello, World!”。然后，我们定义了一个整数变量 index，并将其初始化为7，表示要获取的字符的索引位置。接下来，我们使用str.charAt(index)方法获取字符串中第i个字符，并将其存储在变量 character 中。最后，我们使用System.out.println()方法将字符输出到控制台。

需要注意的是，字符串的索引位置从0开始计数，因此第i个字符的索引位置为i-1。如果索引位置超出字符串的长度范围，将会抛出StringIndexOutOfBoundsException异常。因此，在获取字符串的某个字符之前，需要确保索引位置是有效的。

会字符串的长度函数

使用字符串的length()方法来获取字符串的长度。以下是一个示例：

String str = "Hello, World!";  
int length = str.length();  
System.out.println(length); // 输出 13

在这个示例中，我们首先定义了一个字符串变量 str，并将其初始化为 “Hello, World!”。然后，我们使用str.length()方法获取字符串的长度，并将其存储在变量 length 中。最后，我们使用System.out.println()方法将长度输出到控制台。

需要注意的是，字符串的长度指的是字符串中字符的数量，不包括字符串末尾的空字符。

会正循环(i从0到9），也会反循环（i从9到0）

正循环（i从0到9）：

for (int i = 0; i < 10; i++) {  
    System.out.println(i);  
}

反循环（i从9到0）：

for (int i = 9; i >= 0; i--) {  
    System.out.println(i);  
}

知道字符串s的字符序号是从0开始到s.lenth()-1

在大多数编程语言中，字符串的索引是从0开始的，这意味着字符串中的第一个字符的索引是0，第二个字符的索引是1，依此类推，直到最后一个字符的索引是字符串长度减1。

例如，如果有一个字符串s = "hello"，那么它的索引将会是：

s[0] = ‘h’
s[1] = ‘e’
s[2] = ‘l’
s[3] = ‘l’
s[4] = ‘o’

所以，s.length() - 1将给出字符串的最后一个字符的索引。

会取s中第i个字符s.chatAt(i)

可以使用字符串的charAt()方法来获取字符串中第i个字符。以下是一个示例：

String s = "Hello, World!";  
int index = 7; // 要获取的字符的索引位置  
char character = s.charAt(index);  
System.out.println(character); // 输出 "W"

在这个示例中，我们首先定义了一个字符串变量 s，并将其初始化为 “Hello, World!”。然后，我们定义了一个整数变量 index，并将其初始化为7，表示要获取的字符的索引位置。接下来，我们使用s.charAt(index)方法获取字符串中第i个字符，并将其存储在变量 character 中。最后，我们使用System.out.println()方法将字符输出到控制台。# 考试前核心复习知识点：