Java基础笔记（面向对象中级）

已于 2023-04-12 00:48:21 修改
阅读量85 收藏
点赞数
分类专栏： Java SE 文章标签： java intellij-idea 开发语言
于 2022-05-31 17:11:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sdjgh/article/details/125069505
版权

7 面向对象(中级)

文章目录

7.0 IDEA

  • 常用快捷键：
    1. command + d 删除当前行
    2. command + option + 向下光标 向下复制当前行
    3. option + / 补全代码
    4. command + / 注释
    5. option + enter 导入该行的类
    6. command + option + L 格式化代码
    7. control + R 运行
    8. optio + A 构造器
    9. control + H 查看继承关系
    10. command + B 定位方法
    11. .var 自动变量名
    12. Command + option + T 环绕方式
  • 常用模版快捷键
    1. fori 遍历
    2. itar 遍历数组
    3. iter 增强遍历
    4. sout 打印换行

7.1 包

  • 基本语法：

    Package 包名

  • 包的命名：
    • 只能包含数字、字母、下划线、小圆点，但不能用数字开头，不能是关键字或保留字
  • 命名规范：
    • 小写字母＋小圆点一般是 com.公司名.项目名.业务模块名
  • 引入包：
    1. import java.uti Scanner；就只是引入一个类Scanner
    2. import java.util*：1/ 表示将java.util 包所有都引入
  • 注意事项和细节：
    1. package 的作用是声明当前类所在的包，需要放在类的最上面，一个类中最多只有一个package
    2. import指令 位置放在package的下面，在类定义前面,可以有多句目没有顺序要求

7.2 访问修饰符

  • 基本介绍：

    java提供四种访问控制修饰符号，用于控制方法和属性(成员变量)的访问权限(范围)

  • 访问权限⭐️⭐️：

    1. 公开级别：用public修饰,对外公开

    2. 受保护级别：用protected修饰，对子类和同一个包中的类公开

    3. 默认级别：没有修饰符号，向同一个包的类公开

    4. 私有级别：用private修饰,只有类本身可以访问，不对外公开

      访问级别访问修饰符同类同包子类不同包
      公开public✅✅✅✅
      受保护protected✅✅✅❌
      默认无✅✅❌❌
      私有private✅❌❌❌
  • 注意事项和细节：
    1. 修饰符可以用来修饰类中的属性，成员方法以及类
    2. 只有默认的和public才能修饰类，并目遵循上述访问权限的特点
    3. 子类待定
    4. 成员方法的访问规则和属性完全样

7.3 封装⭐️

  • 基本介绍：

    封装(encapsulation)就是把抽象出的数据[属性]和对数据的操作方法封装在一起数据被保护在内部，程序的其它部分只有通过被授权的操作（方法），才能对数据进行操作

  • 封装步骤：
    1. 将属性进行私有化private[不能直接修改属性]
    2. 提供一个公共的(public)set方法，用于对属性判断井赋值
      public void setxxx(类型 参数名){
      加入数据验证的业务逻辑;
      属性 = 参数名;}
    3. 提供个公共的(public)get方法，用于获取属性的值
      public 数据类型 getXxxx(){
      return XX;}

7.4 继承⭐️

  • 基本介绍：

    继承可以解决代码复用，当多个类存在相同的属性(变量)和方法时,可以以这些类中抽象出交类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends来声明继承父类即可

  • 基本语法：
    class 子类 extends 父类{}
  • 注意事项和细节：

    1. 子类继承了所有的属性和方法，非私有的属性和方法可以在子类直接访问，但是私有属性和方法不能在子类直接访问，要通过父类提供公共的方法去访问

    2. 子类必须调用父类的构造器，完成父类的初始化

    3. 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用 super 去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过

    4. 指定去调用父类的某个构造器，则显式的调用一下：super(参数列表)

    5. super在使用时，必须放在构造器第一行(super只能在构造器中使用)

    6. super()和this()都只能放在构造器第一行，因此这两个方法不能共存在一个构造器

    7. java所有类都是Object类的子类

    8. 父类构造器的调用不限于直接父类！将一直往上追潮直到Object类

    9. 子类最多只能继承一个父类(指直接继承)，即java中是单继承机制

    10. 不能滥用继承，子类和父类之间必须满足 is-a 的逻辑关系

      public class TopBase { //父类是Object

    public TopBase() {
        //super(); Object的无参构造器
        System.out.println("构造器TopBase() 被调用...");//1
    }
}


      public class Base extends TopBase { //父类
    //4个属性
    public int n1 = 100;
    protected int n2 = 200;
    int n3 = 300;
    private int n4 = 400;

    public Base() { //无参构造器
        System.out.println("父类Base()构造器被调用....");
    }
    public Base(String name, int age) {//有参构造器
        //默认super()
        System.out.println("父类Base(String name, int age)构造器被调用....");
    }
    public Base(String name) {//有参构造器
        System.out.println("父类Base(String name)构造器被调用....");
    }
    //父类提供一个public的方法,返回了n4
    public int getN4() {
        return n4;
    }
    public void test100() {
        System.out.println("test100");
    }
    protected void test200() {
        System.out.println("test200");
    }
    void test300() {
        System.out.println("test300");
    }
    private void test400() {
        System.out.println("test400");
    }
    //call
    public void callTest400() {
        test400();
    }
}

      /输入ctrl + H 可以看到类的继承关系
public class Sub extends Base { //子类

    public Sub(String name, int age) {
        //1. 调用父类的无参构造器, 如下或者 什么都不写,默认就是调用super()
        //super();//父类的无参构造器
        //2. 调用父类的 Base(String name) 构造器
        //super("hsp");
        //3. 调用父类的 Base(String name, int age) 构造器
        super("king", 20);

        //细节：super在使用时，必须放在构造器第一行
        //细节: super() 和 this() 都只能放在构造器第一行，因此这两个方法不能共存在一个构造器
        //this() 不能再使用了
        System.out.println("子类Sub(String name, int age)构造器被调用....");
    }

    public Sub() {//无参构造器
        //super(); //默认调用父类的无参构造器
        super("smith", 10);
        System.out.println("子类Sub()构造器被调用....");
    }
    //当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器
    public Sub(String name) {
        super("tom", 30);
        //do nothing...
        System.out.println("子类Sub(String name)构造器被调用....");
    }

    public void sayOk() {//子类方法
        //非私有的属性和方法可以在子类直接访问
        //但是私有属性和方法不能在子类直接访问
        System.out.println(n1 + " " + n2 + " " + n3);
        test100();
        test200();
        test300();
        //test400();错误
        //要通过父类提供公共的方法去访问
        System.out.println("n4=" + getN4());
        callTest400();//
    }
}
  • 继承本质：

    子对象创建完成，建立查找关系

  • 继承内存图⭐️：

7.5 多态⭐️⭐️

7.5.1多态

  • 基本介绍：

    方法或对象具有多种形态，是面向对象的第三大特征，多态是建立在封装和继承基础之上的

  • 多态具体体现
    • 方法的多态
      1. 重写和重载就是体现多态
    • 对象的多态
      1. 一个对象的编译类型和运行类型可以不一致
      2. 编译类型在定义对象时，就确定了，不能改变
      3. 运行类型是可以变化的
      4. 编译类型看定义时 = 号 的左边，运行类型看 = 号的 右边
  • 注意事项和细节：

    • 向上转型

      1. 本质：父类的引用指向了子类的对象
      2. 语法：父类类型 引用名 = new 子类类型();
      3. 特点：编译类型看左边，运行类型看右边
      4. 可以调用父类中的所有成员(需遵守访问权限)
      5. 不能调用子类特有成员
      6. 最终运行效果看子类的具体实现

    • 向下转型

      1. 本质：把指向子类对象的父类引用，转成子类对象的子类引用
      2. 语法：子类类型 引用名 = (子类类型) 父类引用;
      3. 只能强转父类引用，不能强转父类对象
      4. 父类的引用必须指向的是当前目标类型的对象
      5. 当向下转型后，可以调用子类类型中所有的成员

    • 属性

      1. 属性没有重写，属性的值看编译类型

      2. instance of 比较较操作符，用于判断对象的运行类型是否为XX类型或XX类型的子类型

        public class PolyDetail {
    public static void main(String[] args) {

        //向上转型: 父类的引用指向了子类的对象
        //语法：父类类型引用名 = new 子类类型();
        Animal animal = new Cat();
        Object obj = new Cat();//可以吗? 可以 Object 也是 Cat的父类

        //向上转型调用方法的规则如下:
        //(1)可以调用父类中的所有成员(需遵守访问权限)
        //(2)但是不能调用子类的特有的成员
        //(#)因为在编译阶段，能调用哪些成员,是由编译类型来决定的
        //animal.catchMouse();错误
        //(4)最终运行效果看子类(运行类型)的具体实现, 即调用方法时，按照从子类(运行类型)开始查找方法
        //，然后调用，规则我前面我们讲的方法调用规则一致。
        animal.eat();//猫吃鱼..
        animal.run();//跑
        animal.show();//hello,你好
        animal.sleep();//睡

        //老师希望，可以调用Cat的 catchMouse方法
        //多态的向下转型
        //(1)语法：子类类型 引用名 =（子类类型）父类引用;
        //问一个问题? cat 的编译类型 Cat,运行类型是 Cat
        Cat cat = (Cat) animal;
        cat.catchMouse();//猫抓老鼠
        //(2)要求父类的引用必须指向的是当前目标类型的对象
        Dog dog = (Dog) animal; //可以吗？

        System.out.println("ok~~");
    }
}

        public class PolyDetail02 {
    public static void main(String[] args) {
        //属性没有重写之说！属性的值看编译类型
        Base base = new Sub();//向上转型
        System.out.println(base.count);// ？ 看编译类型 10
        Sub sub = new Sub();
        System.out.println(sub.count);//?  20
    }
}

class Base { //父类
    int count = 10;//属性
}
class Sub extends Base {//子类
    int count = 20;//属性
}

        public class PolyDetail03 {
    public static void main(String[] args) {
        BB bb = new BB();
        System.out.println(bb instanceof  BB);// true
        System.out.println(bb instanceof  AA);// true

        //aa 编译类型 AA, 运行类型是BB
        //BB是AA子类
        AA aa = new BB();
        System.out.println(aa instanceof AA);
        System.out.println(aa instanceof BB);

        Object obj = new Object();
        System.out.println(obj instanceof AA);//false
        String str = "hello";
        //System.out.println(str instanceof AA);
        System.out.println(str instanceof Object);//true
    }
}

class AA {} //父类
class BB extends AA {}//子类

7.5.2 动态绑定机制⭐️⭐️

  • 当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定

  • 当调用对象属性时，没有动态綁定机制，哪里声明，哪里使用()

    public class DynamicBinding {
    public static void main(String[] args) {
        A a = new B();
        System.out.println(a.sum());
        System.out.println(a.sum1());
    }
}

class A {
    public int i = 10;

    public int sum() {
        return getI() + 10;//当子类不存在sum方法时，会从父类找到sum方法，但动态绑定机制会找到子类的getI返回i值
    }

    public int sum1() {
        return i + 10;
    }

    public int getI() {
        return i;
    }
}

class B extends A {
    public int i = 20;

    public int sum() {
        return i + 20;
    }

    public int sum1() {
        return i + 10;
    }

    public int getI() {
        return i;
    }
}

7.5.3 多态的应用

  • 多态数组
    1. 多态数组：定义类型为父类类型，里面保存的实际元素类型为子类类型
    2. 多态参数：方法定义的形参类型为父类类型，实参类型允许为子类类型

7.6 Super

  • 基本介绍：

    super代表父类的引用，用于访问父类的属性、方法、构造器

  • 基本语法：
    1. 访问父类的属性，但不能访问父类的private属性
      super.属性名;
    2. 访问父类的方法，不能访问父类的private方法
      super.方法名(参数列表);
    3. 访问父类的构造器(只能放在构造器的第一句，只能出现一句)
      super(参数列表);
  • 注意事项和细节：
    1. 调用父类的构造器的好处 (分工明确，父类属性由父类初始化，子类的属性由子类初始化)
    2. 当子类中有和父类中的成员(属性和方法)重名时，为了访问父类的成员，必须通过super，如果没有重名，使用super、this、 直接访问效果相同
    3. super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员；如果多个基类(上级类)中都有同名的成员，使用super访问遵循就近原则
  • super和this
  • 实例：
    public class Base { //父类是Object

    public int n1 = 999;
    public int age = 111;
    public void cal() {
        System.out.println("Base类的cal() 方法...");
    }
    public void eat() {
        System.out.println("Base类的eat().....");
    }
}

    public class A extends Base{
    //4个属性
    //public int n1 = 100;
    protected int n2 = 200;
    int n3 = 300;
    private int n4 = 400;

    public A() {}
    public A(String name) {}
    public A(String name, int age) {}

//    public void cal() {
//        System.out.println("A类的cal() 方法...");
//    }

    public void test100() {
    }

    protected void test200() {
    }

    void test300() {
    }

    private void test400() {
    }
}

    public class B extends A {

    public int n1 = 888;

    //编写测试方法
    public void test() {
        //super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员；
        // 如果多个基类(上级类)中都有同名的成员，使用super访问遵循就近原则。A->B->C

        System.out.println("super.n1=" + super.n1);
        super.cal();
    }

    //访问父类的属性 , 但不能访问父类的private属性 [案例]super.属性名
    public void hi() {
        System.out.println(super.n1 + " " + super.n2 + " " + super.n3 );
    }
    public void cal() {
        System.out.println("B类的cal() 方法...");
    }
    public void sum() {
        System.out.println("B类的sum()");
        //希望调用父类-A 的cal方法
        //这时，因为子类B没有cal方法，因此我可以使用下面三种方式

        //找cal方法时(cal() 和 this.cal())，顺序是:
        // (1)先找本类，如果有，则调用
        // (2)如果没有，则找父类(如果有，并可以调用，则调用)
        // (3)如果父类没有，则继续找父类的父类,整个规则，就是一样的,直到 Object类
        // 提示：如果查找方法的过程中，找到了，但是不能访问， 则报错, cannot access
        //      如果查找方法的过程中，没有找到，则提示方法不存在
        //cal();
        this.cal(); //等价 cal

        //找cal方法(super.call()) 的顺序是直接查找父类，其他的规则一样
        //super.cal();

        //演示访问属性的规则
        //n1 和 this.n1 查找的规则是
        //(1) 先找本类，如果有，则调用
        //(2) 如果没有，则找父类(如果有，并可以调用，则调用)
        //(3) 如果父类没有，则继续找父类的父类,整个规则，就是一样的,直到 Object类
        // 提示：如果查找属性的过程中，找到了，但是不能访问， 则报错, cannot access
        //      如果查找属性的过程中，没有找到，则提示属性不存在
        System.out.println(n1);
        System.out.println(this.n1);

        //找n1 (super.n1) 的顺序是直接查找父类属性，其他的规则一样
        System.out.println(super.n1);

    }
    //访问父类的方法，不能访问父类的private方法 super.方法名(参数列表);
    public void ok() {
        super.test100();
        super.test200();
        super.test300();
        //super.test400();//不能访问父类private方法
    }
    //访问父类的构造器(这点前面用过)：super(参数列表);只能放在构造器的第一句，只能出现一句！
    public  B() {
        //super();
        //super("jack", 10);
        super("jack");
    }
}

7.7 方法重写(overwrite)

  • 基本介绍：

    子类的方法和父类方法一致，那么子类的方法覆盖了父类的方法

  • 注意事项和细节：
    1. 子类的方法的形参列表,方法名称，要和父类方法的形参列表,方法名称完全一样
    2. 子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类
    3. 子类方法大于等于父类方法的访问权限

7.8 Object类

  • ==

    1. 既可以判断基本类型，又可以判断引用类型

    2. 如果判断基本类型，判断的是值是否相等

    3. 如果判断引用类型，判断的是地址是否相等，即判定是不是同一个对象

      public class Equals01 {
    public static void main(String[] args) {
        A a = new A();
        A b = a;
        A c = b;
        System.out.println(a == c);
        B bObj = a;
        System.out.println(bObj == c);
    }
}

class A extends B{}
class B{}
  • equals
    1. equals:是Object类中的方法，只能判断引用类型
    2. 默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等
  • hashCode
    1. 提高具有哈希结构的容器的效率
    2. 两个引用，如果指向的是同一个对象，则哈希值肯定是一样的
    3. 两个引用，如果指向的是不同对象，则哈希值是不一样的
    4. 哈希值主要根据地址号来的，不能完全将哈希值等价地址
    5. 后面在集合中hashCode 如果需要的话，也会重写
  • toString
    1. 默认返回：全类名＋@+哈希值的十六进制
    2. 子类往往重写to String方法，用于返回对象的属性信息
    3. 重写toString方法，打印对象或拼接对象时，都会自动调用该对象的toString形式
    4. 当直接输出一个对象时，toString 方法会被默认的调用
  • finalize
    1. 当对象被回收时，系统自动调用该对象的finalize方法
    2. 子类可以重写该方法，做一些释放资源的操作
    3. 什么时候被回收：当某个对象没有任何引用时，则jvm就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用finalize方法
    4. 垃圾回收机制的调用，是由系统来決定(即有自己的GC算法)，也可以通过System.gc() 主动触发垃圾回收机制

7.9断点调试

  • 基本介绍：

    断点调试是指在程序的某一行设置一个断点，调试时，程序运行到这一行就会停住，然后你可以一步一步往下调试，调试过程中可以看各个变量当前的值，出错的话，调试到出错的代码行即显示错误，停下。进行分析从而找到这个Bug

  • 注意事项和细节：
    1. 在断点调试 过程中，是运行状态，是以对象的运行类型来执行的
    2. F7：跳入方法内
    3. F8：逐行执行代码
      shift+F8:跳出方法
    4. F9：resume，执行到下一个断点
恐高宇航员
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java笔记——08.面向对象（中级）
qq_43544021的博客
10-08 101
08.面向对象（中级） 常用IDEA快捷键（有部分自行定义） 删除当前行：ctrl+D 复制当前行至下一行：ctrl+Y 补全代码：alt+/ 添加注释和取消注释：ctrl+/ 导入该行需要的类：alt+enter 快速格式化代码：ctrl+alt+L 快速运行程序：alt+R 生成构造方法：alt+insert 查看一个类的层级关系：ctrl+H 定位到具体的方法：ctrl+B 自动分配变量：alt+enter .var 修饰符 本类 同包 子类 不同包 public ✓ ✓ ✓
Java学习笔记之面向对象编程(中级部分)
Mr_zta的博客
03-27 695
1 包 1.1 包的三大作用 1）区分相同名字的类 2）当类很多时，可以很好的管理类 3）控制访问范围 1.2 包的命名 命名规则：只能包含数字、字母、下划线、小圆点，但不能用数字开头，不能是关键字或保留字。 命名规范： 1）一般是小写字母+小圆点 2）一般是：com.公司名.项目名.业务模块名 如：com.hspedu.oa.controller 1.3 常用的包 1）java.lang.* //lang包是基本包，默认引用，不需要再引入 2）java.util.* //util包是系统提供的工具包 3）
java基础笔记04-面向对象
weixin_42139800的博客
01-22 429
java基础笔记04-面向对象中级、继承本质
Java基础学习笔记03——Java面向对象中级
QiuShuiLianDong的博客
09-11 149
2021_09_09
JAVA学习笔记——第七章 面向对象中级（一）
showy0的博客
07-24 1809
JAVA学习笔记——第七章 面向对象中级（一）包含IDEA、包、访问修饰符、面向对象三大特Object类和断点调试等基础内容。
JAVA学习笔记-第七章 面向对象中级（二）
08-17
JAVA学习笔记-第七章 面向对象中级（二）
软件设计师中级王勇老师课程笔记-12面向对象程序设计
07-26
王勇老师的这门课程笔记全面覆盖了软件设计师中级考试所需掌握的核心知识领域，不仅包括了计算机组成与体系结构、操作系统、数据库系统等基础知识，还涉及到了面向对象编程、UML、数据流图等高级主题。通过学习这些...
韩顺平编写的java学习笔记(全)
10-20
1. **Java面向对象编程**：与Java SE相似。 2. **数据库编程**：重点在于使用JDBC连接数据库。 3. **HTML/CSS/JavaScript**：前端开发技能，通常与Java后端配合使用。 #### Java EE中级部分 - **Servlets**：处理...
JAVA基础：数据类型、命名规范
weixin_53755148的博客
09-05 1133
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
浅析synchronized锁升级的原理与实现 1
水w的博客
09-01 1235
浅析synchronized锁升级的原理与实现
计算机毕业设计选题推荐-任务管理系统-项目任务分配系统-Java/Python项目实战
IT研究室的博客
09-03 791
随着信息化技术的迅猛发展，各类企业和组织越来越依赖于高效的任务管理系统以保证其日常运营的顺利进行。根据IDC（国际数据公司）发布的报告显示，全球企业在数字化转型上的投入已达数千亿美元，其中相当一部分资金用于提升企业内部的管理效率。任务管理系统作为企业信息化的重要组成部分，能有效帮助企业分配、监控和反馈任务，从而提高工作效率。然而，尽管市场上已有多种任务管理系统，它们在功能、用户体验和适用性上存在显著差异。
基于JavaWeb开发的JavaSpringboot+Vue实现前后端分离房屋租赁系统
最新发布
央顺科技官方博客
09-05 386
2021年处于信息科技高速发展的大背景之下。在今天，缺少手机和电脑几乎已经成为不可能的事情，人们生活中已经难以离开手机和电脑。针对增加的成本管理和操作,各大商家非常有必要建立自己的网上房屋租赁平台系统，这既可以让更多的人体验到网络所带来的方便，也有助于提高房屋的租赁。在经过几十年的高速发展后，互联网已成为最流行、最普及的媒体，每天的信息流量甚至能比得上过去十年。其以便捷的信息交换、快速的沟通速度，悄然地改变着会员的消费方式。
数据访问：JPA
hhgh_的博客
09-02 1001
其二，Sun希望整合ORM 技术，实现统一的 API调用接口。@Table（name=“”,catalog=“”,schema=“”）可选，用来标注一个数据库对应的实体类，数据库中创建的表明默认和类名一致，通常和@Entity配合使用，只能标注在实体的class定义处，表示实体对应的数据库表的信息。@Entity(name=“EntityName”)必须，用来标注一个数据库表对应的实体，数据库中创建的表明默认和类名一致，其中，name可选，对应数据库中的一个表，使用此注解标记Pojo是一个JPA实体。
MapStruct-Java实体转换利器
m0_63622279的博客
09-02 513
MapStruct 是一个用于生成映射器接口的代码生成库，主要用于简化 Java 对象之间的转换过程。在处理不同模型之间数据转换时，MapStruct 可以自动生成实现类减少手工转换逻辑的工作量。使用场景：各种模型之间的转换。BODTOVOPOJO引入mapstruct的pom依赖定义mapper接口（注意，这里不是MyBatis的Mapper哦），使用@Mapper注解标记，并在接口中声明映射方法。编写映射方法，（从xxxO转换为yyyO,模型之间的转换）在业务层中使用Mapper。
Address localhost:1099 is already in use：tomcat频繁重启端口占用问题
qq_63535554的博客
09-05 373
​短时间内频繁运行tomcat服务器​，端口占用问题。
JavaWeb（基于SpringBoot开发）全总结（1）
2302_81420820的博客
09-02 988
再到spring boot中去设置，当我们遇到报错不要紧，我们直接再复制我们在DG上面写的sql语句，到idea那个数据库那里再运行一次，2.由于使用不同开发工具开发出来的略有不同，导致不能够互通，所以国际规定，使用maven创建的项目为统一标准结构，也就是下图所示的结构。还有我们写的案例里面的mapper层写的sql语句的新增，删除，等等操作，都是基于mybatis来实现的。例如：传入的是路径参数，json格式的参数等等，根据不同的参数我们使用不同的注解。
java后端开发-Mybatis连接数据库步骤
weixin_73355603的博客
09-02 1835
🎙座右铭：得之坦然，失之淡然。💎擅长领域：前端是的，我需要您的：是我持续下去的动力！先看看目录，是不是IDEA的配置，数据库mysql或者其他的数据库这套方法都适合的。
基于Java+Springboot+Vue+elememt宠物用品商城系统设计实现
央顺科技官方博客
08-31 1380
随着信息技术的不断发展，我们现在已经步入了信息化的时代了，而信息时代的代表便是网络技术的日渐成熟，而现在网络已经和我们的生活紧密的联系起来了，我们不敢想象没有网络我们的生活会像怎么样，也许就像食物中没有调料现在的生活离开了网络会变得索然无味。通过网络我们可以足不出户的做许多事情，例如工作、娱乐、学习，交友和购物等等许多我们数之不尽的事情，而就是因为网络我们的生活变得多姿多彩，或许有时甚至帮我们省下不少的时间和给予了我们更多的机遇。宠物网上商城对我们来说就有这些意义。
【计算机毕业设计】高校课堂教学管理系统
weixin_47772925的博客
09-04 1057
2.1Java是由SUN公司推出，该公司于2010年被oracle公司收购。Java本是印度尼西亚的一个叫做爪洼岛的英文名称，也因此得来java是一杯正冒着热气咖啡的标识。Java语言在移动互联网的大背景下具备了显著的优势和广阔的前景，它是面向对象的，分布式的，动态的，具有平台无关性、安全性、健壮性。Java语言的基本语句语法和C++一样，但是它面向对象的技术更加彻底，因为Java要求将所有的内容都必须封装成类，把类作为程序的基本单位。由于不允许类外有变量、方法。
达内JAVA学习笔记：面向对象基础与设计原则
Java学习笔记是达内教育提供的全面指南，特别适合初级到中级的学习...达内的Java学习笔记提供了一个扎实的基础，涵盖了从概念理解到实践应用的全过程，帮助读者建立起对面向对象编程的理解，并熟练掌握Java语言的运用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

恐高宇航员

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值