面向对象编程-Java

面向对象编程

面向对象 & 面向过程

面向过程思想（线性思维）

  • 步骤清晰简单，第一步做什么，第二步做什么……
  • 面向过程适合处理一些较为简单的问题

面向对象思想

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

队医描述复杂的事务，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微规操作，仍需要面向过程的思路去处理。

什么叫面向对象

  • 面向对象编程（Object-Oriented Programming，OOP）
  • 面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据
  • 抽象
  • 三大特性
    • 封装
    • 继承
    • 多态
  • 从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象
  • 从代码运行角度考虑是先有类后有对象。类是对象的模板

方法

  • 方法的定义
    • 修饰符
    • 返回类型
    • break：跳出switch，结束循环 和 return 的区别
    • 方法名：注意规范就OK 见名知意
    • 参数列表：（参数类型，参数名） …：可变长参数
    • 异常抛出：后面学习
package com.oop.demo01;

import java.io.IOException;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-03 1:32
 */
//Demo01 类
public class Demo01 {
    //main 方法
    public static void main(String[] args) {

    }
    /*
    修饰符 返回值类型   方法名（...）{
        方法体
        return 返回值;
    }
     */
    // return 结束方法，返回一个结果！
    public String sayHello(){
        return "Hello,world";
    }
    public void hello(){
        return;
    }
    public int max(int a,int b){
        return a>b?a:b; //三元运算符
    }
    // 数组下标越界：Arrayindexoutofbounds
    public void readFile(String file) throws IOException{

    }
}

  • 方法的调用：递归

    • 静态方法

    • 非静态方法

    • package com.oop.demo01;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-03 1:45
 */
//学生类
public class Student {
    //方法
    public void say(){
        System.out.println("学生说话了");
    }
}

package com.oop.demo01;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-03 1:45
 */
public class Demo02 {
    public static void main(String[] args) {
        // 静态方法 static
        // Student.say();
        // 非静态方法
        // 实例化这个类
        // 对象类型 对象名 = 对象值;
        Student student = new Student();

        student.say();
    }
    /*
    两个都不是静态方法，或者两个都是静态方法，则可以直接相互调用
    若静态方法调用非静态方法则会出错
    静态方法是和类一起加载的
    普通方法是类实例化之后才存在
     */
    public void a(){

    }
    public void b(){

    }
}

    • 形参和实参

    • package com.oop.demo01;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-03 1:56
 */
public class Demo03 {
    public static void main(String[] args) {
        // 调用方法的两种形式
        // 实际参数和形式参数的类型要对应
        int add = new Demo03().add(1,2);
        /*
        加上static修饰符
        int add = Demo03.add(1,2);
         */
        System.out.println();
    }
    public int add(int a,int b){
        return a+b;
    }
}

    • 值传递和引用传递

    • package com.oop.demo01;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-03 2:29
 */
// 值传递
public class Demo04 {
    public static void main(String[] args) {
        int a=1;
        System.out.println(a);
        Demo04.change(a);
        System.out.println(a);
    }
    // 返回值为空
    public static void change(int a){
        a = 10;
    }
}


package com.oop.demo01;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-03 2:33
 */
// 引用传递：对象，本质还是值传递
    // 对象，内存
public class Demo05 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);    //null
        change(person);
        System.out.println(person.name);
    }
    public static void change(Person person){
        // person是一个对象：指向的 ---> Person person = new Person(); 这是一个具体的人，可以改变属性！
        person.name = "caobo";
    }
}
// 一个文件里面只能有一个public class，但是可以有多个class
// 定义了一个Person类，有一个属性：name
class Person{
    String name;    //null
}

    • this关键字

类与对象的关系

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

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

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

    • 张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例。
    • 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念

创建与初始化一个对象

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

import java.sql.SQLOutput;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-03 2:51
 */
// 学生类
public class Student {
    // 属性：字段
    String name;    // null
    int age;    // 0

    // 方法
    public void study(){
        // this代表当前这个类
        System.out.println(this.name+"在学习");
    }
}

/*
Person ---> 身高，体重，国籍...
学程序好？对世界进行更好的建模！音乐，旅游

package com.oop.demo02;

import com.oop.demo02.Student;


// 一个项目应该只存在一个main方法
    public static void main(String[] args) {
        // 类是抽象的，需要被实例化
        // 类实例化后会返回一个自己的对象
        // student对象就是Student类的一个具体实例
        Student xiaoming = new Student();
        Student xh = new Student();
        xiaoming.name="小明";
        xiaoming.age=3;

        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);

        xh.name="小红";
        xh.age=3;
        System.out.println(xh.name);
        System.out.println(xh.age);
    }

 */
  • 类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：
    • 1.必须和类的名字相同
    • 2.必须没有返回值类型，也不能写void
package com.oop.demo02;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-03 3:09
 */
// java----> class
public class Person {
    //一个类即使什么都不写，他也会存在一个方法
    // 显示的定义构造器
    String name;
    // 实例化初始值
    // 1.使用new关键字，本质是在构造器
    // 2.用来初始化值
    public Person(){
        this.name="caobo";
    }
    //有参构造：一旦定义了有参构造，无参就必须显示定义
    public Person(String name){
        this.name = name;   // this.name代表对象本身的name，name是传递进来的name
    }
    // alt + insert快捷键，自动生成构造器
}
/*
public static void main(String[] args) {
        // new 实例化了一个对象
        Person person = new Person();
        Person person2 = new Person("狂神");

        System.out.println(person.name); //caobo
        System.out.println(person2.name); //狂神
    }
    构造器：
        1. 和类名相同
        2. 没有返回值
    作用：
        1. new 本质在调用构造方法
        2. 初始化对象的值
    注意点：
        1. 定义有参构造之后，如果想使用无参构造，显示的定义一个无参构造
    Alt + Insert
    this. = 
 */


package com.oop.Demo03;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-04 2:56
 */
public class Pet {
    public String name;
    public int age;
    // 无参构造
    public void shout(){
        System.out.println("叫了一声");
    }
}


package com.oop.demo02;

import com.oop.Demo03.Pet;
import com.oop.demo02.Student;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-03 2:52
 */
// 一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        Pet dog = new Pet();
        dog.name="丑橘";
        dog.age=3;
        dog.shout();
        System.out.println(dog.name);
        System.out.println(dog.age);
        Pet cat = new Pet();
    }
}

在这里插入图片描述

小结

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

封装、继承、多态。

封装

该露的露，该藏的藏

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

封装（数据的隐藏）

通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏

记住这句话就够了：属性私有，get/set

  1. 提高程序的安全性，保护数据
  2. 隐藏代码的实现细节
  3. 统一接口
  4. 系统的可维护性增加了
package com.oop.demo04;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-04 23:38
 */
// 类    private：私有
public class Student {
    // 属性私有
    private String name;// 名字
    private int id;// 学号
    private char sex;// 性别
    private int age;
    // 学习（）

    // 睡觉（）
    // 提供一些可以操作这个属性的方法
    // 提供一些public的get、set方法
    // get 获取这个数据
    public String getName(){
        return this.name;
    }
    // set 给这个数据设置值
    public void setName(String name){
        this.name=name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age>120||age<0) {    //不合法
            age=3;
        }else{
            this.age = age;
        }
    }
}



package com.oop.demo02;

import com.oop.Demo03.Pet;
import com.oop.demo04.Student;
/*
    1.提高程序的安全性，保护数据
    2.隐藏代码的实现细节
    3.统一接口
    4.系统的可维护性增加了
 */
/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-03 2:52
 */
// 一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        String name = s1.getName();
        s1.setName("caobo");
        System.out.println(s1.getName());
        s1.setAge(-1); // 不合法的
        System.out.println(s1.getAge());
    }
    // alt + insert   自动生成get、set方法
}

继承

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

extends的意思的“扩展”。子类是父类的扩展

JAVA中类只有单继承，没有多继承

  • 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等
  • 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示
  • 子类和父类之间，从意义上讲应该具有“is a”的关系
  • final修饰的类不能被继承，就没有子类了
package com.oop.demo05;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-05 0:37
 */
// Person 人:父类
    //在Java中，所有的类都默认继承Object类
    // public
    // protected
    // default
    // private 私有的是无法继承的
public class Person/* extends Object*/ {
    private int money = 10_0000_0000;

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    public void say(){
        System.out.println("说了一句话");
    }
}


package com.oop.demo05;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-05 0:37
 */
// 学生  is 人：派生类，子类
    // 子类继承父类，就会拥有父类的全部方法！
public class Student extends Person{
    // ctrl + h     继承树
}


package com.oop.demo05;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-05 0:38
 */
// Teacher is 人：派生类，子类
public class Teacher extends Person{
}

package com.oop.demo02;

import com.oop.Demo03.Pet;
import com.oop.demo05.Person;
import com.oop.demo05.Student;
/*
    1.提高程序的安全性，保护数据
    2.隐藏代码的实现细节
    3.统一接口
    4.系统的可维护性增加了
 */
/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-03 2:52
 */
// 一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();
        Person person = new Person();

    }
    // alt + insert   自动生成get、set方法
}

object类

super this

super注意点：
1.super调用父类的构造方法，必须在构造方法的第一个
2.super必须只能出现在子类的方法或构造方法中！
3.super和this不能同时调用构造方法！

Vs this：
1.代表的对象不同：
this:本身调用者这个对象
super：代表父类对象的引用
2.前提：
this：没有继承也可以使用
super：只能在继承条件下才可以使用
3.构造方法：
this()：本类的构造
super()：父类的构造

package com.oop.demo02;

import com.oop.Demo03.Pet;
import com.oop.demo05.Person;
import com.oop.demo05.Student;
/*
    1.提高程序的安全性，保护数据
    2.隐藏代码的实现细节
    3.统一接口
    4.系统的可维护性增加了
 */
/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-03 2:52
 */
// 一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        //student.test("秦将");
        //student.test1();

    }
    // alt + insert   自动生成get、set方法
}


package com.oop.demo05;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-05 0:37
 */
// 学生  is 人：派生类，子类
    // 子类继承父类，就会拥有父类的全部方法！
public class Student extends Person{
    // 隐藏代码 ：调用了父类的无参构造

    public Student() {
        // 默认调用父类的无参
        //super();    // 调用父类的构造器，必须在子类构造器的第一行
        this("hello"); // 调用子类的构造器，同样必须在子类构造器的第一行
        System.out.println("Student的无参构造执行了");
    }

    public Student(String name) {
        this.name = name;
    }

    // ctrl + h     继承树
    private String name = "caobo";
    public void print(){
        System.out.println("Student");
    }
    public void test1(){
        print();        // Student
        this.print();   // Student
        super.print();  // Person

    }
    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);


    }
}

package com.oop.demo05;

import javax.lang.model.element.NestingKind;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-05 0:37
 */
// Person 人:父类
    //在Java中，所有的类都默认继承Object类
    // public
    // protected
    // default
    // private 私有的是无法继承的
public class Person/* extends Object*/ {

    public Person(String name) {
        System.out.println("无参执行了");
    }

    protected String name="曹博";
    public void print(){
        System.out.println("Person");
    }
}

方法重写

重写：需要有继承关系，子类重写父类的方法!

  1. 方法名必须相同
  2. 参数列表必须相同
  3. 修饰符：范围可以扩大但不能缩小：public>protected>default>private
  4. 抛出的异常：范围可以被缩小，但不能扩大；ClassNotFoundException–>Exception(大)

重写，子类的方法和父类必须要一致；方法体不同；

为什么需要重写：

1.父类的功能子类不一定需要，或者不一定满足！
Alt + Insert：override

package com.oop.demo05;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-05 1:51
 */
// 重写都是方法的重写，和属性无关
public class B {
    public  void test(){
        System.out.println("B=>test");
    }
}


package com.oop.demo05;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-05 1:51
 */
// 继承关系
public class A extends B{
    // override 重写
    @Override   //注解：有功能的注释！
    public void test() {
        System.out.println("A=>test");
    }
}


package com.oop.demo02;

import com.oop.Demo03.Pet;
import com.oop.demo05.A;
import com.oop.demo05.B;
import com.oop.demo05.Person;
import com.oop.demo05.Student;
/*
    1.提高程序的安全性，保护数据
    2.隐藏代码的实现细节
    3.统一接口
    4.系统的可维护性增加了
 */
/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-03 2:52
 */
// 一个项目应该只存在一个main方法
public class Application {
    // 静态的方法和非静态的方法区别很大
    // 静态方法：// 方法的调用只和左边，定义的数据类型有关
    // 非静态：重写
    public static void main(String[] args) {
        // 方法的类型只和左边，定义的数据类型有关
        A a = new A();
        a.test();

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

多态

动态编译：类型：可扩展性

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

一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多（父类，有关系的类）

注意：多态是方法的多态，属性也没有多态

多态注意事项

  1. 多态是方法的多态，属性没有多态
  2. 父类和子类，有联系 String Person：类型转换异常：ClassCastException
  3. 存在的条件
    1. 有继承关系
    2. 子类重写父类方法
    3. 父类引用指向子类对象
  4. 以下不可重写
    1. static 方法，属于类，他不属于实例
    2. final 常量：
    3. private 方法：
package com.oop.Demo06;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-05 2:24
 */
public class Person {
    public void run(){
        System.out.println("run");
    }
}


package com.oop.Demo06;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-05 2:24
 */
public class Student extends Person{
    @Override
    public void run() {
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");
    }
}


package com.oop.demo02;
import com.oop.Demo06.Person;
import com.oop.Demo06.Student;

/*
    1.提高程序的安全性，保护数据
    2.隐藏代码的实现细节
    3.统一接口
    4.系统的可维护性增加了
 */
/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-03 2:52
 */
// 一个项目应该只存在一个main方法
public class Application {
    // 静态的方法和非静态的方法区别很大
    // 静态方法：// 方法的调用只和左边，定义的数据类型有关
    // 非静态：重写
    public static void main(String[] args) {

        // 一个对象的实际类型是确定的
        // new Student();
        // new Person();
        // 可以指向的引用类型就不确定了：父类的引用指向子类
        // Student 能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        // Person 父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();
        s2.run(); // 子类重写了父类的方法，执行子类的方法
        s1.run();
        // 对象能执行哪些方法，主要看对象坐标的类型，和右边关系不大！
        //s2.eat();
        ((Student) s2).eat(); // 高转低
        s1.eat();
    }
}

instanceof （类型转换） 引用类型，判断一个对象是什么类型~

  1. 父类的引用指向子类的对象
  2. 把子类转换为父类，向上转型：
  3. 把父类转化为子类，向下转型：强制转型
  4. 方便方法的调用，减少重复的代码！简洁

抽象：封装、继承、多态！ 抽象类，接口

package com.oop.Demo06;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-05 2:24
 */
public class Person {
    public void run(){
        System.out.println("run");
    }
}
package com.oop.Demo06;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-05 2:24
 */
public class Student extends Person{
    public void go(){
        System.out.println("go");
    }
}
/*
public static void main(String[] args) {
        // Object > String
        // Object > Person > Teacher
        // Object > Person > Student
        Object object = new Student();

        // System.out.println(X instanceof Y);  // 能不能编译通过，取决于XY之间是否存在父子关系

        System.out.println(object instanceof Student);  // true
        System.out.println(object instanceof Person);   // true
        System.out.println(object instanceof Object);   // true
        System.out.println(object instanceof Teacher);  // false
        System.out.println(object instanceof String);   // false
        Person person = new Student();
        System.out.println("==================");
        System.out.println(person instanceof Student);  // true
        System.out.println(person instanceof Person);   // true
        System.out.println(person instanceof Object);   // true
        System.out.println(person instanceof Teacher);  // false
        // System.out.println(person instanceof String);   // 编译报错

        Student student = new Student();
        System.out.println("==================");
        System.out.println(student instanceof Student);  // true
        System.out.println(student instanceof Person);   // true
        System.out.println(student instanceof Object);   // true
        //System.out.println(student instanceof Teacher);   // 编译报错
        //System.out.println(student instanceof String);    // 编译报错
    }
 */

package com.oop.Demo06;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-06 1:14
 */
public class Teacher extends Person{
}

package com;
import com.oop.Demo06.Person;
import com.oop.Demo06.Student;
import com.oop.Demo06.Teacher;

/*
    1.提高程序的安全性，保护数据
    2.隐藏代码的实现细节
    3.统一接口
    4.系统的可维护性增加了
 */
/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-03 2:52
 */
// 一个项目应该只存在一个main方法
public class Application {
    // 静态的方法和非静态的方法区别很大
    // 静态方法：// 方法的调用只和左边，定义的数据类型有关
    // 非静态：重写
    public static void main(String[] args) {
       // 类型之间的转化：基本类型转换    高->低 强转，低->高 不需要
        // 父->子  强制转换
        Person obj = new Student();
        // Student将这个对象转换为Student类型，我们就可以使用Student类型的方法了！
        ((Student) obj).go();
        new Student();
        Student student = new Student();
        // 低转高  子类转换为父类，可能会丢失自己的本来的一些方法
        Person person = student;
    }
}

Static关键字

package com.oop.demo07;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-06 1:58
 */
public class Person {
    //
    {
        // 匿名代码块
    }
    static {
        // 静态代码块
    }
    // 2. 赋初始值
    {
        System.out.println("匿名代码块");
    }
    // 1.
    static {
        System.out.println("静态代码块");
    }
    // 3.

    public Person() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person p1 = new Person();
        System.out.println("===============");
        Person p2 = new Person();
    }
}


package com.oop.demo07;


/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-06 1:46
 */
// static :
public class Student {
    private static int age; // 静态变量  多线程
    private double score; // 非静态变量
    public void run(){
        System.out.println("run");
        go(); // 非静态方法可以调用静态方法中的所有东西
    }
    public static void go(){
        System.out.println("go");
        //静态方法可以调用静态方法中的，不能调用非静态的
    }

    public static void main(String[] args) {
        Student s1 = new Student();

        System.out.println(s1.age);

        System.out.println(s1.score);
        System.out.println(Student.age);
        // System.out.println(Student.score);
        new Student().run();
        go();
    }
}


package com.oop.demo07;
// 静态导入包
//
import static java.lang.Math.random;
import static java.lang.Math.PI;
/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-06 2:03
 */
public class Test {
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
    }
}

抽象类

  • abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类。
  • 抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。
  • 抽象类，不能使用new关键字来创建对象，他是用来让子类继承的
  • 抽象方法，只有方法的声明，没有方法的实现，他是用来让子类实现的
  • 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类
package com.oop.demo08;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-11 23:56
 */
// abstract 抽象类：类（需要继承）extends:单继承~ 接口可以多继承
public abstract class Action {  //一旦里面有了抽象方法，这个类必须声明为抽象类
    // 约束~有人帮我们实现~
    // abstract,抽象方法，只有方法名字，没有方法的实现！
    public abstract void doSomething();
    // 1. 不能new这个抽象类，只能靠子类去实现它：约束！
    // 2. 抽象类中可以写普通的方法
    // 3. 抽象方法必须在抽象类中
    // 抽象的抽象：约束
    // 思考？new，存在构造器吗？
    // 存在的意义    抽象出来~   提高开发效率
    public void run(){
        System.out.println("run");
    }
}



package com.oop.demo08;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-11 23:59
 */
// 抽象类的所有方法，继承了它的子类，都必须要实现它的方法~除非这个子类也是抽象的~
public class A extends Action {
    @Override
    public void doSomething() {

    }
}

接口

  • 普通类：只有具体实现

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

  • 接口：只有规范！自己无法写方法专业的约束约束和实现分离：面向接口编程~

  • 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。如果你是好人，则必须干掉坏人；如果你是坏人，则必须欺负好人。

  • 接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。

  • OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如C++、Java、C#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象。

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

package com.oop.demo09;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-12 1:06
 */
// 抽象的思维~ Java 架构师~
// interface 定义的关键字，接口都需要有实现类
public interface UserService {

    // 常量~ public static final int AGE = 99;
    // 一般很少人在接口里面定义常量
    int AGE=99;
    // 接口中的所有定义的方法其实都是抽象的 public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}


package com.oop.demo09;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-12 1:13
 */
public interface TimeService {
    void timer();
}


package com.oop.demo09;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-12 1:10
 */
// 抽象类：extends
// 类可以实现接口 implements 接口
// 实现了接口的类，就需要重写接口中的方法~
// 多继承~利用接口实现多继承~
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() {

    }
}

接口的作用

  1. 约束
  2. 定义一些方法，让不同的人实现~ 10----> 1
  3. public abstrat
  4. public static final
  5. 接口不能被实例化
  6. implements可以实现多个接口
  7. 必须要重写就口中的方法~
  8. 总结博客

内部类

定义

内部类就是在一个类的内部再定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。

  1. 成员内部类
  2. 静态内部类
  3. 局部内部类
  4. 匿名内部类
  5. lambada
package com.oop.demo10;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-12 2:44
 */
public class Outer {

    private int id=10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    // public static class Inner{ 静态内部类，一旦加上static 就拿不到id了
    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        // 获得外部类的私有属性~
        public void getID(){
            System.out.println(id);
        }
    }
    // 局部内部类
    public void method(){
        class Inner{
            
        }
    }
}
// 一个java文件中只能有一个public class ，但是可以有多个class
class A{

}


package com.oop.demo10;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-12 2:57
 */
// 思想，操作，关键字
public class Test {
    public static void main(String[] args) {
        Apple apple = new Apple();
        // 没有名字初始化类,不用将实例保存到对象中,匿名内部类
        new Apple().eat();
        UserService userService = new UserService(){

            @Override
            public void hello() {

            }
        };
    }
}
class Apple{
    public void eat(){
        System.out.println("1");
    }
}
interface UserService{
    void hello();
}


package com;
import com.oop.demo10.Outer;

/*
    1.提高程序的安全性，保护数据
    2.隐藏代码的实现细节
    3.统一接口
    4.系统的可维护性增加了
 */
/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-03 2:52
 */
// 一个项目应该只存在一个main方法
public class Application {

    public static void main(String[] args) {
        // new
        Outer outer = new Outer();
        // 通过这个外部类来实例化内部类~
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getID();

    }
}

异常机制

Exception

什么是异常

  • 实际工作中，遇到的情况不可能是非常完美的。比如：你写某个模块，用户输入的不一定符合你的要求、你的程序要打开某个文件，这个文件可能不存在或者文件格式不对，你要读取数据库的数据，数据可能是空的等。我们程序再跑着，内存或硬盘可能满了。等等
  • 软件程序在运行过程中，非常可能遇到刚刚提到的这些异常问题，我们叫异常，英文是：Exception，意思是例外。这些，例外情况，或者叫异常，怎么让我们写的程序做出合理的处理。而不至于程序崩溃。
  • 异常指程序运行中出现的不期而至的各种情况，如：文件找不到、网络链接失败、非法参数等。
  • 异常发生在程序运行期间，它影响了正常的程序执行流程
package com.exception;


/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-14 22:57
 */
public class Demo01 {
    public static void main(String[] args) {
        new Demo01().a();

    }
    public void a(){
        b();
    }
    public void b(){
        a();
    }
}

// Exception in thread "main" java.lang.StackOverflowError

package com.exception;


/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-14 22:57
 */
public class Demo01 {
    public static void main(String[] args) {
        System.out.println(11/0);

    }

}
//Exception in thread "main" java.lang.ArithmeticException: / by zero
// 	at com.exception.Demo01.main(Demo01.java:12)
简单分类
  • 检查性异常
    • 最具代表性的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在的文件时，一个异常就发生了，这些异常在编译时不能被简单的忽略。
  • 运行时异常：
    • 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
  • 错误ERROR：
    • 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，他们在编译也检查不到的。
  • 异常处理框架

异常体系结构

  • Java把异常当作对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类
  • 在Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception

在这里插入图片描述

  • Error
    • Error类对象由Java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关
    • Java虚拟机运行错误（Virtual MachineError），当JVM不再有继续执行操作所需的内存时，将出现OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止；
    • 还有发生在虚拟机试图执行应用时，如类定义错误（NoClassDefFoundError）、链接错误（LinkageError）。这些错误是不可查的，因为他们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。
  • Exception
    • 在Exception分支中有一个重要的子类RuntimeException（运行时异常）
      • ArrayIndexOutOfBoundsException（数组下标越界）
      • NullPointerException（空指针异常）
      • ArithmeticException（算数异常）
      • MissingResourceException（丢失资源）
      • ClassNotFoundException（找不到类）
      • 等异常，这些异常是不检查异常，程序中可以选择捕获异常，也可以不处理。
    • 这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生
  • Error和Exception的区别：Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，Java虚拟机（JVM）一般会选择终止线程；Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常

Java异常处理机制

快捷键：ctrl + alt + t

异常处理的五个关键字

try、catch、finally、throw、throws

package com.exception;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-14 23:53
 */
public class test {
    public static void main(String[] args) {
        int a=1;
        int b=0;
        try {   // try监控区域
            System.out.println(a/b);
        }catch(ArithmeticException e){  // 捕获异常
            System.out.println("程序出现异常，变量b不能为0");
        }finally{   // 处理善后工作，
            System.out.println("finally");
        }
    }
}


package com.exception;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-14 23:53
 */
public class test {
    public static void main(String[] args) {
        int a=1;
        int b=0;
        // 假设要捕获多个异常：从小到大！
        
        try {   // try监控区域
            System.out.println(a/b);
        }catch(Error e){  // catch(想要捕获的异常类型！)捕获异常
            System.out.println("Error");
        }catch(Exception e){

            System.out.println("Exception");
        }catch(Throwable e) {

            System.out.println("Throwable");
        }finally{   // 处理善后工作
            System.out.println("finally");
        }
    }
    public void a(){b();};
    public void b(){a();};
}

只能捕获一个，就像if…elseif…elseif…else…，且下面必须比上面的范围广

finally 可以不要finally，假设IO，资源，关闭！

抛出异常

try

捕获异常

catch

处理异常

package com.exception;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-15 0:11
 */
public class Test2 {
    public static void main(String[] args) {
        int a=1;
        int b=0;
        try {
            new Test2().test(1,0);
        } catch (ArithmeticException e) {
            throw new RuntimeException(e);
        } finally {
        }
        // Ctrl Alt + T
        try {
            if(b==0){   // 主动抛出异常 throw throws
                throw new ArithmeticException();    // 主动抛出一个异常
            }
            System.out.println(a/b);
        } catch (Exception e) {
            // throw new RuntimeException(e);
            // System.exit(0); //手动结束程序
            e.printStackTrace();  //打印错误的信息
        } finally {

        }
    }
    // 假设这个方法中，处理不了这个异常，方法上抛出异常
    public void test(int a,int b) throws ArithmeticException{
        if(b==0){   // 主动抛出异常 throw throws
            throw new ArithmeticException();    // 主动抛出一个异常,一般在方法中使用
        }
        System.out.println(a/b);
    }
}

自定义异常

  • 使用Java内中的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需继承Exception类即可。
  • 在程序中使用自定义异常类，大体可以分为以下几个步骤：
    • 创建自定义异常类。
    • 在方法中通过throw关键字抛出异常对象
    • 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
    • 在出现异常方法的调用者中捕获并处理异常。
package com.exception.demo02;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-15 0:50
 */
// 自定义异常类
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 com.exception.demo02;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-15 0:58
 */
public class Test {
    // 可能会存在异常的方法
    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 {
            test(11);
        } catch (MyException e) {
            // throw new RuntimeException(e);
            // 增加一些处理异常的代码块
            System.out.println("MyException=>"+e);
        } finally {
        }
    }

}

总结

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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/431287.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

mybatis的xml文件如何配置能被识别

mybatis的xml文件如何配置能被识别

为了让MyBatis能够识别和使用XML Mapper文件&#xff0c;你需要确保这些文件被正确放置和配置。下面是确保MyBatis XML Mapper文件被识别的步骤&#xff1a; 1. 正确放置XML Mapper文件 通常&#xff0c;XML Mapper文件应该放在src/main/resources目录下。为了更好的组织这些…
阅读更多...
【STM32+OPENMV】二维云台颜色识别及追踪

【STM32+OPENMV】二维云台颜色识别及追踪

一、准备工作 有关OPENMV最大色块追踪及与STM32通信内容&#xff0c;详情见【STM32HAL】与OpenMV通信 有关七针OLED屏显示内容&#xff0c;详情见【STM32HAL】七针OLED(SSD1306)配置(SPI版) 二、所用工具 1、芯片&#xff1a;STM32F407ZGT6 2、CUBEMX配置软件 3、KEIL5 4…
阅读更多...
VUE读取静态文件技巧

VUE读取静态文件技巧

背景&#xff1a; 现在有一个文件123.jpg在assets目录&#xff0c;我需要在bbb.vue里面去引用他&#xff0c;直接使用../方法无法获取该文件&#xff0c;且页面不能正常显示。文件目录如下&#xff1a; 解决办法&#xff1a;使用require方法&#xff1a; require(../assets/1…
阅读更多...
基于springboot+vue的酒店管理系统

基于springboot+vue的酒店管理系统

博主主页&#xff1a;猫头鹰源码 博主简介&#xff1a;Java领域优质创作者、CSDN博客专家、阿里云专家博主、公司架构师、全网粉丝5万、专注Java技术领域和毕业设计项目实战&#xff0c;欢迎高校老师\讲师\同行交流合作 ​主要内容&#xff1a;毕业设计(Javaweb项目|小程序|Pyt…
阅读更多...
【STM32F103】WDG看门狗

【STM32F103】WDG看门狗

本系列在之前介绍时钟树的文章中有稍微提一下看门狗WDG&#xff08;Watch Door Dog&#xff09;。 简单来说&#xff0c;可以当成是一个计数器&#xff0c;一旦这个计数器溢出则单片机复位。因为我们需要每隔一段时间就把这个计数器的值清零&#xff08;喂狗&#xff09;。 I…
阅读更多...
C++命名空间

C++命名空间

在C/C中&#xff0c;变量&#xff0c;函数和和类这些名称都存在于全局作用域中&#xff0c;可能会导致很多冲突&#xff0c;使用命名空间的目的是对标识符的名称进行本地化&#xff0c;避免命名冲突或名字污染&#xff0c;namespace关键字就是解决这种问题的。如下程序并无问题…
阅读更多...
低代码平台开发实践：基于React的高效构建与创新【文末送书-29】

低代码平台开发实践：基于React的高效构建与创新【文末送书-29】

文章目录 背景低代码平台简介基于React的优势低代码平台的实际应用 低代码平台开发实践&#xff1a;基于React【文末送书-29】 背景 随着技术的不断进步和业务需求的日益复杂&#xff0c;低代码平台成为现代软件开发领域中备受关注的工具之一。在这个快节奏的时代&#xff0c;…
阅读更多...
C语言——结构体（位段）、联合体、枚举

C语言——结构体（位段）、联合体、枚举

hello&#xff0c;大家好&#xff01;我是柚子&#xff0c;今天给大家分享的内容是C语言中的自定义类型结构体、联合体以及枚举&#xff0c;有什么疑问或建议可以在评论区留言&#xff0c;会顺评论区回访哦~ 一、结构体 struct a.结构体声明 不同于数组的是&#xff0c;结构…
阅读更多...
16：00面试，16：06就出来了，问的问题过于变态了。。。

16：00面试，16：06就出来了，问的问题过于变态了。。。

从小厂出来&#xff0c;没想到在另一家公司又寄了。 到这家公司开始上班&#xff0c;加班是每天必不可少的&#xff0c;看在钱给的比较多的份上&#xff0c;就不太计较了。没想到2月一纸通知&#xff0c;所有人不准加班&#xff0c;加班费不仅没有了&#xff0c;薪资还要降40%…
阅读更多...
C++对象内存模型布局详解

C++对象内存模型布局详解

目录 本文主要内容如下&#xff1a; 最后还有一些问题&#xff1a; 一、理解虚函数表 二、对象模型概述 三、继承下的C对象模型 单继承&#xff1a; 多继承&#xff1a; 一般的多继承&#xff08;非菱形继承&#xff09;&#xff1a; 菱形继承&#xff1a; 五、虚继承…
阅读更多...
如何创建一个VUE3项目并使用Element UI插件

如何创建一个VUE3项目并使用Element UI插件

1.确保已经安装了Node&#xff1a; win R 打开控制面板&#xff0c;输入“node -v”回车。出现版本号信息&#xff0c;则安装成功&#xff0c;否则请移步安装。 Node.js安装及环境配置&#xff08;简单易懂&#xff01;&#xff09;_building: c:\program files\nodejs\node…
阅读更多...
基于SSM的学科竞赛管理系统。Javaee项目。ssm项目。

基于SSM的学科竞赛管理系统。Javaee项目。ssm项目。

演示视频&#xff1a; 基于SSM的学科竞赛管理系统。Javaee项目。ssm项目。 项目介绍&#xff1a; 采用M&#xff08;model&#xff09;V&#xff08;view&#xff09;C&#xff08;controller&#xff09;三层体系结构&#xff0c;通过Spring SpringMvcMybatisVueLayuiElemen…
阅读更多...
我的第②个出海工具站 - 2024年50个出海工具站计划

我的第②个出海工具站 - 2024年50个出海工具站计划

为了大家更好的使用各种出海工具。我上线了一版 出海工具导航 站点&#xff0c;经常使用的可以收藏下&#xff0c;我文内使用的网站都集成在了这里&#xff0c;非常使用。 随着AIGC的到来&#xff0c;2024年到了海外工具回暖的一年。今年计划上线50款出海工具站计划&#xff0c…
阅读更多...
嵌入式工程师函数变量，常用的命名规则（参考学习）

嵌入式工程师函数变量，常用的命名规则（参考学习）

很多工程师不注重平时编码习惯&#xff0c;比如命名规则&#xff0c;一会大写、一会小写&#xff0c;一会中文拼音&#xff0c;一会下划线等&#xff0c;导致自己写的代码自己都看不懂了。 今天就来分享一点关于软件代码常见的几种命名规则。 匈牙利命名法 匈牙利命名法广泛应…
阅读更多...
西安雁塔未来人工智能计算中心算力成本分析

西安雁塔未来人工智能计算中心算力成本分析

先看一例旧闻&#xff1a;西部“最强大脑”落户雁塔——30亿亿次超算能力助力创新之城建设 其中提到一期算力为 300PFLOPS FP16&#xff08;每秒30亿亿次半精度浮点计算&#xff09;&#xff0c;项目总投资约为19亿元。 这个算力是什么概念呢&#xff1f; 我们以深度学习训练中…
阅读更多...
使用sunshine和moonlight实现远程游戏串流

使用sunshine和moonlight实现远程游戏串流

过年回家想要打游戏&#xff0c;但是苦于家里没有电脑&#xff0c;又没办法把电脑搬回去&#xff0c;于是想到了使用串流的方式。 实现串流的软件有多种&#xff1a; moonlight。因为仅实现了 NVIDIA 的游戏串流协议&#xff0c;所以只支持 N 卡。Steam Link。支持 steam 的游…
阅读更多...
第五十回 插翅虎枷打白秀英 美髯公误失小衙内-mayfly-go：web 版 linux、数据库等管理平台

第五十回 插翅虎枷打白秀英 美髯公误失小衙内-mayfly-go：web 版 linux、数据库等管理平台

晁盖宋江和吴用到山下迎接雷横上山&#xff0c;宋江邀请雷横入伙&#xff0c;雷横以母亲年事已高为由拒绝了。 雷横回到郓城&#xff0c;听李小二说从东京新来了个表演的叫白秀英&#xff0c;吹拉弹唱跳&#xff0c;样样精通&#xff0c;于是雷横和李小二一起到戏院去看演出。…
阅读更多...
什么是AJAX？它的运用场景有哪些？

什么是AJAX？它的运用场景有哪些？

文章目录 前言一、什么是AJAX二、AJAX原理是什么三、为什么需要AJAX四、AJAX的使用五、AJAX的应用场景 前言 AJAX 即 Asynchronous Javascript And XML&#xff08;异步JavaScript和XML&#xff09;&#xff0c;是指一种创建交互式网页应用的网页开发技术。 AJAX 是一种用于创…
阅读更多...
首尔之春在线资源最新电影1080p高清

首尔之春在线资源最新电影1080p高清

打开下面这个链接就可以看到 首尔之春在线资源最新电影1080p高清 如果链接打不开&#xff0c;就复制下面的网址到浏览器打开 https://www.zhufaka.cn/liebiao/A09504AE3BF8BD06 用阿里云盘下载&#xff0c;下载完成之后&#xff0c;用迅雷播放 首尔之春在线资源最新电影10…
阅读更多...
NVMe管理命令为何不用SGL？-2

NVMe管理命令为何不用SGL？-2

在IO数据传输中&#xff0c;是否选择SGL可以根据自身场景的需要。SGL提供的是一种高效且灵活的方式来描述非连续的内存区域&#xff0c;这对于现代高性能存储系统至关重要&#xff0c;尤其是在处理大数据块或者随机小I/O操作时具有明显优势&#xff1a; 高效的数据传输&#xf…
阅读更多...
最新文章

Copyright @ 2022~2023