java 期末考试 小结

1.Java的三个版本

        Java ee    平台标准版         java se  平台企业版     java me    平台微机版

2.Java 跨平台性

        通常是指Java程序可以在不同的操作系统和硬件平台上运行,而无需对代码进行修改。这是由于Java的跨平台性是通过Java虚拟机(JVM)实现的。

        Java程序首先被编译成字节码,这是一种与特定平台无关的中间代码。然后,JVM将字节码解释或编译成特定平台的机器代码,以便在该平台上运行。这使得Java程序可以在任何具有适当JVM的平台上运行。

3.Java程序运行机制

  1. 编写Java代码:你需要使用Java编程语言编写代码。Java代码是面向对象的,以类和方法的形式组织。

  2. 编译Java代码:使用Java编译器(javac)将Java代码编译成字节码文件(.class文件)。字节码是一种中间形式,可以在Java虚拟机(JVM)上运行。

  3. 加载字节码:Java虚拟机(JVM)负责加载字节码文件。它将字节码文件加载到内存中,并将其转换为机器可以理解的指令。

  4. 解释和执行:JVM解释并执行字节码指令。它逐行解释字节码指令,并将其转换为底层操作系统可以执行的机器代码。

  5. 运行时环境:JVM提供运行时环境,包括内存管理、垃圾回收和线程管理等。它负责管理程序的内存使用和执行过程中的资源。

 4.JDK   JRE  JVM 三个开发平台

  1. JDK(Java Development Kit)是Java开发工具包,提供了编译、调试和运行Java程序所需的工具和库。它包含了JRE以及编译器(javac)、调试器(jdb)、打包工具(jar)等开发工具。

  2. JRE(Java Runtime Environment)是Java运行环境,用于执行Java程序。它包含了JVM和Java类库,可以在计算机上运行Java应用程序,但不包含用于开发Java程序的工具。

  3. JVM(Java Virtual Machine)是Java虚拟机,是Java程序运行的核心组件。它负责将Java字节码翻译成机器码并执行。JVM是跨平台的,可以在不同操作系统上运行Java程序。

5.Java的开发流程

编辑:生成.java 文件   

编译:(jvm) 生成 .class 字节码文件

运行:运行是指使用Java解释器将字节码文件翻译成机器代码,执行并显示结果

 6.Java程序执行入口的主方法

java程序的执行入口是通过一个特定的方法来定义的,这个方法被称为"main"方法。在Java程序中,main方法是程序的起点,程序从这个方法开始执行。

main方法的定义格式如下:

public static void main(String[] args) {
         // 执行的代码
         }

7.合法的标识符

  1. 标识符是用于命名变量、方法、类等的名称。
  2. 标识符可以由字母、数字、下划线和美元符号组成。
  3. 标识符必须以字母、下划线或美元符号开头。
  4. 标识符区分大小写,例如"myVariable"和"myvariable"是不同的标识符。
  5. 标识符不能是Java关键字,如"public"、"class"等。
  6. 标识符的长度可以是任意的,但最好保持简洁和有意义。
  7. 标识符不能包含空格或特殊字符,如@、#、%等。

8.java  数据类型(8 + 3)

Java数据类型:

  1. 基本数据类型(Primitive Data Types)八种基本数据类型:

    • 整数类型:byte、short、int、long
    • 浮点类型:float、double
    • 字符类型:char
    • 布尔类型:boolean
  2. 引用数据类型(Reference Data Types)三种引用数据类型:

    • 类(Class)
    • 接口(Interface)
    • 数组(Array)
// 声明整数类型变量
int age = 25;

// 声明浮点类型变量
double salary = 5000.50;

// 声明字符类型变量
char grade = 'A';

// 声明布尔类型变量
boolean isStudent = true;

// 声明类类型变量
String name = "John Smith";

// 声明数组类型变量
int[] numbers = {1, 2, 3, 4, 5};

9.   8种数据类型 

类型 字节 取值范围
byte 1 -2^7  ~ 2^7 -1
short 2 -2 ^ 15~ 2^15 - 1
int  4 -2 ^ 31 ~ 2 ^ 31 -1
float 4 -2 ^ 31 ~ 2 ^ 31 -1
long 8 -2 ^ 63 ~ 2 ^ 63 -1
double 8 -2 ^ 63 ~ 2 ^ 63 -1
char 2 0 ~ 2^ 16 -1
boolean 1 true ,false

 10.整型常量的三种表达式

Java整型常量有以下三种表达式:

  1. 十进制表达式:使用十进制数字表示整型常量。例如:int x = 10;

  2. 八进制表达式:使用前缀0表示整型常量为八进制。例如:int y = 012;

  3. 十六进制表达式:使用前缀0x或0X表示整型常量为十六进制。例如:int z = 0xA;

11.浮点数常量的两种表达式

  1. 十进制表示: 浮点数可以直接使用十进制表示,例如:

    double num1 = 3.14;

    float num2 = 2.71828f;

  2. 科学计数法表示: 浮点数也可以使用科学计数法表示,使用字母E(或e)表示指数部分,例如:

    double num3 = 2.5e6; // 2.5乘以10的6次方,即2500000.0
    float num4 = 1.23e-4f; // 1.23乘以10的-4次方,即0.000123

12.Java字符型的四种表达式是指以下四种形式:

  1. 直接赋值表达式: char c = 'a';

  2. 转义字符表达式: char c = '\n'; // 表示换行符

  3. Unicode 表达式: char c = '\u0061'; // 表示字符 'a' 的 Unicode 编码

  4. 字符型变量运算表达式: char c = 'a'; int i = c + 1; // 将字符 'a' 的 ASCII 值加 1,得到整数 98

以下是一个简单的示例代码,演示了这四种表达式的使用:

public class CharExpressions {
    public static void main(String[] args) {
        // 直接赋值表达式
        char c1 = 'a';
        System.out.println("直接赋值表达式: " + c1);

        // 转义字符表达式
        char c2 = '\n';
        System.out.println("转义字符表达式: " + c2);

        // Unicode 表达式
        char c3 = '\u0061';
        System.out.println("Unicode 表达式: " + c3);

        // 字符型变量运算表达式
        char c4 = 'a';
        int i = c4 + 1;
        System.out.println("字符型变量运算表达式: " + i);
    }
}
输出结果:

直接赋值表达式: a
转义字符表达式:
Unicode 表达式: a
字符型变量运算表达式: 98

13.字符串常量

字符串连接

String str1 = "Hello";
String str2 = "World";
String result = str1 + " " + str2; // "Hello World"

 表达式中包含变量:

String name = "Alice";
int age = 25;
String message = "My name is " + name + " and I am " + age + " years old."; // "My name is Alice and I am 25 years old."
表达式中包含转义字符
String filePath = "C:\\Users\\Alice\\Documents\\file.txt";
String message = "The file is located at: " + filePath; // "The file is located at: C:\Users\Alice\Documents\file.txt"

表达式中包含方法调用:

String str = "Hello";
String result = str.concat(" World"); // "Hello World"

14.变量的定义和赋值

当在Java中定义变量时,需要指定变量的类型,然后给变量赋予一个值。以下是Java中定义和赋值变量的示例代码:

// 定义一个整数类型的变量,并赋值为10
int num = 10;

// 定义一个字符串类型的变量,并赋值为"Hello World"
String message = "Hello World";

// 定义一个布尔类型的变量,并赋值为true
boolean flag = true;

// 定义一个浮点数类型的变量,并赋值为3.14
float pi = 3.14f;
在上面的示例中,我们使用关键字int,String boolean和 float来定义变量的类型,然后使用 = 赋值运算符将值赋给变量。

15.用户输入的方法

1.使用Scanner类:Scanner类是Java中用于读取用户输入的常用类。以下是使用Scanner类获取用户输入的示例代码:

import java.util.Scanner;

public class UserInputExample {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("请输入一个整数:");
        int number = scanner.nextInt();
        System.out.println("您输入的整数是:" + number);

        System.out.print("请输入一个字符串:");
        String text = scanner.nextLine();
        System.out.println("您输入的字符串是:" + text);

        scanner.close();
    }
}

2.使用BufferedReader类:BufferedReader类也可以用于读取用户输入。以下是使用BufferedReader类获取用户输入的示例代码:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class UserInputExample {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        System.out.print("请输入一个整数:");
        int number = Integer.parseInt(reader.readLine());
        System.out.println("您输入的整数是:" + number);

        System.out.print("请输入一个字符串:");
        String text = reader.readLine();
        System.out.println("您输入的字符串是:" + text);

        reader.close();
    }
}

16.Java的三种注释方式

  1. 单行注释:以双斜杠(//)开头,用于注释单行代码。注释内容会被编译器忽略。

    // 这是一个单行注释
    int x = 10; // 这是另一个单行注释
    
  2. 多行注释:以斜杠星号(/)开头,以星号斜杠(/)结尾,用于注释多行代码。注释内容会被编译器忽略。

    /*
     * 这是一个多行注释
     * 可以跨越多行
     */
    int x = 10;
    /* 这是另一个多行注释 */
    
  3. 文档注释:以斜杠星号(/**)开头,以星号斜杠(*/)结尾,用于生成API文档。注释内容会被编译器和工具解析,并生成文档。

    /**
     * 这是一个文档注释
     * 可以包含对类、方法、参数等的描述
     */
    public class MyClass {
        /**
         * 这是一个文档注释
         * @param x 参数x
         * @return 返回值
         */
        public int myMethod(int x) {
            return x;
        }
    }
    

 17.三种转义字符

在Java中,有三种常用的转移语句,分别是:

1.break语句:用于终止当前循环或者switch语句,并跳出循环或者switch语句的执行。可以在循环或者switch语句内部的任何位置使用break语句。

例如,以下是使用break语句终止循环的示例:

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break; // 当i等于5时,终止循环
    }
    System.out.println(i);
}

2.continue语句:用于跳过当前循环的剩余部分,并继续下一次循环的执行。continue语句会立即跳到循环的下一次迭代。

例如,以下是使用continue语句跳过某次循环迭代的示例:

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        continue; // 当i等于5时,跳过本次循环迭代,继续下一次迭代
    }
    System.out.println(i);
}

3.return语句:用于从方法中返回值,并终止方法的执行。return语句可以在方法的任何位置使用,用于提前结束方法的执行。

例如,以下是使用return语句返回值并终止方法的示例

public int add(int a, int b) {
    return a + b; // 返回a和b的和,并终止方法的执行
}

18.一维数组二维数组的声明和创建

当声明和创建Java数组时,需要指定数组的类型、名称和大小(对于一维数组)或行数和列数(对于二维数组)。

一维数组的声明和创建:

// 声明一个整数类型的一维数组
int[] arr;

// 创建一个大小为5的整数类型的一维数组
arr = new int[5];

// 声明并创建一个大小为3的字符串类型的一维数组
String[] names = new String[3];

二维数组的声明和创建:

// 声明一个整数类型的二维数组
int[][] matrix;

// 创建一个3行4列的整数类型的二维数组
matrix = new int[3][4];

// 声明并创建一个2行3列的字符串类型的二维数组
String[][] grid = new String[2][3];

19.Java数组内存结构是什么

在Java中,数组是一个固定大小的连续内存块,用于存储相同类型的元素。数组的内存结构可以分为两部分:数组对象和数组元素。

数组对象:在Java中,数组是一个对象,它包含了有关数组的元数据,如数组的长度等。数组对象本身存储在堆内存中,并且它的引用存储在栈内存中。

数组元素:数组元素是实际存储数据的部分。元素的类型可以是任何Java数据类型,包括基本类型和引用类型。数组元素按照顺序存储在内存中,可以通过索引访问。

下面是一个示例代码,演示了Java数组的内存结构:

public class ArrayMemoryStructure {
    public static void main(String[] args) {
        // 创建一个整数数组
        int[] numbers = new int[5];
        
        // 数组对象存储在堆内存中
        // 数组对象的引用存储在栈内存中
        // 数组元素存储在堆内存中
        
        // 设置数组元素的值
        numbers[0] = 10;
        numbers[1] = 20;
        numbers[2] = 30;
        numbers[3] = 40;
        numbers[4] = 50;
        
        // 访问数组元素的值
        System.out.println(numbers[0]); // 输出: 10
        System.out.println(numbers[1]); // 输出: 20
        System.out.println(numbers[2]); // 输出: 30
        System.out.println(numbers[3]); // 输出: 40
        System.out.println(numbers[4]); // 输出: 50
    }
}

20.java 虚拟机主要四种内存存储区(堆,栈,程序计数器,方法区)

Java虚拟机(JVM)有四种主要的内存存储区域,分别是堆(Heap)、栈(Stack)、方法区(Method Area)和程序计数器(Program Counter Register)。

  1. 堆(Heap):堆是Java虚拟机管理的最大的一块内存区域,用于存储对象实例和数组。堆是所有线程共享的,它在JVM启动时被创建,并且在JVM关闭时销毁。堆被划分为新生代(Young Generation)和老年代(Old Generation)两部分,新生代又被划分为Eden空间、Survivor1空间和Survivor2空间。

  2. 栈(Stack):栈是用于存储局部变量、方法参数和方法调用的信息的内存区域。每个线程在执行过程中都会创建一个栈帧(Stack Frame),用于存储方法的局部变量和操作数栈。栈帧随着方法的调用和返回而入栈和出栈。

  3. 方法区(Method Area):方法区用于存储类的结构信息,包括类的字段、方法、构造器、运行时常量池等。方法区是所有线程共享的,它在JVM启动时被创建,并且在JVM关闭时销毁。

  4. 程序计数器(Program Counter Register):程序计数器是一块较小的内存区域,它可以看作是当前线程所执行的字节码的行号指示器。每个线程都有一个独立的程序计数器,用于记录线程当前执行的位置。

 21.堆和栈存储的数据类型和特点

  1. 堆(Heap):堆是用于动态分配内存的区域,存储的是对象和数组。在堆中分配的内存需要手动释放,否则会造成内存泄漏。堆是线程共享的,可以被多个线程访问和修改。

  2. 栈(Stack):栈是用于存储局部变量和方法调用的信息的区域。每个线程都有自己的栈,栈中存储的是基本数据类型的变量和对象的引用。栈是自动分配和释放的,当一个方法执行完毕后,栈中的变量会自动被销毁。

22.数组的下标遍历

  1. 使用普通的for循环:
    int[] array = {1, 2, 3, 4, 5};
    for (int i = 0; i < array.length; i++) {
        System.out.println("Index: " + i + ", Value: " + array[i]);
    }
    

  2. 使用增强型for循环(也称为for-each循环)
    int[] array = {1, 2, 3, 4, 5};
    for (int element : array) {
        int index = Arrays.asList(array).indexOf(element);
        System.out.println("Index: " + index + ", Value: " + element);
    }
    

23.冒泡排序

import java.util.Arrays;

/**
 * @author tian
 */
public class test2 {
    public static void  bubbleSort(int[] arr){
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-1-i; j++) {
                if (arr[j]>arr[j+1]){
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                }
            }
        }
    }
    public static void main(String[] args) {
        int[] arr1 = {12,13,1,31,3,13,1123};
        bubbleSort(arr1);
        System.out.println(Arrays.toString(arr1));
    }
}

 24.对象创建的语法

在Java中,对象的创建和使用涉及以下几个方面的语法和用法:

  1. 创建对象:使用new关键字创建对象,并调用构造函数初始化对象的属性。例如:
    ClassName objectName = new ClassName(); // 创建一个对象
  2. 访问对象的属性:使用对象名加点操作符.来访问对象的属性。例如:
    objectName.propertyName = value; // 设置对象的属性值 
    System.out.println(objectName.propertyName); // 输出对象的属性值
  3. 调用对象的方法:使用对象名加点操作符.来调用对象的方法。例如:
    objectName.methodName(); // 调用对象的方法

  4. 构造函数:构造函数用于初始化对象的属性。它与类名相同,没有返回类型,并可以有参数。例如:
    public class ClassName { 
        public ClassName() { 
        // 构造函数代码 
            } 
        }

  5. 对象的引用:Java中的对象是通过引用来访问的。对象变量存储的是对象的引用,而不是对象本身。例如:
    ClassName object1 = new ClassName(); // 创建对象并将引用赋值给变量 
    ClassName object2 = object1; // 将object1的引用赋值给object2

  6. 对象的销毁:Java的垃圾回收机制会自动回收不再被引用的对象。当一个对象不再被任何引用变量引用时,它就成为垃圾,会被垃圾回收器回收。

 25.对象的生命周期

Java对象的生命周期是指对象从创建到销毁的整个过程。下面是Java对象的生命周期的一些关键点:

  1. 创建对象:使用关键字new来创建一个对象,例如:MyClass obj = new MyClass();
  2. 初始化对象:在创建对象后,会调用对象的构造方法来进行初始化操作。
  3. 使用对象:可以通过对象引用来访问对象的属性和方法,进行各种操作。
  4. 对象可达性:对象在被引用时是可达的,当对象不再被引用时,它变得不可达。
  5. 垃圾回收:当对象不再可达时,Java的垃圾回收机制会自动回收这些不可达对象的内存空间。
  6. 销毁对象:在垃圾回收时,对象的finalize()方法会被调用,可以在该方法中进行一些资源释放的操作。

26.销毁对象的方法

在Java中,对象的销毁是由垃圾回收器(Garbage Collector)自动处理的,开发人员无需手动销毁对象。当对象不再被引用时,垃圾回收器会自动回收该对象的内存。

Java中的垃圾回收器使用了不同的算法来确定对象是否可回收,最常用的是基于引用计数和可达性分析的算法。当对象不再被引用时,垃圾回收器会将其标记为可回收,并在适当的时候释放其占用的内存。

以下是一些与Java对象销毁相关的概念和方法:

  1. 引用计数:每个对象都有一个引用计数器,当有新的引用指向对象时,计数器加一,当引用被删除时,计数器减一。当计数器为零时,对象被认为是不可达的,可以被回收。

  2. 可达性分析:通过从根对象(如线程栈、静态变量等)开始,通过引用链追踪对象的引用关系,判断对象是否可达。如果对象不可达,则可以被回收。

  3. finalize()方法:这是一个在对象被垃圾回收前调用的方法。它可以被重写以在对象被销毁前执行一些清理操作。然而,由于finalize()方法的执行时间是不确定的,不建议过度依赖它。

需要注意的是,虽然开发人员无需手动销毁对象,但可以通过将对象引用设置为null来显式地释放对象所占用的内存。这样一来,对象就变得不可达,垃圾回收器会在适当的时候回收对象。

 27.构造方法的定义和使用

当我们创建一个对象时,构造方法用于初始化对象的状态。在Java中,构造方法是一个特殊的方法,它具有与类相同的名称,并且没有返回类型。以下是关于Java构造方法的定义和使用的一些重要事项:

  1. 构造方法的命名必须与类名完全相同。
  2. 构造方法没有返回类型,包括void。
  3. 如果我们没有显式地定义构造方法,编译器将自动提供一个默认的无参构造方法。
  4. 如果我们定义了一个或多个构造方法,则默认构造方法将不再提供。
  5. 构造方法可以具有参数,这些参数用于初始化对象的成员变量。
  6. 构造方法可以重载,即在同一个类中可以有多个构造方法,只要它们的参数类型或数量不同即可。
  7. 使用new关键字调用构造方法来创建对象。

以下是一个示例,展示了如何定义和使用构造方法:

public class Person {
    private String name;
    private int age;
    
    // 无参构造方法
    public Person() {
        name = "John Doe";
        age = 0;
    }
    
    // 带参数的构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // 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;
    }
}

在上面的示例中,我们定义了一个Person类,它具有两个构造方法:一个是无参构造方法,另一个是带有参数的构造方法。我们可以使用这些构造方法来创建Person对象,并通过getter和setter方法访问和修改对象的属性。

28.面向对象的三个特征(分装,继承,多态)

Java面向对象的三个特征是封装、继承和多态。

  1. 封装(Encapsulation):封装是将数据和对数据的操作封装在一个单独的单元中,通过访问修饰符(如private、public等)来控制对数据的访问。封装可以隐藏实现细节,使代码更加模块化和易于维护。

  2. 继承(Inheritance):继承是指一个类可以继承另一个类的属性和方法。通过继承,子类可以重用父类的代码,并可以添加自己的特定功能。继承可以创建类的层次结构,使得代码更加可扩展和可重用。

  3. 多态(Polymorphism):多态是指同一个方法可以在不同的对象上产生不同的行为。多态允许使用一个父类类型的引用来引用子类对象,从而实现动态绑定和方法的重写。多态可以提高代码的灵活性和可扩展性。

29.类

当谈到Java编程时,类是一个重要的概念。类是Java中的基本构建块,用于创建对象。它是一个模板,用于定义对象的属性和行为。以下是关于Java类的一些重要信息:

  1. 类的定义:在Java中,类是使用关键字class定义的。以下是一个简单的类定义的示例:
    public class MyClass {
        // 类的成员变量
        private int myVariable;
        
        // 类的构造方法
        public MyClass(int value) {
            myVariable = value;
        }
        
        // 类的成员方法
        public void myMethod() {
            System.out.println("Hello, World!");
        }
    }
    
  2. 对象的创建:类用于创建对象。使用new关键字可以实例化一个类,并创建该类的对象。以下是一个创建MyClass对象的示例:
    MyClass obj = new MyClass(10);
    
  3. 成员变量:类可以包含成员变量,它们用于存储对象的状态。成员变量可以是任何数据类型,例如整数、字符串等。在上面的示例中,myVariable是一个成员变量。

  4. 构造方法:类可以包含构造方法,用于初始化对象的属性。构造方法的名称必须与类的名称相同。在上面的示例中,MyClass类有一个接受一个整数参数的构造方法。

  5. 成员方法:类可以包含成员方法,用于定义对象的行为。成员方法可以访问和操作类的成员变量。在上面的示例中,myMethod是一个成员方法。

  6. 封装性:类支持封装性,这意味着它可以隐藏对象的内部实现细节,并通过公共方法来访问和操作对象。在上面的示例中,myVariable被声明为私有(private),因此只能通过公共方法来访问。

类的种类:

当谈论Java类的种类时,可以从不同的角度进行分类。以下是一些常见的Java类的种类:

  1. Object类:Object是所有类的父类,它定义了一些常用的方法,如equals()、hashCode()和toString()等。

  2. 抽象类(Abstract Class):抽象类是不能被实例化的类,它可以包含抽象方法和非抽象方法。抽象类通常用作其他类的基类。

  3. 接口(Interface):接口是一种抽象类型,它定义了一组方法的签名,但没有实现。类可以实现一个或多个接口,并提供接口中定义的方法的具体实现。

  4. 枚举类(Enum Class):枚举类是一种特殊类型的类,它限制实例的数量,并提供一组预定义的常量。枚举类通常用于表示一组相关的常量。

  5. 内部类(Inner Class):内部类是定义在另一个类内部的类。它可以访问外部类的成员,包括私有成员。

  6. 匿名类(Anonymous Class):匿名类是没有显式名称的类,它通常用于创建临时的、只使用一次的类实例。

  7. 泛型类(Generic Class):泛型类是具有类型参数的类。它可以在定义类时指定类型参数,并在实例化时提供实际的类型。

这只是一些常见的Java类的种类,还有其他一些特殊类型的类,如单例类、异常类等。

 30.对象 

Java对象是Java程序中的基本单元,它是类的一个实例。对象具有状态和行为,并且可以通过调用其方法来执行操作。每个对象都有其自己的唯一标识符,可以用于在程序中引用它。

以下是一个简单的Java代码示例,演示了如何创建一个对象:

public class MyClass {
    private String name;
    
    public MyClass(String name) {
        this.name = name;
    }
    
    public void printName() {
        System.out.println("Name: " + name);
    }
    
    public static void main(String[] args) {
        MyClass myObject = new MyClass("John");
        myObject.printName();
    }
}

在上面的示例中,MyClass是一个类,myObjectMyClass的一个对象。通过new关键字和类的构造函数,我们创建了一个新的对象,并将其赋值给myObject变量。然后,我们可以调用对象的方法来执行操作。 

31.类和对象的关系

当谈到Java类和对象的关系时,对象是类的实例化。类是一个模板或蓝图,用于创建对象。类定义了对象的属性和行为。

以下是一些关于Java类和对象关系的重要事实:

  1. 类是对象的模板:类是一个抽象的概念,它定义了对象的属性和行为。它描述了对象应该具有的状态和行为。

  2. 对象是类的实例:对象是根据类定义创建的实体。可以使用关键字“new”创建对象。

  3. 类是对象的模板:可以根据类创建多个对象。每个对象都有自己的状态和行为,但它们共享相同的属性和方法。

  4. 类的成员:类可以包含成员变量和成员方法。成员变量是类的属性,它们用于存储对象的状态。成员方法是类的行为,它们用于执行操作。

  5. 对象的引用:可以使用对象的引用变量来访问对象的属性和方法。引用变量是指向对象的内存地址。

  6. 对象之间的交互:对象可以通过调用彼此的方法来进行交互。一个对象可以调用另一个对象的方法,以便共享信息和执行操作。

以下是一个简单的Java代码示例,演示了类和对象之间的关系:

// 定义一个类
class Person {
    // 成员变量
    String name;
    int age;
    
    // 成员方法
    void display() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }
}

// 创建对象并使用
public class Main {
    public static void main(String[] args) {
        // 创建对象
        Person person1 = new Person();
        
        // 设置对象的属性
        person1.name = "John";
        person1.age = 25;
        
        // 调用对象的方法
        person1.display();
    }
}

 32.访问修饰符

当在Java中定义类、方法或变量时,可以使用访问修饰符来控制对它们的访问权限。Java中有四种访问修饰符:public、private、protected和default(默认)。

  1. public:被public修饰的类、方法或变量可以从任何地方访问。
  2. private:被private修饰的类、方法或变量只能在同一个类中访问,其他类无法直接访问。
  3. protected:被protected修饰的类、方法或变量可以在同一个包中的其他类中访问,或者在不同包中的子类中访问。
  4. default(默认):如果没有指定任何访问修饰符,则默认为default修饰符。被default修饰的类、方法或变量可以在同一个包中的其他类中访问。

例如:

// 使用public修饰符
public class MyClass {
    public int publicVar; // 公共变量
    public void publicMethod() { // 公共方法
        // 代码逻辑
    }
}

// 使用private修饰符
public class MyClass {
    private int privateVar; // 私有变量
    private void privateMethod() { // 私有方法
        // 代码逻辑
    }
}

// 使用protected修饰符
public class MyClass {
    protected int protectedVar; // 受保护变量
    protected void protectedMethod() { // 受保护方法
        // 代码逻辑
    }
}

// 默认访问修饰符
class MyClass {
    int defaultVar; // 默认变量
    void defaultMethod() { // 默认方法
        // 代码逻辑
    }
}

 32.Java当中重写和重载的区别

当涉及到Java中的方法时,重写(Override)和重载(Overload)是两个常见的概念。

重写(Override)是指在子类中定义一个与父类中具有相同名称、参数列表和返回类型的方法。重写方法允许子类提供自己的实现,覆盖掉父类中的实现。重写方法必须具有相同的方法签名,包括方法名称、参数列表和返回类型。

以下是一个重写方法的示例:

class Animal {
    public void sound() {
        System.out.println("Animal makes sound");
    }
}

class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.sound(); // 输出 "Dog barks"
    }
}

重载(Overload)是指在同一个类中定义多个方法,它们具有相同的名称但参数列表不同。重载方法允许使用不同的参数来执行相似的操作。在调用重载方法时,编译器会根据传递给方法的参数类型和数量来决定要调用的方法。

以下是一个重载方法的示例:

class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    
    public double add(double a, double b) {
        return a + b;
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        System.out.println(calculator.add(2, 3)); // 输出 5
        System.out.println(calculator.add(2.5, 3.5)); // 输出 6.0
    }
}

33.给定一个字符串求字母,空格个数

public class Main {
    public static void main(String[] args) {
        String str = "Hello World";
        int letterCount = 0;
        int spaceCount = 0;

        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if (Character.isLetter(c)) {
                letterCount++;
            } else if (Character.isWhitespace(c)) {
                spaceCount++;
            }
        }

        System.out.println("Letter count: " + letterCount);
        System.out.println("Space count: " + spaceCount);
    }
}

这段代码中,我们首先定义了一个字符串str,然后使用一个循环遍历字符串中的每个字符。通过Character.isLetter(c)方法判断字符是否为字母,如果是则字母计数器letterCount加一;通过Character.isWhitespace(c)方法判断字符是否为空格,如果是则空格计数器spaceCount加一。最后输出字母和空格的个数。

34.缓冲区长度的计算

当涉及到Java缓冲区的长度计算时,通常是指计算缓冲区的容量或剩余空间。下面是一些与Java缓冲区长度计算相关的信息:

  1. 缓冲区容量计算:

    • 对于数组类型的缓冲区(如byte[]),可以使用数组的length属性来获取缓冲区的容量。
    • 对于ByteBuffer等直接缓冲区,可以使用capacity()方法获取缓冲区的容量。
  2. 缓冲区剩余空间计算:

    • 对于数组类型的缓冲区,可以使用length - position来计算剩余空间。
    • 对于ByteBuffer等直接缓冲区,可以使用remaining()方法获取剩余空间。

下面是一些示例代码:

  1. 缓冲区容量计算(数组类型缓冲区):
    byte[] buffer = new byte[1024];
    int capacity = buffer.length;
    System.out.println("缓冲区容量:" + capacity);
    
  2. 缓冲区容量计算(直接缓冲区):
    ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
    int capacity = buffer.capacity();
    System.out.println("缓冲区容量:" + capacity);
    

  3. 缓冲区剩余空间计算(数组类型缓冲区):
    byte[] buffer = new byte[1024];
    int position = 512;
    int remaining = buffer.length - position;
    System.out.println("剩余空间:" + remaining);
    
  4. 缓冲区剩余空间计算(直接缓冲区):
    ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
    buffer.position(512);
    int remaining = buffer.remaining();
    System.out.println("剩余空间:" + remaining);
    

 35.String类和StringBuffer类和String Builder 类的不同点和相同点

        String类、StringBuffer类和StringBuilder类都是用来处理字符串的类,它们有以下的不同点和相同点:

不同点:

  1. 可变性:String类是不可变的,即一旦创建就不能被修改。而StringBuffer类和StringBuilder类是可变的,可以对字符串进行增删改操作。
  2. 线程安全性:String类是线程安全的,因为它的方法都是同步的。而StringBuffer类是线程安全的,因为它的方法都是同步的。而StringBuilder类是非线程安全的,因为它的方法没有同步修饰符。
  3. 性能:由于String类是不可变的,每次对字符串进行修改时都会创建一个新的String对象,所以在频繁修改字符串时,使用StringBuffer类和StringBuilder类会更高效。

相同点:

  1. 都是用来处理字符串的类,提供了丰富的方法来操作字符串。
  2. 都可以使用"+"来进行字符串的拼接。
  3. 都继承自Object类,并且实现了CharSequence接口。

37.字符串的比较

  •  s1 == s2  c/c++
  • s1.equals(s2);     // 返回值是boolean
  • s1.equalsIgnoreCase(s2)    //忽略大小写,是否相同 返回值为boolean
  • s1.compareTo(s2)        //返回int    如果返回大于零 s1 > s2;如果返回值小于零 s1 < s2; 如果返回值等于零 即 s1 = s2
  • s1.compareToIgnore(s2);  s1和s2 忽略大小写 

38.字符串查找

方法 功能
char charAt(int index) 返回index位置上字符,如果index为负数或者越界,抛出indexoutofBoundsExcp
int indexOf(int ch) 返回ch第一次出现的位置,没有返回-1
int indexOf(int ch,int fromIndex) 从fromIndex位置开始找ch第一次出现位置,没有返回-1
int indexOf(String str) 返回str第一次出现的位置,没有返回-1
int indexOf(String str,String fromIndex) 从fromIndex位置开始找str第一次出现位置,没有返回-1
int lastIndexOf(int ch) 返回ch第一次出现的位置,没有返回-1
int lastIndexOF(int ch,int fromIndex) 从fromIndex位置开始找ch第一次出现位置,没有返回-1
int lastIndexOf(String str) 返回str第一次出现的位置,没有返回-1
int lastIndexOF(String str,String fromIndex) 从fromIndex位置开始找str第一次出现位置,没有返回-1

 39.数值和字符串转换  valueOf()

String str = String.valueOf(123);

将字符串转换为整数

int val1 = Integer.parseInt("123");

double val2 = Double.parseDouble("12.25");

40.大小写的转换

s1.toUpperCase();    //转大写

s2.toLowerCase();  //转小写

41.字符串转数组

//字符串转数组

char[ ]  chars = str1.toCharArray();

//数组转字符串

String s2 = new String(ch); 

42.StringBuilder和StringBuffer 区别 

当涉及到字符串的拼接和修改时,Java提供了两个主要的类:StringBuilder和StringBuffer。它们的主要区别在于线程安全性和性能。

  1. 线程安全性:

    • StringBuffer:StringBuffer是线程安全的,可以在多个线程中同时使用,因为它的方法都是同步的(synchronized)。
    • StringBuilder:StringBuilder是非线程安全的,不能在多个线程中同时使用,因为它的方法不是同步的。
  2. 性能:

    • StringBuffer:由于StringBuffer的方法都是同步的,所以在多线程环境下使用时,会有额外的开销。但是在单线程环境下,其性能与StringBuilder相当。
    • StringBuilder:由于StringBuilder的方法不是同步的,所以在单线程环境下,其性能比StringBuffer更好。

所以,如果你的代码在单线程环境下使用,建议使用StringBuilder,因为它的性能更好。如果你的代码在多线程环境下使用,建议使用StringBuffer,因为它是线程安全的。

你可能感兴趣的:(java,jvm,开发语言)